Automating with Bash

NUnix · L3 MIAGE · CM3 · 90 minutes

Louis Ledoux

ISTIC · University of Rennes

2026–2027

Writing Bash scripts

A script saves commands so you can run them again.
Arguments let you use the same script with different inputs.

1. Read arguments and store values in variables.
2. Use conditions, loops and functions.
3. Handle errors and test the script.

1. Scripts, arguments and variables

Run a script, pass arguments and store values

Bash: Bourne again

Bash = Bourne-Again SHell.

The name puns on Stephen Bourne, author of the earlier Unix shell sh.

We use Bash syntax in this course.
sh script.sh may select a different shell with fewer features.

Bourne's shell appeared in Seventh Edition Unix. Bash extends that shell's language. Source: GNU Bash, What is Bash?.

A first script

#!/bin/bash
# hello.sh
name="MIAGE"
echo "Hello, $name"

• The first line selects an interpreter for direct execution.
• # begins a comment when used in this position.
• .sh is a naming convention, not a requirement.

Save the commands in a text file named hello.sh. Bash interprets them in order. The first line is called a shebang.

Two ways to run a script

Invoke Bash

bash hello.sh

Bash reads the file.
It needs read access to it.

Execute the file

chmod u+x hello.sh
./hello.sh

Requires execute permission and a usable interpreter.

Both forms require directory traversal and script read permission. Direct execution also requires the execute bit. bash hello.sh selects Bash explicitly; ./hello.sh uses the shebang. Both run in a child process, so their variable assignments do not change the calling shell.

The shebang: selecting an interpreter

#!/bin/bash
printf 'Hello, MIAGE\n'

On Linux, direct execution of ./hello.sh uses the interpreter named after #!.

The extension .sh does not choose Bash.
The first line does. We call it the shebang.

#! must be the first two bytes of the file. Windows CRLF line endings can add a carriage return to the interpreter path and cause an execution error. /usr/bin/env bash is another convention: it searches PATH for Bash. Linux execve: interpreter scripts.

One symbol, several names

Symbol	Names you may hear
#	hash, number sign; pound sign in US usage
#	French: croisillon, also carré
♯	The musical sharp sign (dièse)

#!: hash followed by bang.
The symbol’s name and its role depend on context.

The OQLF lists croisillon and carré for # and distinguishes it from the musical sharp sign ♯. Carré is common in telephone instructions. OQLF: croisillon. In Bash, # at the start of an unquoted word introduces a comment; a # inside ordinary text need not do so.

Positional parameters

./hello.sh Alice "L3 MIAGE"

Parameter	Value inside this script
$0	./hello.sh
$1	Alice
$2	L3 MIAGE
$#	2
"$@"	Every argument, each kept as a separate word

Use braces from the tenth argument onward: ${10}. $10 means $1 followed by literal 0. getconf ARG_MAX reports an implementation limit in bytes for combined argument and environment data, not a fixed number of arguments. Other system limits and runtime conditions also apply.

Passing arguments with spaces

set -- "L3 MIAGE" Unix
printf '<%s>\n' "$@"
printf '<%s>\n' "$*"

<L3 MIAGE>
<Unix>
<L3 MIAGE Unix>

set -- supplies positional parameters. With the default IFS, "$*" joins them into one string separated by spaces. "$@" preserves them as separate arguments. printf repeats the format for each argument.

Assigning and reading a variable

course="NUnix"
echo "$course"
course="Bash scripting"
echo "Today: $course"

Assignment: name=value, with no spaces around =.
Expansion: $name or ${name}.

Shell variables normally hold strings. PATH, HOME and SHELL already have system meanings; use other names for your data. A variable remains set until unset or until its shell ends. Function-local variables have a shorter lifetime.

Quoted variable expansions

filename="meeting notes.txt"
cat "$filename"
echo '${filename}'
echo "${filename}"

• Double quotes preserve the expanded value as one argument.
• Single quotes preserve the literal text ${filename}.

cat receives one filename argument. Without quotes, variable expansion normally allows word splitting and filename expansion. The first echo prints the literal ${filename}; the second prints meeting notes.txt.

Capturing command output

directory=$(pwd)
message="$1 and $2"
echo "$directory"
echo "$message"

$(command) captures the command's standard output.
$1 and $2 are positional arguments, introduced earlier.

The message example needs two positional arguments. Supply them when running the script, or use set -- first second in a practice shell. Command substitution removes trailing newlines from the captured output.

Printing values

name="Alice"
echo "Hello, $name"
printf 'Hello, %s\n' "$name"

echo is convenient for simple messages.
printf gives explicit control over formatting and newlines.

printf '%s' "$value" prints the value as data, even if it resembles an echo option. The format string controls conversion and newlines.

Exporting a variable

message="hello"
bash -c 'echo "$message"'
export message
bash -c 'echo "$message"'

The first child prints an empty line.
After export, the next child prints hello.

This example starts with message unset. An executed child shell receives exported variables through its environment. The single quotes delay expansion of $message until the child runs. A (...) subshell also copies unexported shell variables. Bash environment.

A child receives a copy

export message="parent"
bash -c 'message="child"; echo "$message"'
echo "$message"

child
parent

Changes in the child do not update the parent's variables. env and printenv show environment variables. Bash's set also shows unexported shell variables and functions.

2. Conditions and exit status

Choose which commands to run with if, && and ||

Tests are commands too

test -d logs
[ -d logs ]
[[ -d logs ]]
(( 3 < 5 ))

• test and [ are command names. ] closes the [ form.
• [[ ... ]] is a Bash conditional construct.
• (( ... )) tests an arithmetic expression.

Spaces separate the arguments in [ -d logs ]. The closing ] is an argument required by [. Parentheses (...) run a subshell. Bash [[ ... ]] has its own parsing rules and does not perform ordinary word splitting or pathname expansion on variable values.

if, elif and else

if [ "$count" -gt 10 ]; then
    echo "More than ten"
elif [ "$count" -eq 10 ]; then
    echo "Exactly ten"
else
    echo "Fewer than ten"
fi

The first successful test selects the branch.
else handles the remaining case.

count must already hold an integer. if accepts a command list and checks its exit status. The [ command is one possible test. A newline can replace the semicolon before then.

The condition can be grep

if grep ' ERROR ' app.log; then
    echo "At least one error was found"
else
    echo "No match, or grep could not read the file"
fi

if checks a command’s status.
Square brackets are needed only when we choose a test command.

grep prints matching lines before the success message. An error also produces a nonzero status, so the else branch covers both no-match and failure.

Conditional command lists

mkdir results && echo "Directory created"
test -d results || echo "Directory is missing"

• a && b: run b only when a succeeds.
• a || b: run b only when a fails.
• ! a: invert the success/failure result.

A command list returns the status of its last executed command. && and || have equal precedence and are evaluated left to right. Separate [ ... ] commands can be joined with these operators.

Which messages appear?

true  || echo "A"
false || echo "B"
true  && echo "C"
false && echo "D"

B
C

Checkpoint: command status

1. Status 0: true or false?
2. Does false; echo yes print?
3. Does false && echo yes print?
4. Status of false || true?

1. True / success.
2. Yes. ; always continues.
3. No.
4. 0, from the final executed command, true.

In a && b || c, c runs if a fails or if b fails. This can differ from an if/else statement.

Check the argument count

Save as count-lines.sh:

#!/bin/bash
if [ "$#" -ne 1 ]; then
    printf 'Usage: %s FILE\n' "$0" >&2
    exit 2
fi
wc -l < "$1"

Check the argument count before using $1.
Print the usage message on stderr.

Run bash count-lines.sh notes.txt. With no argument or too many arguments, the script prints usage on stderr and exits with status 2. Otherwise, it counts newline characters in the supplied file. If the file cannot be opened, the redirection fails and the script finishes with a nonzero status.

Integer arithmetic

count=3
echo "$((count + 2))"
count=$((count + 1))
((count += 2))
echo "$count"

• $((...)) expands to an integer result.
• ((...)) is a Bash arithmetic command.

This prints 5 then 6. declare -i is not required. $((...)) is POSIX shell arithmetic expansion, while ((...)) is not specified as a POSIX sh command. These operations use integers; 5 / 2 yields 2. The command ((expression)) reports status zero when the value is nonzero, and status one when the value is zero.

3. Loops

Process a list of arguments or read a file line by line

for visits a list of words

for group in L3info L3miage M1info; do
    echo "$group"
done

Each iteration assigns the next word to group, then runs the body.

The list can contain literal words, numbers, filenames or "$@".

The words can come from a literal list, "$@", or a pattern such as ./*.txt. With Bash defaults, an unmatched pattern remains literal. Parsing ls output with command substitution can split filenames containing whitespace.

while repeats after a successful test

i=1
while [ "$i" -lt 10 ]; do
    echo "$i"
    ((i += 1))
done

Test before each iteration.
The loop prints the integers 1 through 9.

The condition is a command list. A zero status runs the body; a nonzero status ends the loop. Bash looping constructs.

while can test a whole command list

i=1
while
    echo "Checking i=$i"
    [ "$i" -le 3 ]
do
    echo "Body: $i"
    ((i += 1))
done

The last command before do decides whether the body runs.

A condition list can span several lines. Each command runs in order; the last command's status determines whether the loop body runs. Bash looping constructs.

The condition runs once more than the body

Checking i=1
Body: 1
Checking i=2
Body: 2
Checking i=3
Body: 3
Checking i=4

• At 1, 2, 3, the test succeeds.
• At 4, the final test fails.
• The body does not run a fourth time.

If echo followed [ ... ] in the condition list, echo's usual success status would replace the test's status. This loop would then keep running.

Read a file line by line

while IFS= read -r name; do
    printf 'Hello, %s\n' "$name"
done < names.txt

• read succeeds when it reads a complete line.
• At EOF, it fails and the loop stops.
• < feeds the file to the whole loop.

names.txt contains one name per line, with a newline after each name. IFS= preserves leading and trailing whitespace; -r preserves backslashes. To also process a final line without a newline, use while IFS= read -r name || [ -n "$name" ]; do ...; done. File redirection keeps this loop in the current shell.

until repeats after a failed test

i=1
until [ "$i" -ge 10 ]; do
    echo "$i"
    ((i += 1))
done

This also prints 1 through 9.
The loop stops when the condition succeeds.

until tests before entering the body, so the body may run zero times. It continues while the condition returns nonzero. Bash looping constructs.

break, continue and exit

Command	Effect
continue	Skip the rest of the current iteration
break	Leave the current loop
exit n	End the script with status n

After break, execution continues after the loop.

break and continue can take a nesting level. exit ends the shell running the command; here that shell is executing a script.

case selects a matching pattern

read -r -p "Enter a command: " choice
case "$choice" in
    all|ALL)
        ls -la ;;
    list|LIST)
        ls -l ;;
    *)
        echo "Invalid choice" ;;
esac

| separates alternative patterns. ;; ends a branch.

case uses shell patterns. The first matching branch runs. all|ALL matches those two spellings; mixed-case All reaches the final * branch.

4. Functions and debugging

Group commands in functions and trace script execution

Defining and calling a function

greet() {
    echo "Hello, $1"
}

greet "MIAGE"

• Define the function before calling it.
• Inside it, $1 is its first argument.
• return n finishes the function with exit status n.

The function definition must execute before its call. A function can print data to stdout and return a numeric status from 0 to 255. Without return, its status comes from the last command executed.

Check syntax and trace execution

bash -n count-lines.sh
bash -x count-lines.sh notes.txt

• -n: parse the script without executing its commands.
• -x: execute and trace expanded commands on stderr.
• Check output and status on ordinary and failing inputs.

-n checks syntax without testing files or running commands. -x shows expanded arguments, which may include private data. Useful test cases include no argument, an empty file, a missing file and a filename containing spaces.

CM3 summary: Bash scripts

1. Define inputs, outputs and failure statuses.
2. Quote variable and filename arguments.
3. Use command status for branches and loop conditions.
4. Test normal, empty and failing inputs.

Optional reference

More examples and a command reference

Command substitution

echo "Current directory: $(pwd)"

The shell runs pwd and replaces $(pwd) with its standard output.

The older form is `pwd`.
We will write $(pwd) because nested commands are easier to read.

Command substitution captures stdout and removes trailing newlines. stderr and the exit status are separate.

Newlines, semicolons and continuations

echo "first"
echo "second"; echo "third"
echo "a longer message" \
     "continued on the next line"

• A newline or ; separates commands.
• A backslash immediately before a newline continues the line.

The continuation backslash must immediately precede the newline. Bash also accepts line breaks after operators such as | and inside compound commands. echo prints its arguments separated by spaces.

Reading a line

read -r -p "Your name: " name
echo "Hello, $name"

• read reads from standard input.
• -p displays a prompt in an interactive terminal.
• -r preserves backslashes in the input.

read first second splits the line using IFS and places the remaining words in the last variable. Without a variable name, Bash uses REPLY. read returns zero on a successful read and nonzero on EOF or another failure. For an exact line including leading/trailing whitespace, use IFS= read -r line. The simple name example uses normal whitespace handling.

Integer, readonly and array variables

declare -i count=3
readonly course="NUnix"
declare -a words
words[0]="one"
words[1]="two"
echo "${words[0]}"

unset count removes a variable. A readonly variable cannot be reassigned or unset in that shell.

declare -i and indexed arrays are Bash features. Arithmetic expansion does not require declare -i. A readonly variable remains readonly until its shell exits; run this example in a fresh Bash shell.

Familiar environment variables

Variable	Meaning
HOME	Home directory
USER	Account name, usually set at login
PWD, OLDPWD	Current and previous working directories
PATH	Colon-separated command search directories
SHELL	Configured login shell, not necessarily the current shell
TERM	Terminal type
HOSTNAME	Host name in Bash
MANPATH	Manual search path, when explicitly set

Arithmetic with let and expr

let 'count = 3 + 5'
echo "$count"
expr 3 + 5
expr 3 \* 5

• let evaluates an arithmetic expression in Bash.
• expr takes separate arguments, so its spaces matter.
• Escape * so the shell passes it to expr literally.

The outputs are 8, 8 and 15. A quoted let expression can contain spaces. expr receives the operator and operands as separate arguments, prints its result and returns a status.

Comparing numbers and strings

Relation	Integers with [	Strings with [
Equal	-eq	=
Different	-ne	!=
Less / greater	-lt, -gt	\<, \>
Less / greater or equal	-le, -ge	No dedicated operator

[ "$count" -gt 3 ]
[ "$name" = "Alice" ]

Bash's [ builtin supports escaped string comparison operators < and >; POSIX test does not specify them. [[ ... ]] uses < and > without escaping. (( ... )) compares integers. String ordering depends on locale and the construct used.

Testing strings and files

Test	True when…
-n "$value"	The string is nonempty
-z "$value"	The string is empty
-e "$path"	The path exists
-f "$path"	It is a regular file
-d "$path"	It is a directory
-s "$path"	Its size is greater than zero
-r, -w, -x	Read, write or execute/search access is allowed

For -r, -w and -x, supply a quoted path as with the other file tests. These predicates generally follow symbolic links; -L tests the link itself, including a dangling link. -f means regular file, not any existing path. A prior access test does not guarantee a later operation succeeds if conditions change.

Checkpoint: arithmetic and tests

1. Value of $((5 / 2))?
2. Is n = 3 an assignment?
3. Status of false?
4. Does -f accept every existing directory?

1. 2 (integer division).
2. No. Use n=3.
3. 1
4. No. It tests for a regular file.

Checking access to a file

#!/bin/bash
read -r -p "Enter a filename: " filename
if [ ! -w "$filename" ]; then
    echo "File is not writable"
    exit 1
elif [ ! -r "$filename" ]; then
    echo "File is not readable"
    exit 1
else
    echo "File is writable and readable"
fi

A directory can also pass -r, -w and -x tests. Use -f when a regular file is required. A failed access test may also mean that the path does not exist.

Comparing two files

diff "$1" "$2" > diff.out
status=$?
if [ "$status" -eq 0 ]; then
    echo "Files are identical"
elif [ "$status" -eq 1 ]; then
    cat diff.out
else
    echo "Comparison failed" >&2
fi
rm -f diff.out

Supply two filenames. diff returns 0 for identical files, 1 for differences and greater than 1 for an error. This example overwrites diff.out in the current directory. A reusable script should use a unique temporary file and arrange cleanup.

Copying a known list of files

#!/bin/bash
destination=$1
for file in f1 f2 f3; do
    cp "$file" "$destination/$file"
done

Call with an existing destination directory as the first argument.

Create f1, f2 and f3 first, then supply an existing destination directory as the script's first argument. Quoting keeps a destination with spaces in one argument.

A loop can feed a pipeline

for number in 6 3 1 2; do
    echo "$number"
done | sort -n

1
2
3
6

The loop's entire stdout feeds sort -n. With normal Bash pipeline execution, variable assignments inside a pipeline element do not update the parent shell.

Repeating until interrupted

while true; do
    echo "alive..."
    sleep 3
done

true always succeeds.
Use Ctrl+C to interrupt this foreground loop.

sleep 3 waits three seconds between iterations. The loop keeps running until interrupted.

Skipping 4, stopping at 7

for x in 1 2 3 4 5 6 7 8 9; do
    if [ "$x" -eq 4 ]; then
        continue
    fi
    echo "$x"
    if [ "$x" -eq 7 ]; then
        break
    fi
done
echo "After the loop: x=$x"

continue skips the print at 4. At 7, the print runs before break. The final echo runs after the loop.

The loop's output

1
2
3
5
6
7
After the loop: x=7

• At 4, continue skips echo.
• At 7, echo runs before break.
• The final message runs after the loop.

Function scope

outside="a global variable"
mine() {
    local inside="this is local"
    echo "$outside"
    echo "$inside"
    outside="a global with new value"
}
echo "$outside"
mine
echo "$outside"
echo "${inside-unset}"

Start with inside unset. local gives the variable scope within the function and its calls while the function runs. Assigning outside changes that variable in the current shell. Functions can read shell variables without export. ${inside-unset} prints unset if inside is absent.

What remains after the call

a global variable
a global variable
this is local
a global with new value
unset

outside changed.
The function's local variable is no longer in scope.

Builtins: shell and process control

Builtin	Use
cd, pwd	Change / report the current directory
history	Display command history
exec	Replace the shell with another program
exit	End the current shell
kill	Send a signal
trap	Arrange a response to a signal or shell event

exec ls replaces the current shell with ls. trap can associate a command with a named signal, such as QUIT. Signal numbers can vary between platforms.

Builtins: data and parameters

Builtin	Use
declare, readonly, local	Define variable attributes or scope
export, set	Manage the environment / shell settings
echo, read	Print output / read input
let, test	Arithmetic / condition tests
shift	Discard leading positional parameters
return	End a function and report its status

set with no arguments prints shell variables and functions. set -- assigns positional parameters. shift 2 discards $1 and $2, then renumbers the remaining arguments.

Reading a small script

#!/bin/bash
for filename in "$@"; do
    if [ -f "$filename" ]; then
        wc -l "$filename"
    fi
done

For each argument that names a regular file, print its line count.