Linux Command Line

This guide gives you a solid foundation for using the Linux command line with confidence.

I recommend following along in your own terminal as you progress. The best way to learn the command line is by using it. Experiment with each command, try variations, and make it part of your workflow.

The examples in this guide use a Linux environment and Bash. Many of the commands also work on macOS and other Unix-like systems, although some options and behaviors may differ.

Who is this guide for?

This guide is designed for engineers, researchers, and developers who have a basic familiarity with Linux and core computing concepts. No prior experience with Bash scripting is required.

The Terminal

The Linux command line is often associated with the terminal, shell, and prompt. While these terms are sometimes used interchangeably, they refer to different parts of the system.

The terminal is essentially a text-based interface used to interact with the computer. Its origins go way back to the early 1950s with MIT’s Whirlwind I computer, the first to use a typewriter for input and a printer for output.

By the mid-1960s, more advanced display-based terminals like the IBM 2260 began to emerge. During this era, computers were massive machines known as mainframes, and users could connect to them remotely via individual terminals.

The IBM 2260 display-based terminal. Credit: Norsk Teknisk Museum.

These early terminals were quite simple: just a keyboard and a screen. They didn’t have the processing power to run programs on their own. Their sole purpose was to send whatever you typed to the central mainframe and then display the data they received back on the screen.

Today, the Linux command line provides a powerful interface for interacting with the computer. Instead of clicking on icons, you type commands into an application called the terminal. Working behind the scenes, a program known as the shell interprets your commands, understands your intent, and instructs the computer to perform the desired actions.

If you’re using Linux or macOS, the terminal is already available with common Linux commands. On Windows, install the Windows Subsystem for Linux (WSL). Setup instructions are available at learn.microsoft.com/windows/wsl.

Getting Started with the Terminal

When you launch the Terminal, you should see a shell prompt similar to this:

borges@linux:~ $

Let’s begin with the date command, which displays the current date and time:

borges@linux:~ $ date

Tue Jul 28 08:25:32 CEST 2025

A related command is cal, which displays a calendar for the current month:

borges@linux:~ $ cal

     July 2025
Su Mo Tu We Th Fr Sa
       1  2  3  4  5
 6  7  8  9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31

Note

In some cases, the shell prompt will be omitted to simplify the presentation of commands.

Navigation

These are the most important commands to help you navigate the file system.

Print working directory (pwd)

Print the current working directory:

pwd

List directory contents (ls)

List the contents of the current directory:

ls

List the contents of a specific directory:

ls /home

Tip

The ls command also supports options that modify its output format:

-a  Show all content, including hidden ones
-l  Show the contents in a long listing format
-h  With -l, show file size in KB, MB, GB, or TB
-R  List subdirectories recursively

The -l option displays the contents in long listing format with additional information:

ls -l /home

total 4
drwxr-x--- 6 borges borges 4096 Jul 28 10:25 borges

The output shows:

• d indicates that the entry is a directory
• rwxr-x--- are the permissions
• 6 is the number of hard links to the entry
• borges is the owner
• The second borges is the group
• 4096 is the size in bytes
• Jul 28 10:25 is the last modification date and time

To make the file size easier to read, add the -h option:

ls -lh /home

total 4.0K
drwxr-x--- 6 borges borges 4.0K Jul 28 10:25 borges

This next command uses the -a option to show all files, including hidden ones:

ls -alh /home/borges

total 40K
drwxr-x--- 6 borges borges 4.0K Jul 28 08:30 .
drwxr-xr-x 3 root   root   4.0K Jul 28 08:30 ..
-rw-r--r-- 1 borges borges 3.7K Mar 31  2024 .bashrc
-rw-r--r-- 1 borges borges  807 Mar 31  2024 .profile
drwx------ 2 borges borges 4.0K Jul 28 10:25 .ssh

Tip

The . refers to the current directory, /home/borges in this example, while .. refers to its parent directory, that is /home.

In Linux, hidden files and directories are represented by a dot at the beginning of their names, like the file .bashrc and the directory .ssh.

Change directory (cd)

borges@linux:~ $ cd /usr/bin

borges@linux: /usr/bin $

In this example we start in ~, which refers to the home directory, and move to /usr/bin.

Tip

Here are some useful symbols you can use with the cd command:

~   Home directory
-   Previous directory
.   Current directory
..  Parent directory

From /usr/bin, let’s navigate to its parent directory:

borges@linux: /usr/bin $ cd ..

borges@linux: /usr $

Now, our current working directory is /usr. Let’s return to the home directory:

borges@linux: /usr $ cd ~

borges@linux:~ $

From here, we can go back to the previous working directory:

borges@linux:~ $ cd -

borges@linux: /usr $

Tip

Mastering these navigation commands is essential for building confidence and efficiency when working with the command line. The more you practice using them, the more natural and intuitive your workflow will become.

Inspecting Files

This section introduces commands for inspecting files in the file system.

cat

Displays or combines the contents of files:

cat filename

head

Display the first 10 lines of a file:

head filename

Tip

Use -n to specify the number of lines to display:

head -n 7 filename

tail

Display the last 10 lines of a file:

tail filename

Tip

Use -n to specify the number of lines to display.

Use -f to follow the file and display new lines as they are added.

wc

Count lines, words, and bytes in a file:

wc filename

Tip

Use these options to count specific types of content:

-l, --lines  Show the number of lines
-w, --words  Show the number of words
-m, --chars  Show the number of characters
-c, --bytes  Show the number of bytes

less

View file content:

less filename

Tip

less is a program for viewing the contents of text files. When a file spans more than one screen, it allows scrolling both forward and backward.

---

Essential Commands

h  Display help menu
q  Quit

Movement and Navigation

j  Forward one line
k  Backward one line
f  Forward one window
b  Backward one window
d  Forward one half-window
u  Backward one half-window
g  Go to the first window
G  Go to the last window

Searching

/term  Search forward for term
?term  Search backward for term
n      Repeat search, same direction
N      Repeat search, opposite direction

Practice 🔥

1. Display the contents of a text file:

   cat /etc/passwd

2. Display the first 5 lines of a file:

   head -n 5 /etc/passwd

3. Display the last 2 lines of a file:

   tail -n 2 /etc/passwd

4. Count the number of lines, words, and characters in a file:

   wc /etc/passwd
   
   32  45 1656 /etc/passwd

   Where:

   • 32: lines
   • 45: words
   • 1656: bytes

5. Count only the characters in a file:

   wc --chars /etc/passwd

6. Open a sample text file:

   less /etc/services

7. Practice moving, searching, and quitting:

   Moving: j, k, f, b, d, u

   Searching: /term, n, N

   Jumping: g, G

   Quitting: q

Inspecting Commands

A command can be an executable program, an internal shell command, a shell function or script, or an alias that can be defined by several commands.

type

Display command details:

type date

date is /bin/date

type type

type is a shell builtin

which

Display command location:

which bash

/bin/bash

Managing Files and Directories

Copy (cp)

You can copy a specific file or directory using the cp command:

cp source destination

Common options

-r  Copy directories recursively
-i  Prompt before overwrite
-v  Verbose output

Copy a file to another directory

cp /source_dir/myfile /destination_dir/

Note

The file will retain its original name.

Copy a file to another directory and rename it

cp /source_dir/myfile /destination_dir/new_filename

Copy a directory and its content into another directory

You must use the -r option to copy directories.

cp -r /source_dir/mydir /destination_dir/

Note

This copies the entire mydir directory and everything within it into destination_dir.

Move (mv)

The command mv is used to move a file or directory from one location to another, or to rename a file or directory within the same location. Unlike cp, moving a file or directory removes it from the source location.

mv source destination

Common options

-i  Prompt before overwrite
-v  Verbose output

Rename a file in the current directory

mv old_filename.txt new_filename.txt

Move a file to a different directory

mv myfile.txt /destination_dir/

Note

The file retains its original name.

Move a directory to a new location

mv /source_dir/mydir /destination_dir/

Note

This moves the entire mydir directory and all its contents to destination_dir.

Make directory (mkdir)

The command mkdir (make directory) is used to create one or more new directories in the specified location.

mkdir directory_name

Common options

-p  Create parent directories as needed
-v  Verbose output

Create a single directory in the current location

mkdir projects

Create multiple directories at once

mkdir scripts docs logs

Create a nested directory structure

Use the -p option to create multiple directories in a path.

mkdir -p project/src/main

Note

This command will successfully create project, then src inside it, and finally main inside src.

Create a new file (touch)

The command touch is commonly used to create a new empty file if the file does not already exist.

touch filename

Remove (rm)

The command rm (remove) is used to permanently delete files or directories. Use this command with caution, as deleted files are typically unrecoverable.

rm filename

Common options

-r  Remove directories recursively
-f  Force removal without prompt
-i  Prompt before each removal

Remove a single file

rm unnecessary_file.txt

Remove multiple files

rm log_*.txt temp_file.bak

Remove a directory and its contents

To remove a directory, the -r (recursive) option is required.

rm -r old_project_folder/

Force-remove a directory without prompting

rm -rf very_old_backup/

Danger

The combination rm -rf permanently deletes files and directories without confirmation.

Use with extreme caution!

Hard and Soft links

In Linux-based systems, links are used to create references to files or directories, allowing a single item to be accessed via multiple names or locations.

We have two distinct kinds of links:

• Hard link: another name for the same file. If one name is deleted, the other still provides access to the file.
• Soft link (symbolic link): a shortcut that points to another file or directory. If the target is deleted, the link breaks.

Create a hard link

ln target link_name

Note

Hard links can only be created for files, not directories.

Create a symbolic (soft) link

ln -s target link_name

Note

Soft links can be created for files and directories.

Practice 🔥

1. Create a playground directory:

   mkdir /tmp/playground

2. Change to the playground directory:

   cd /tmp/playground

3. Create multiple directories following the example:

   • Directorydir1/

     • …
   • Directorydir2/

     • Directorydir3/

       • …
   • Directorydir4/

     • Directorydir5/

       • Directorydir6/

         • …
   • Directoryfiles/

     • …

   mkdir dir1 dir2 dir4 files

   mkdir dir2/dir3 dir4/dir5

   mkdir dir4/dir5/dir6

   Tip

   You can create all directories at once using a single command with mkdir -p:

   mkdir -p dir1 dir2 dir2/dir3 dir4 dir4/dir5/dir6 files

4. Create files inside dir3:

   • Directorydir2/

     • Directorydir3/

       • file_1.txt
       • file_2.txt
       • file_3.txt

   touch dir2/dir3/file_1.txt

   touch dir2/dir3/file_2.txt

   touch dir2/dir3/file_3.txt

5. Recursively list all directories and files:

   ls -R

   • Directorydir1/

     • …
   • Directorydir2/

     • Directorydir3/

       • file_1.txt
       • file_2.txt
       • file_3.txt
   • Directorydir4/

     • Directorydir5/

       • Directorydir6/

         • …
   • Directoryfiles/

     • …

6. Copy /etc/passwd into dir6/file_4.txt:

   • /etc/passwd
   • Directorydir4/

     • Directorydir5/

       • Directorydir6/

         • file_4.txt

   Using a relative path, run:

   cp /etc/passwd dir4/dir5/dir6/file_4.txt

   Caution

   Make sure you run this command from /tmp/playground, since dir4/... is relative to the current working directory.

   To avoid depending on the current directory, use the absolute path instead:

   cp /etc/passwd /tmp/playground/dir4/dir5/dir6/file_4.txt

7. Create a symbolic link to file_4.txt:

   • Directorydir4/

     • Directorydir5/

       • Directorydir6/

         • file_4.txt
   • soft_link.txt -> dir4/dir5/dir6/file_4.txt

   ln -s dir4/dir5/dir6/file_4.txt soft_link.txt

8. List files in the current directory with detailed info:

   ls -l

   • Directorydir1/

     • …
   • Directorydir2/

     • …
   • Directorydir4/

     • …
   • Directoryfiles/

     • …
   • soft_link.txt -> dir4/dir5/dir6/file_4.txt

9. Create a hard link to file_4.txt:

   • Directorydir4/

     • Directorydir5/

       • Directorydir6/

         • file_4.txt
   • hard_link.txt

   ln dir4/dir5/dir6/file_4.txt hard_link.txt

10. Remove the file_4.txt file:

    • Directorydir4/

      • Directorydir5/

        • Directorydir6/

          • file_4.txt

    rm dir4/dir5/dir6/file_4.txt

11. List files in the current directory with detailed info:

    ls -l

    • Directorydir1/

      • …
    • Directorydir2/

      • …
    • Directorydir4/

      • …
    • Directoryfiles/

      • …
    • hard_link.txt
    • soft_link.txt -> dir4/dir5/dir6/file_4.txt

    The symbolic link soft_link.txt is still present, but it is now broken. The hard link hard_link.txt, however, still works and provides access to the file.

12. Attempt to display the content of the soft_link.txt file:

    cat soft_link.txt
    
    cat: soft_link.txt: No such file or directory

    The target file cannot be accessed through the symbolic link because the link is broken.

13. Display the first 10 lines of hard_link.txt file:

    head hard_link.txt

14. Rename the hard link hard_link.txt to output.txt:

    mv hard_link.txt output.txt

15. Remove the soft_link.txt file:

    rm soft_link.txt

16. Recursively list all directories and files:

    ls -R

    • Directorydir1/

      • …
    • Directorydir2/

      • Directorydir3/

        • file_1.txt
        • file_2.txt
        • file_3.txt
    • Directorydir4/

      • Directorydir5/

        • Directorydir6/

          • …
    • Directoryfiles/

      • …
    • output.txt

Managing IO and Errors

This section covers commands for controlling the standard input, output, and error of processes, making it easier to manage and manipulate data.

In Linux, every process automatically starts with three data streams:

1. Standard input (stdin): the channel through which a program receives data, usually from the keyboard or a file.
2. Standard output (stdout): where a program sends its results, usually shown on the terminal.
3. Standard error (stderr): used to display error messages.

Tip

A process is a program that is running on your computer. When you start an application or run a command, the system creates a process for it, which includes the program’s code, its current activity, and the resources it needs, like memory or CPU time.

Standard output (stdout)

To redirect the standard output of a process to a file instead of displaying it on the screen, use the redirection operator > followed by the file name.

For example, we can redirect the output of the cal -m July command to a file instead of displaying it on the screen:

cal -m July > /tmp/calendar.txt

Then, we can display the file content:

cat /tmp/calendar.txt

     July 2025
Su Mo Tu We Th Fr Sa
       1  2  3  4  5
 6  7  8  9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31

Now, let’s see what happens if we type the command incorrectly:

cal -m month > /tmp/calendar.txt

cal: month is neither a month number (1..12) nor a name

We get an error message because the command expects either a valid month name or a number between 1 and 12, not the term month.

Now, let’s display the file content:

cat /tmp/calendar.txt

The file is empty because the command cal -m month produced an error and didn’t generate the calendar as expected.

As you may notice, the redirection operator > overwrites the file, discarding its previous data. If you want to preserve the existing data, you can use the append operator >>, which adds new data to the end of the file.

1. Overwriting the file with the July calendar:

   cal -m July > /tmp/calendar.txt

2. Appending the file with the August calendar:

   cal -m August >> /tmp/calendar.txt

3. Displaying the contents of the file:

   cat /tmp/calendar.txt
   
       July 2025
   Su Mo Tu We Th Fr Sa
         1  2  3  4  5
   6  7  8  9 10 11 12
   13 14 15 16 17 18 19
   20 21 22 23 24 25 26
   27 28 29 30 31
   
       August 2025
   Su Mo Tu We Th Fr Sa
                   1  2
   3  4  5  6  7  8  9
   10 11 12 13 14 15 16
   17 18 19 20 21 22 23
   24 25 26 27 28 29 30
   31

Standard error (stderr)

Redirecting standard error is easier to understand once you know that the shell treats standard input, output, and error as separate file descriptors:

• File descriptor 0: Standard input (stdin)
• File descriptor 1: Standard output (stdout)
• File descriptor 2: Standard error (stderr)

This means that a command can produce both normal output and error messages, and the shell can redirect them independently.

For example, ls produces an error for the nonexistent myfile and normal output for /usr:

ls myfile /usr

ls: cannot access 'myfile': No such file or directory
/usr:
bin  games  include  lib  libexec  local  sbin  share  src

Redirect the output to a file and the error to the terminal

The > operator redirects standard output to a file. It does not affect standard error, so error messages are still displayed in the terminal:

ls myfile /usr > /tmp/output.txt

ls: cannot access 'myfile': No such file or directory

The normal output from /usr is now stored in /tmp/output.txt, while the error message remains visible in the terminal.

Tip

View the contents of /tmp/output.txt to see the redirected output:

cat /tmp/output.txt

Redirect the output to the terminal and the error to a file

To redirect standard error, use 2> instead of >. The 2 refers to file descriptor 2, which represents standard error.

In this example, the normal output is still displayed in the terminal, while the error message is written to /tmp/output.txt:

ls myfile /usr 2> /tmp/output.txt

/usr:
bin  games  include  lib  libexec  local  sbin  share  src

Tip

View the contents of /tmp/output.txt to see the redirected error.

Redirect both the output and the error to a file

In Bash, you can redirect both standard output and standard error to the same file using &>:

ls myfile /usr &> /tmp/output.txt

Now both the normal output and the error message are written to /tmp/output.txt.

There is also a traditional way to achieve the same result using file descriptors:

ls myfile /usr > /tmp/output.txt 2>&1

Here, we perform two redirections. First, > redirects standard output to /tmp/output.txt. Then, 2>&1 redirects standard error (file descriptor 2) to the same destination as standard output (file descriptor 1).

The order matters. The shell processes these redirections from left to right, so 2>&1 redirects standard error to wherever standard output is currently pointing.

Discard the standard error

You can discard standard error by redirecting it to /dev/null:

ls myfile /usr 2> /dev/null

/usr:
bin  games  include  lib  libexec  local  sbin  share  src

Here, 2> redirects standard error (file descriptor 2) to /dev/null. The error message is discarded, while the normal output is still displayed in the terminal.

Tip

/dev/null is a special device that discards any data written to it. It is commonly used when you want to suppress command output or errors.

Standard input (stdin)

Standard input allows a command to receive data from a source such as the keyboard or a file. Use the < operator to redirect standard input from a file.

Let’s create a simple text file:

printf "Zucchini\nApple\nCherry\n" > /tmp/items.txt

Tip

The printf command prints formatted text. Here, > redirects its standard output to /tmp/items.txt.

Now, redirect standard input from the file:

sort < /tmp/items.txt

Apple
Cherry
Zucchini

Instead of reading input from the keyboard, sort reads the contents of /tmp/items.txt through standard input.

Pipeline

A pipeline allows you to use the pipe operator | to send the standard output of one command as the standard input to another command.

Let’s display some data and pass it through a pipeline to sort the output:

printf "Zucchini\nApple\nCherry\n" | sort

Apple
Cherry
Zucchini

Now, let’s sort some data and use a pipeline to remove duplicates:

printf "Red\nBlue\nYellow\nBlue\nYellow\nRed" | sort | uniq

Blue
Red
Yellow

Tip

The uniq command filters adjacent duplicate lines. It is commonly used with sort to remove duplicate lines regardless of their original order.

Here’s an example of filtering by the specific term python:

ls /usr/bin | grep python

pybabel-python3
python3
python3.14

Tip

The grep command is used for searching text patterns in files. Don’t worry about understanding everything for now, as we will explore it in more detail later.

Explore the docs for each command. We have only scratched the surface!

With more practice you will see how redirection is used for solving real problems, and how standard input, output, and error are at the core of nearly every command-line tool.

Searching files

The find command is a powerful tool for searching files and directories based on their name, type, permissions, date, ownership, size, and more. It can also execute commands on the results, making it very flexible.

find [path] [expression]

Tip

Common paths

/  Root directory (entire system)
.  Current directory
~  Home directory

Common expressions

-name    Filter by file name
-type d  Filter by directories
-type f  Filter by regular files
-type l  Filter by symbolic links
-user    Filter by owner
-group   Filter by group
-size    Filter by file size

Sizes

c  Bytes
k  Kilobytes
M  Megabytes
G  Gigabytes

Search for files by name

Searching for any regular file named bash:

find /usr/ -name "bash"

Searching for files ending with the term bash:

find /usr/ -name "*bash"

Searching for files starting with the term bash:

find /usr/ -name "bash*"

Searching for files containing the term bash:

find /usr/ -name "*bash*"

Searching for files with a .txt extension:

find /usr/ -name "*.txt"

Search for files by type

Searching for directories:

find /usr/ -type d

Searching for directories named linux:

find /usr/ -type d -name "linux"

Searching for regular files:

find /usr/ -type f

Searching for .txt files with names starting with bash:

find /usr/ -type f -name "bash*.txt"

Searching for symbolic links:

find /usr/ -type l

Searching for symbolic links named python3:

find /usr/ -type l -name "python3"

Search for files by size

Searching for files larger than 10 Megabytes:

find /usr/ -size +10M

Searching for files smaller than 1 Kilobyte:

find /usr/ -size -1k

Search for files by owner

Searching for files owned by your user:

find ~ -user "$(whoami)"

Tip

The whoami command returns your username. To run a command and use its output as part of another command, use $(command).

Executing commands

The -exec option allows you to run a command on each file found. This makes find much more powerful. The syntax is:

find [path] [expression] -exec command {} \;

The {} is replaced by the current file, and the sequence must end with \;.

Examples:

Listing details of all .txt files:

find ~ -name "*.txt" -exec ls -l {} \;

Printing the first line of each .txt file:

find ~ -name "*.txt" -exec head -n 1 {} \;

Removing empty files (safe to try in a test directory):

find ./testdir -type f -empty -exec rm {} \;

Caution

This command is safe because of the -empty parameter.

When using -exec rm, be extra careful not to delete important files.

Searching text

The grep command is used to search text inside files using patterns and regular expressions. It is one of the most common tools for quickly finding matching lines in logs, source code, or any other text file.

grep [options] pattern [file...]

Tip

Common options

-i  Ignore case (case-insensitive search)
-r  Search recursively in directories
-n  Show line numbers of matches
-v  Invert match (show non-matching lines)
-E  Use extended regular expressions
-l  Show only names of files with matches
-c  Count the number of matches

Basic regular expressions

^word  Match lines starting with word
word$  Match lines ending with word
.      Match any single character
.*     Match zero or more of any character
[abc]  Match one character: a, b or c
[0-9]  Match any digit
aa|bb  Match either aa or bb

Search for a simple word

Searching for the word admin in a file:

grep "admin" /etc/passwd

Ignoring case (matches admin, Admin, ADMIN, etc.):

grep -i "admin" /etc/passwd

Search using anchors

Searching for lines starting with root:

grep "^root" /etc/passwd

Searching for lines ending with bash:

grep "bash$" /etc/passwd

Search with character classes

Searching for lines that contain a number:

grep "[0-9]" /etc/passwd

Searching for lines containing cat, bat, or hat:

grep "[cbh]at" /etc/passwd

Extended regular expressions

With -E we can use more advanced patterns.

Searching for either Daemon or Proxy:

grep -E "Daemon|Proxy" /etc/passwd

Searching for words ending with ing:

grep -E "[a-zA-Z]+ing" /etc/passwd

Counting and file matches

Counting the number of matches for the word false:

grep -c "false" /etc/passwd

Showing only the names of files containing the word main:

grep -rl "main" /path/to/directory

Introduction to Bash scripting

A Bash script is a text file containing commands that are executed in sequence. Scripts are essential for system administration, allowing you to automate tasks, create simple programs, and combine existing commands into efficient, reusable workflows.

Your first Bash script

1. Create a script file using nano or your favorite code editor:

   nano /tmp/script.sh

2. Copy and paste the content below, and save:

   #!/usr/bin/env bash
   # A simple script
   echo "Hello, world!"

   The first line, known as the shebang, specifies Bash as the interpreter for the script. The second line is a comment. The third line uses the echo command to print the specified string to the standard output.

3. Make the file executable:

   To run a bash script correctly, you must ensure it has execution permission. For that, we use the chmod command (short for change mode), which is a fundamental Linux command used to control access to files and directories.

   Close the nano editor and set the execution permission to the script:

   chmod +x /tmp/script.sh

4. Run the script:

   bash /tmp/script.sh

Comments

Comments help explain the purpose of certain lines. They should only be used to explain less obvious parts of the code.

# This is a comment!
# Comments start with a hash (#)
#
# Something important here! Albert Einstein

Variables

Variables are used to store values. No spaces are allowed around the equal sign.

NAME="Alice"
CITY="Paris"

echo "${NAME} lives in ${CITY}"

Tip

Use ${VAR_NAME} to access the value of a variable.

Always quote variables like "${VAR_NAME}" to avoid unexpected word splitting.

Multi-line variables

You can assign multi-line text to a variable using the here-document syntax, which allows you to embed a block of text or commands directly within a script. Below is an example of how you can define a multi-line variable.

Copy and paste this into the terminal:

TEXT="$(cat << EOF
---
The current directory is: ${PWD}
You are logged in as: $(whoami)
---
EOF
)"

echo "${TEXT}"

By default, the shell performs parameter expansion and command substitution inside the here-document. For example, ${PWD} expands to the current directory and $(whoami) is replaced by the current user.

If you need to preserve the literal contents without performing expansions or substitutions, quote the opening delimiter with << 'EOF', so the text is stored or printed exactly as written. Below is an example of how to define a multi-line variable without expansion. Pay attention to the details and compare it with the previous (unquoted) example to observe the difference.

Copy and paste the following into the terminal:

TEXT="$(cat << 'EOF'
---
The current directory is: ${PWD}
You are logged in as: $(whoami)
---
EOF
)"

echo "${TEXT}"

Tip

Using << 'EOF' keeps the text literal. Without the quotes, variables inside will be expanded.

Arrays

Bash supports indexed arrays, which provide a way to store multiple data elements that can be accessed by their position (index), starting from 0. Check the example below.

Copy and paste this into the terminal:

COLORS=("red" "green" "blue")

echo "0: ${COLORS[0]}"
echo "1: ${COLORS[1]}"
echo "2: ${COLORS[2]}"

Reading input from the user

The read command waits for the user to enter a value and stores it in a variable. In this example, the input is stored in the NAME variable.

When read runs, the shell pauses until the user types something and presses Enter. The value can then be used by subsequent commands.

Copy and paste the following into the terminal:

echo "Enter your name:"
read NAME

echo
echo "Welcome ${NAME}."

Tip

We use echo without any arguments to print a blank line.

Control flow

Control flow in Bash scripting is essential for making decisions and performing repetitive tasks. It determines the order in which commands are executed based on conditions.

Mastering control flow allows a script to move beyond simple sequential commands to dynamic and powerful automation.

If statements

An if statement is a control structure that executes one or more commands based on the result of a condition.

Here is an example of an if statement:

if [[ "CONDITION" ]]; then
    "INSTRUCTIONS"
fi

Now, a more complete example:

NAME="Alice"

if [[ "${NAME}" = "Alice" ]]; then
  echo "Welcome, Alice."
else
  echo "You are not Alice."
fi

Tests and conditions

We have several ways to perform tests and conditional checks in Bash. Below are the most commonly used tests:

Common tests

• [[ -f FILE ]] True if file exists and is a regular file
• [[ -d DIR ]] True if directory exists
• [[ -z STR ]] True if string is empty
• [[ -n STR ]] True if string is not empty
• [[ NUM1 -eq NUM2 ]] True if numbers are equal
• [[ NUM1 -lt NUM2 ]] True if NUM1 is less than NUM2
• [[ NUM1 -gt NUM2 ]] True if NUM1 is greater than NUM2

Check if a file exists:

if [[ -f "myfile.txt" ]]; then
  echo "File exists"
else
  echo "File not found"
fi

Compare two numbers:

if [[ 1 -lt 2 ]]; then
  echo "Are you sure?"
fi

For loops

A for loop allows a block of code to be executed repeatedly. For example, we can use it to print all the elements of an array like this:

COLORS=("red" "green" "blue")

for COLOR in "${COLORS[@]}"
do
  echo "Color: ${COLOR}"
done

Here’s another way to do it by looping over strings:

for COLOR in "red" "green" "blue"
do
  echo "Color: ${COLOR}"
done

You can also loop over a range:

for i in {0..3}
do
  echo "Number: ${i}"
done

Practice 🔥

1. Create a new script:

   nano /tmp/calendar.sh

2. Copy and paste the content below, and save:

   #!/usr/bin/env bash
   echo "Calendar Display Utility"
   echo
   echo "Please enter the month number (1-12):"
   
   read MONTH
   
   # Print the calendar for the month
   cal -m "${MONTH}"

3. Make the file executable:

   chmod +x /tmp/calendar.sh

4. Run the script:

   bash /tmp/calendar.sh

Wrapping Up

You now have the foundations you need to work comfortably at the Linux command line. You can navigate the file system, inspect and manage files, redirect input and output, connect commands with pipelines, search for files and text, and write simple Bash scripts.

But the command line really starts to click when you use it to solve your own problems. Don’t worry about memorizing every option or command. Keep experimenting, read the documentation, and gradually build up your own toolbox.

There’s a lot more to discover, but you have everything you need to start exploring.