Bash Scripting

Why Write Scripts?

Shell scripts automate tasks that would otherwise require typing the same commands repeatedly or trusting humans to remember a procedure:

• Daily system backups
• Software installation and patching across multiple servers
• Periodic system monitoring and health checks
• Raising alarms and sending notifications
• Troubleshooting, auditing, and compliance checks
• Any sequence of steps you want to run consistently and repeatably

A script is simply a text file containing a sequence of commands. The shell executes them one by one - exactly as if you typed them.

---

Shell Interpreter Choices

The interpreter is the program that reads and executes your script. Common choices:

Interpreter	Path	Notes
bash	/bin/bash	Most common; extensive feature set; default on most Linux systems
sh	/bin/sh	POSIX-compliant; usually symlinked to bash or dash
dash	/bin/dash	Faster than bash; fewer features; many distros use for /bin/sh
zsh	/bin/zsh	Interactive-focused; not ideal for portability
python3	/usr/bin/python3	For complex tasks requiring data structures, network, APIs
perl	/usr/bin/perl	Powerful text processing; legacy systems

The available shells on a system are listed in /etc/shells.

---

First Script

#!/bin/bash
# Lines beginning with # are comments (except the shebang)
echo "Hello, Linux!"

The first line is the shebang (#!) - it tells the kernel which interpreter to use. It’s not a comment - it’s a special directive parsed by the kernel.

# Save as hello.sh, make executable, and run:
chmod +x hello.sh
./hello.sh                   # run directly
bash hello.sh                # run without chmod via bash interpreter

Reading User Input

#!/bin/bash
# Interactive reading of a variable
echo "Enter your name:"
read name
echo "Hello, $name!"

---

Special Characters

Character	Purpose
#	Comment (except #! on line 1)
\	Line continuation (join next line)
;	Command separator (run sequentially)
$	Variable reference or command substitution prefix
>	Redirect stdout (overwrite)
>>	Redirect stdout (append)
<	Redirect stdin
|	Pipe output to next command
&	Run in background
&&	AND - run next command only if previous succeeded
||	OR - run next command only if previous failed

Command Chaining

make ; make install ; make clean          # run all, regardless of success/failure
make && make install && make clean        # stop on first failure
cat file1 || cat file2 || cat file3       # stop on first success

# Long lines - use backslash continuation:
sudo apt-get install autoconf automake bison \
     build-essential chrpath curl diffstat \
     libsdl1.2-dev libtool lzop make screen

Note

Chaining commands with ;, &&, || is not the same as piping. In piping, stages run concurrently on data streams. In chaining, each command completes before the next starts.

---

Return Values (Exit Codes)

Every command and script exits with a numeric code:

• 0 = success
• Non-zero = failure (specific values vary by program)

ls /etc/passwd
echo $?           # 0 (success)

ls /nonexistent
echo $?           # 2 (no such file)

$? always holds the exit code of the most-recently-run command.

Use exit codes in scripts to signal success or failure:

#!/bin/bash
if [ -f "$1" ]; then
    echo "File exists"
    exit 0
fi
echo "File not found"
exit 1

---

Variables

User-Defined Variables

name="Alice"
count=42
greeting="Hello, $name"   # variable interpolation in double quotes

echo $name
echo ${name}              # brackets allow adjacent text: ${name}s → Alices
echo "$name"              # always quote variables to handle spaces safely

Script Parameters

./script.sh arg1 arg2 arg3

Parameter	Value
$0	Script name
$1	First argument
$2, $3 …	Second, third argument …
$*	All arguments as one string
$@	All arguments as separate strings
$#	Number of arguments

Environment Variables

Variables are local to the current process by default. To pass them to child processes:

export VAR=value           # set and export in one step
VAR=value; export VAR      # or separately

# Child processes get a COPY - changes in the child don't affect the parent
export PATH="$PATH:/opt/myapp/bin"   # add to PATH and export

Typing export with no arguments lists all currently exported variables.

Command Substitution

Capture and use the output of a command:

current_date=$(date +%Y-%m-%d)            # preferred modern syntax
kernel_version=$(uname -r)
ls /lib/modules/$(uname -r)/             # nested use

old_style=`date`                          # deprecated backtick syntax

Always use $() over backticks - it’s readable, nestable, and unambiguous.

---

Functions

function_name () {
    commands
}

# Example:
backup_file () {
    local src="$1"
    local dest="${2:-/tmp}"
    cp "$src" "$dest/$(basename $src).bak"
    echo "Backed up $src to $dest"
}

# Call it:
backup_file /etc/hosts
backup_file /etc/nginx/nginx.conf /var/backups

• Declare before first use
• Parameters accessed via $1, $2 etc. (same as script params)
• local keeps variables scoped to the function - prevents polluting global scope

---

Conditionals

if Statement

if condition; then
    commands
elif other_condition; then
    commands
else
    commands
fi

# Test file existence
if [ -f "$1" ]; then
    echo "File $1 exists"
else
    echo "File $1 does not exist"
fi

# Modern double-bracket syntax (preferred):
if [[ -f "$file" && -r "$file" ]]; then
    echo "File exists and is readable"
fi

The double-bracket [[ ]] is safer - avoids subtle problems with empty variables and enables &&/|| inside the test.

File Tests

Condition	True if
-e file	File exists (any type)
-f file	File exists and is a regular file
-d file	File is a directory
-s file	File exists and has non-zero size
-r file	File is readable
-w file	File is writable
-x file	File is executable
-g file	File has sgid set
-u file	File has suid set

man 1 test    # full list of test conditions

String Comparisons

if [[ "$str1" == "$str2" ]]; then echo "equal"; fi
if [[ "$str1" != "$str2" ]]; then echo "not equal"; fi
if [[ -z "$str" ]]; then echo "empty string"; fi
if [[ -n "$str" ]]; then echo "non-empty string"; fi

Numeric Comparisons

if [[ $num -eq 0 ]]; then echo "zero"; fi

Operator	Meaning
-eq	Equal to
-ne	Not equal to
-gt	Greater than
-lt	Less than
-ge	Greater than or equal to
-le	Less than or equal to

---

Arithmetic

x=5
y=3

echo $((x + y))              # preferred - shell arithmetic expansion
echo $((x * y))
echo $((x / y))              # integer division
count=$((count + 1))         # increment

let x=(1 + 2)                # using let built-in
expr 8 + 8                   # deprecated - use $((...)) instead

---

Loops

for Loop

for var in list; do
    commands
done

# Examples:
for file in *.log; do
    echo "Processing $file"
    gzip "$file"
done

for i in {1..10}; do
    echo "Number $i"
done

# C-style:
for (( i=0; i<10; i++ )); do
    echo "$i"
done

while Loop

while condition; do
    commands
done

# Example: read file line by line
while IFS= read -r line; do
    echo "$line"
done < /etc/hosts

# Countdown:
count=5
while [[ $count -gt 0 ]]; do
    echo "T-$count"
    count=$((count - 1))
done

until Loop

The opposite of while - runs while the condition is false:

until condition; do
    commands
done

until ping -c1 google.com &>/dev/null; do
    echo "Waiting for network..."
    sleep 2
done
echo "Network is up"

---

Built-In Shell Commands

Some commands exist both as external programs in /usr/bin and as bash built-ins:

Built-in	Notes
echo	Built-in is slightly different from /bin/echo
cd	Must be built-in - cannot change parent process’s directory otherwise
pwd	More efficient as built-in
read	Always built-in
printf	More portable than echo for formatted output
let	Arithmetic
export	Environment management
ulimit	Resource limits
logout	End a login session

help echo, help read, help cd - get built-in documentation from within bash.