Shell Scripting: Control Structures, Loops, Arrays and String Handling

11.1 Assignment Context and Recap of Previous Shell Concepts

11.1.1 Assignment Overview and Group Work

The coming assignment builds directly on material covered across the last two weeks and carries a heavy weight on shell scripting. The task asks you to select the right command for each requirement, supply the right arguments and parameters, and combine them cleanly inside scripts to produce the required outputs. You will need commands already practised plus a few you have not met in class — the marking looks at whether you can read a manual page and integrate a new tool, not just recall what was demoed.

It is a group assignment. With a class strength around 26 to 27, groups are of two members each. You find a partner yourself and submit one joint solution per group. The solution will lean on the constructs taught in this lecture (case, for, while, until, break/continue, arrays, string and file tests) and on the commands discussed before. The expectation is fluency: choosing the right tool, chaining it with pipes or tests, and keeping the script readable.

11.1.2 Recap: Wildcards, Substitution and Special Variables

The previous session showed three building blocks you will reuse in every loop and test this week.

Wild or meta characters and pathname expansion. A pattern such as * is not a literal star. The shell expands it before the command runs — called globbing or pathname expansion. In for f in * the * becomes the list of file names in the current directory. The same idea applies to ?, [abc], and brace forms.

Command substitution — inserting a command's output into another line. Two spellings do the same job: the modern \$(command) and the older ` command with backticks. For example, today=\$(date) stores the output of date in today. Inside arithmetic you will see the related form \$(( expression ))`, which evaluates the expression as integers.

Special variables — a script inspecting its own run. These names are always available:

• \$? — exit status of the last command: 0 means success, any other number means error or interruption. Right after echo \$? you learn whether the previous run finished cleanly.
• \$# — count of positional parameters (./script a b c gives 3).
• \$* and \$@ — all positional parameters as words; "\$@" keeps each argument as a separate word, "\$*" joins them.
• \$0 — the script name as invoked.
• \$\$ — the process identifier (PID) of the running shell, a number such as 319 or 5401.

A small demo program from last week printed all of these in their true form so you could see \$?, \$#, \$0, and \$\$ expand with a leading \$.

Visual intuition: picture a pipeline diagram with a horizontal timeline. Each command is a box with an arrow out. The arrow carries an integer back to the shell — 0 drawn in green, non-zero in red. \$? is a little window that always shows the colour of the last arrow. \$# and \$@ sit beside the input hopper showing how many parcels arrived and what was written on each.

11.1.3 Recap: Variables, Shebang and if Constructs

Variables — how to declare and how not to. In shell you write name=value with no spaces around =. name = value tries to run name as a command. You expand with \$name or, more safely, "\$name". You never declare a type first — a shell variable holds text until you use it in arithmetic, when the evaluator treats it as an integer if it looks numeric.

Shebang — the first line that picks the interpreter. A script often starts with #!/bin/bash. The two characters #! are the shebang or hash-bang; the loader reads the path after it and runs that interpreter on the rest of the file. #!/bin/bash says "run this with Bash"; #!/bin/sh says "run this with the system shell". Without a shebang the caller decides (bash script.sh vs sh script.sh), which changes which features are available.

Running and editing. Edit with any text editor such as vi. Run in three ways: bash script.sh (explicit Bash), sh script.sh (system shell — on many Linux systems this is Bash in compatibility mode), or make executable with chmod +x script.sh and then ./script.sh (kernel uses the shebang).

Decision making with if. The session began branching with if and if … else using the test brackets [ condition ]. For example, if [ \$x -eq 3 ]; then echo yes; fi runs the then block only when the test returns true (exit 0). More tests — string (=, -z, -n) and file (-f, -d, -x) — are exactly what this lecture extends with case and loop guards.

Real-world & domain connection: In systems programming and DevOps, the same three recap ideas appear in every nightly job — a deployment script starts with #!/bin/bash, reads \$# to verify it received a host list and a version tag, loops with for h in "\$@", logs \$? after each ssh or rsync, and branches with if or case to decide whether to roll back. Mastering them now saves hours of debugging when a production pipeline mis-expands * or silently ignores a non-zero exit status.

11.2 The case Statement — Many-Way Branching

11.2.1 Why a Many-Way Branch Helps

When a script must choose among many alternatives, a chain of if … then … else gets hard to follow and easy to break with a missing fi or ;. A single many-way branch is easier to read and to grade. In C this is switch. In shell it is case. Think of it this way: based on whatever input you have given, the flow switches to the block whose pattern matches, and that block runs — everything else is skipped. This gives clarity when you would otherwise need ten or fifteen layered if-else tests. Instead of a staircase that is hard to visualise, you write one case with several labelled shelves, and the reader can spot at once which value maps to which action.

11.2.2 Syntax: case, in, Patterns, ;; and esac

The keywords are case, in, ;;, and esac. esac is case spelled backward — it marks the end of the whole structure, just as fi marks the end of an if. A minimal skeleton looks like:

case \$variable_name in
  pattern1)
    commands for pattern1
    ;;
  pattern2)
    commands for pattern2
    ;;
  *)
    commands for anything else
    ;;
esac

Visual intuition: draw a vertical flowchart. A diamond at the top labelled \$variable. Three horizontal branches to the right, each with a label hello), bye), *). Each branch leads into a rectangle of commands and ends with a thick bar labelled ;; that routes back to a single exit point below esac. Only the branch whose label matches lights up; the others stay dim. The final echo "that's all folks" sits below esac and always lights up.

11.2.3 Pattern Details and the Catch-All Star

A pattern can be an integer or a string — you define it to fit what you plan to match. Examples: 0) matches the string 0 (used for remainder in 11.3), hello) matches the word hello, *.log) matches any word ending in .log. Several patterns can be written, for example pattern1, pattern2, pattern3, pattern4, and the value is matched in order until a match is found. If no match is found and there is no *, nothing inside the case runs — a silent no-op that can be confusing without a default. If there is a *, its block runs as the fallback.

Shell patterns inside case support a few useful shorthands:

• | for alternation: hello|hi|hey) matches any of the three.
• Character classes: [Yy]es) matches Yes or yes.
• Wildcards: file* matches file1, filename, etc.; *.txt matches text files.

11.2.4 Worked Example: Hello-Bye Conversation

A small interactive script shows the whole mechanism. The file is often called case.sh.

#!/bin/bash
echo "Please talk to me"
read input_string
case \$input_string in
  hello)
    echo "hello yourself"
    ;;
  bye)
    echo "see you again"
    ;;
  *)
    echo "sorry, I don't understand"
    ;;
esac
echo "that's all folks"

\$ bash case.sh
Please talk to me
hello
hello yourself
that's all folks

\$ bash case.sh
Please talk to me
bye
see you again
that's all folks

\$ bash case.sh
Please talk to me
hello me
sorry, I don't understand
that's all folks

Real-world & domain connection: System scripts use case exactly like this to dispatch on the first argument: case "\$1" in start) start_service ;; stop) stop_service ;; restart) stop_service; start_service ;; *) echo "Usage: \$0 {start|stop|restart}" ;; esac. Package managers, init scripts, and CLI tools all follow the pattern — one case at the top selects the mode, each branch runs a pipeline, and *) prints usage. The shape you practised with hello/bye is the production shape.

11.3 Arithmetic Forms and the Odd-Even Program with case

11.3.1 Evaluating Arithmetic: Double Parentheses, Backticks and expr

Shell arithmetic needs an evaluator — the shell does not do n % 2 by itself unless you invoke one.

remainder=\$(( input_number % 2 ))
# or equivalently
remainder=\$(( \$input_number % 2 ))

remainder=`expr \$input_number % 2`

remainder=\$(expr \$input_number % 2)

Symbol guide on first use:

• $\text{input\_number}$ — the value read from the user, treated as an integer for the remainder test. In shell this lives in input_number after read input_number.
• $\text{remainder}$ — defined as

$$\text{remainder}=\text{input\_number}\mathrm{mod}2$$ value 0 for even, 1 for odd. An integer in $\{0,1\}$ when the input is an integer. In shell this is remainder.

• $2$ — the divisor for the even-odd test. Changing it to 10 would give the last decimal digit instead.

Detailed intuition with numbers: $4\mathrm{mod}2=0$ because $4=2\times 2+0$. $5\mathrm{mod}2=1$ because $5=2\times 2+1$. The remainder is what is left after taking out as many 2s as possible.

11.3.2 Building the Odd-Even Script Step by Step

The aim is to tell whether a given number is odd or even, but now using case instead of if. The file is often named case_odd_num.sh.

#!/bin/bash
printf "Enter the number to be checked\n"
read input_number
remainder=\$(( input_number % 2 ))
case \$remainder in
  0)
    printf "This is an even number\n"
    ;;
  1)
    printf "This is an odd number\n"
    ;;
  *)
    printf "I do not understand\n"
    ;;
esac

Comparison — two ways to get the same remainder:

When to pick: inside a Bash script prefer \$(( … )); when reading a legacy script that already uses expr, recognise the backtick form as equivalent.

11.3.3 Running the Script and Fixing the Missing Semicolons

syntax error near unexpected token `1)'

\$ bash case_odd_num.sh
Enter the number to be checked
2
This is an even number

\$ bash case_odd_num.sh
Enter the number to be checked
3
This is an odd number

The live edit also added printf "\$remainder\n" before the case to make the branching value visible — a standard debugging move: print the discriminator before you dispatch on it.

11.3.4 What Happens with Letters Instead of Numbers

Enter the number to be checked
a
This is an even number
b
This is an even number
c
This is an even number
wow
This is an even number
he
This is an even number

Visual intuition: imagine a funnel labelled \$(( … )) that has a sieve at the top. Numbers fall through unchanged; words are caught, replaced by a 0 chip, and that chip drops into the mod 2 machine. Both the a chip and the wow chip are swapped for 0, so the machine always outputs 0.

Real-world & domain connection: Production scripts that read user input or CSV fields always guard before arithmetic. A payroll script that computes pay = days * rate will first test case "\$days" in ''|*[!0-9]*) echo "bad days: \$days" >&2; continue;; esac before (( pay = days * rate )). Without that guard, a missing field becomes 0 and an employee silently gets zero pay — exactly the silent-wrong-answer class this odd-even demo was designed to expose.

11.4 The for Loop — List and C-Style Forms

11.4.1 List Form: for Variable in List; do ... done

The for loop is one of the most used constructs. Shell offers a form that iterates over a list of words — the list is written explicitly, not as a range object.

for variable in list
do
  commands using \$variable
done

for i in 1 2 3 4 5
do
  echo \$i
done

Intuition — the conveyor belt: picture a conveyor belt carrying parcels labelled 1, 2, 3, 4, 5. The worker (i) picks one parcel each cycle, carries it into the do … done room, runs the commands while holding that parcel, puts it down, and goes back for the next. When the belt is empty, the worker stops.

11.4.2 Mixed Lists and Type Behaviour

A list can be mixed without any change in syntax:

for i in 1 hello mine you 0
do
  echo \$i
done

The shell treats list items as words. When you later use a word in arithmetic, the shell decides how to handle it. The session built a richer loop often called for1.sh to see this:

for i in 1 2 3 4 5 hello I am fine
do
  printf "Looping number %s incremented value is %s\n" "\$i" "\$(( i + 1 ))"
done

A variant tried to compute \$(( \$i + 1 )) when i itself held the letter i. Writing i=i and then \$(( \$i + 1 )) with \$i inside caused a recursion-like expansion error because the evaluator kept expanding the variable name as if it referred to itself. Changing the variable name to something other than i for the outer loop removed the confusion — a concrete lesson to keep the loop variable distinct from any value that looks like the same letter when expanded inside \$(( … )). Modern shells handle \$(( i + 1 )) without the extra \$ more robustly, which is another reason to prefer the form without \$.

Looping number 1 incremented value is 2   # 1+1=2
Looping number 2 incremented value is 3   # 2+1=3
Looping number 3 incremented value is 4   # 3+1=4  (recorded as "4→5" in class notes)
Looping number 4 incremented value is 5   # 4+1=5
Looping number 5 incremented value is 6   # 5+1=6

Looping number hello incremented value is 1   # hello→0, 0+1=1
Looping number I incremented value is 1       # I→0, 0+1=1
Looping number am incremented value is 1      # am→0, 0+1=1
Looping number fine incremented value is 1    # fine→0, 0+1=1

11.4.3 Glob Expansion: When Star Becomes a File List

Another run used the list hello 1 * 2 goodbye. The * did not stay as a star character. It expanded to the list of files in the current directory, as if ls had been run.

Looping number hello ...
Looping number 1 ...
Looping number file1 ...
Looping number file2 ...
Looping number 2 ...
Looping number goodbye ...

where file1, file2 were the actual file names present where the script ran. The expansion happened before the loop saw the list. This is globbing or pathname expansion: the pattern * matches every file and directory name in the current directory (hidden dot-files excluded without dotglob).

Visual intuition: imagine the * as a wildcard-shaped stencil placed over a tray of name cards. When laid down, the stencil lights up every card at once and hands the whole lit set to the for belt. If you wrap the stencil in plastic (quotes or \), the light cannot get through — only the stencil shape itself is handed over.

The shell order that matters here is: brace expansion → tilde expansion → parameter expansion → globbing → word splitting. The * glob happens after \$i expands but before for iterates, which is why the loop sees file names and not a star.

11.4.4 Keeping Star Literal: Escape and Quotes

To keep * as a plain character, three ways work:

for i in hello 1 \* 2 goodbye   # with backslash escape
for i in hello 1 '*' 2 goodbye  # with single quotes
for i in hello 1 "*" 2 goodbye  # with double quotes

All three give:

hello
1
*
2
goodbye

instead of a file list. The backslash escapes the special meaning, and quoting hides it from expansion. The same idea applies to other wild characters (?, […]) when you want the literal shape rather than the pattern. The demo contrasted the two runs back-to-back so the difference was unmistakable: unquoted * → file list; quoted/escaped * → one item *.

11.4.5 C-Style for and Shell Compatibility

Shell also supports a C-like three-expression form:

for (( c=1; c<=5; c++ ))
do
  echo "welcome \$c"
done

# for2.sh
for (( c=1; c<=5; c++ ))
do
  echo "welcome \$c"
done

\$ bash for2.sh
welcome 1
welcome 2
welcome 3
welcome 4
welcome 5

\$ sh for2.sh
welcome 1
welcome 2
welcome 3
welcome 4
welcome 5

Real-world & domain connection: DevOps tooling uses both forms daily. A deploy script uses for h in "\${hosts[@]}" to ssh into each host and rsync a build; a benchmark script uses for (( i=0; i<1000; i++ )) to time an operation and average the result. The list form dominates file and host tasks; the C-style dominates arithmetic sweeps. Knowing which to reach for — and how to keep * literal when you need the character, not the file list — is exactly what the session's contrasting runs drilled.

11.5 The while Loop — Test-Driven Repetition

11.5.1 Syntax and Test Operators

A while loop repeats as long as a given condition is true:

while [ condition ]
do
  commands
done

i=1
while [ \$i -le 5 ]
do
  echo \$i
  i=\$(( i + 1 ))
done

Visual intuition: picture a turnstile with a sign that reads the current value of i. The gate lifts only while the sign shows $i\le 5$ in green. Each trip through the loop room increments the sign by one. After 5→6, the sign flips red — gate stays down, and the crowd routes to done. Forgetting the increment is like a turnstile that never updates the sign — the green light never turns red.

Comparison — for vs while for the same count 1…5:

11.5.2 Infinite Loops, Colon and Interrupt Exit Status

while :
do
  echo "Please talk to me"
  read input_string
  # ... case dispatch ...
done

Please talk to me
hello
hello yourself
Please talk to me
hi
sorry, I don't understand
Please talk to me
^C

echo \$?
130

Real-world illustration: administrators write guarded while loops to process log files or payroll CSV files. The sketch is:

while IFS=, read name days rate; do
  # validate \$name, compute pay, write slip
done < payroll.csv

Here read returning false at end-of-file ends the loop naturally, not a colon. The while : form is reserved for interactive daemons that should run forever until an operator stops them.

11.5.3 Guarded Reading Loop

A second while example avoids the infinite case by adding a real string test:

input_string="hello"
while [ "\$input_string" != "bye" ]
do
  printf "Please type something in (bye to quit)\n"
  read input_string
  printf "%s\n" "\$input_string"
done

Please type something in (bye to quit)
I am fine
I am fine
Please type something in (bye to quit)
how are you
how are you
Please type something in (bye to quit)
bye
bye
# loop stops — "bye" != "bye" is false

Real-world & domain connection: In systems programming, while with a string guard is exactly how interactive tools stay alive — a network daemon does while [ "\$cmd" != "quit" ]; do read cmd; case "\$cmd" in …; esac; done — and while IFS= read -r line is the standard way to process a log file line-by-line without loading it all into memory. The integer guard while [ \$attempts -le 3 ] implements retry logic for flaky curl or ssh calls, incrementing attempts and sleeping between tries. The colon form while :; do …; sleep 60; done appears in monitoring watchdogs that poll forever until an operator interrupts them.

11.6 The until Loop — Running Until a Condition Becomes True

11.6.1 How until Differs from while

The until loop looks exactly like while but runs with the opposite sense:

until [ condition ]
do
  commands
done

Comparison table — while vs until for the same job:

Visual intuition: draw the same turnstile as for while, but now the sign is a stop sign that is red while $i\ne 10$ and flips green at $i=10$. For while [ \$i -le 5 ] the gate lifted on green; for until [ \$i -eq 10 ] the gate lifts on red and drops on green. Same machine, opposite colour rule.

11.6.2 Countdown Example and the Equality Trap

A file often called until1.sh held:

i=3
until [ \$i -eq 0 ]
do
  echo \$i
  i=\$(( i - 1 ))
done

3
2
1

If the test was until [ \$i -ne 3 ] with i=3, the trace is:

• i=3: [ 3 -ne 3 ] → false → until enters → prints 3 → i decrements to 2.
• i=2: [ 2 -ne 3 ] → true → until stops. Only 3 printed.

The lesson: phrase the final state you want to reach, not the state you want to keep, and test with the actual starting value.

11.6.3 Counting from Zero to Nine

A classroom exercise asked to count from 0 to 9 using until. This is the exercise that exposed three successive bugs.

i=0
until [ \$i -le 9 ]
do
  echo \$i
  i=\$(( i + 1 ))
done

i=0
until [ \$i -eq 10 ]
do
  echo \$i
  i=\$(( i + 1 ))
done

Real-world & domain connection: until appears wherever a script waits for a condition produced outside the loop — until ping -c1 dbhost >/dev/null 2>&1; do echo "waiting for DB"; sleep 2; done keeps polling until the database answers, and until [ -f /tmp/ready ]; do sleep 1; done waits until another job creates a sentinel file. The countdown shape you just debugged — until [ \$i -eq 10 ] — is the same shape as until [ "\$status" = "ready" ] used to wait for a service to become ready in deployment scripts.

11.7 Loop Control with break and continue

11.7.1 Definitions in the Payroll Scenario

Two keywords fine-tune loops: break leaves the current loop right away and does not come back; continue leaves the current iteration and resumes with the next iteration of the same loop. Both work inside for, while, or until.

while IFS=, read name days rate; do
  if [ -z "\$name" ]; then
    echo "name missing, stopping" >&2
    break          # essential field missing — halt the whole payroll
  fi
  if [ -z "\$remark" ]; then
    continue       # optional field missing — skip this line's remark, next record
  fi
  # compute pay using \$days and \$rate
done < payroll.csv

Visual intuition: picture the loop as a circular track with a do gate and a done wall. break is a trapdoor that drops you outside the circle at done. continue is a shortcut chute that jumps from mid-lap back to the do gate for the next lap. break ends the race; continue skips the rest of this lap but stays in the race.

11.7.2 Demonstrating break Inside for

A test inside for1.sh inserted a guarded if before the body action:

for i in hello 1 "*" 2 goodbye 1 2 3 4 5
do
  if [ "\$i" = "1" ]
  then
    break
  fi
  echo "\$i"
done

hello

for i in 1 2 3 4 5
do
  if [ "\$i" = "3" ]
  then
    break
  fi
  echo "\$i"
done

1
2

11.7.3 Demonstrating continue Inside for

Replacing break with continue at the same spot:

for i in 1 2 3 4 5
do
  if [ "\$i" = "3" ]
  then
    continue
  fi
  echo "\$i"
done

1
2
4
5

for f in *; do
  if [ "\$f" = "tmp" ]; then continue; fi
  if [ ! -f "\$f" ]; then continue; fi   # skip non-regular files
  echo "\$f is a regular file"
done

Real-world & domain connection: In production, break guards against corrupt essential state — if [ -z "\$days" ]; then echo "missing days for \$name, aborting" >&2; break; fi stops a payroll before it emits wrong slips. continue guards against optional noise — if [ "\$log" = "*.tmp" ]; then continue; fi skips temporary files while archiving logs, and if [ ! -r "\$file" ]; then echo "cannot read \$file, skipping" >&2; continue; fi keeps a backup loop going past one unreadable file instead of failing the whole nightly job. The same two-keyword choice appears in every file-processing pipeline you touched with for f in *.

11.8 Arrays — Grouping Mixed Data

11.8.1 What a Shell Array Is and How Indexing Works

An array (ordered collection) groups values in a systematic way so you can refer to each by its position. Unlike C where an array holds one declared type such as integers or characters, a shell array can hold a mix: a number, then a string, then a single character, then another number. By default every element inside is treated as a string — that is, text. That means 10 is the two-character string "10" until you use it in arithmetic, when the shell coerces it to the integer $10$. This is the same "string until used as number" rule you saw with remainder=\$(( input_number % 2 )) in 11.3.

Indexes start at 0 — the first slot is index 0, the second is 1, and so on. So array[0] is the first element, array[2] the third. The index helps you refer to a particular place in the array later. Special forms let you ask for the whole array (\${array[@]}) or its length (\${#array[@]}).

Visual intuition: draw a horizontal strip divided into boxes 0|1|2|3|4. Fill 0:"error" 1:"zero" 2:"two" 4:"four", leave 3 blank with a dashed outline. An arrow labelled \${array[@]} sweeps left to right showing error zero two four (skipping the blank). An arrow labelled \${array[2]} points only at "two". A badge \${#array[@]} shows 4 — four occupied boxes, not five.

11.8.2 Three Ways to Assign Arrays

Three assignment styles were shown, all valid and interchangeable. All create indexed arrays (numeric keys). A fourth associative style (declare -A) exists in newer Bash but was not used in this lecture.

1. Direct indexed assignment, in any order:

array[0]=10
array[1]="hello"
array[2]=X
array[3]=42
array[4]="mixed"

Here array[0] holds 10, array[1] holds hello, and so on. The order of assignment does not need to be sorted — you can set array[4] before array[0] and the array still has the same contents.

2. Compound indexed assignment in one line — index given explicitly:

array=([0]=10 [1]=20 [2]=30 [3]="program")

Each bracket names the index for the following value. This form lets you create sparse sets in one line: array=([0]="a" [3]="d") leaves 1 and 2 empty.

3. Short form without naming indexes — position decides:

array=(0 10 20 program)

Here placement decides the index: 0 goes to index 0, 10 to index 1, 20 to index 2, program to index 3. A fourth example mixes both: first value goes to 0, second explicitly to 3, leaving a gap, then further values follow. Gaps are allowed: array=(a b [5]=c d) puts a at 0, b at 1, c at 5, d at 6.

11.8.3 Printing: All Elements, Single Element and Slices

To print the whole array in one line you can use either * or @ inside the expansion:

echo \${array[@]}
echo \${array[*]}

for item in "\${array[@]}"; do echo "\$item"; done   # safe, each element one turn

echo \${array[0]}   # hole 0

echo \$array
# same as \${array[0]} in this shell

echo \${array[@]:1:2}   # starting at index 1, take 2 elements → holes 1 and 2
echo \${array[@]:2:2}   # starting at 2, take 2 → holes 2 and 3 (if 3 exists)
echo \${array[@]:2}     # from index 2 to the end

AR[0]=error
AR[1]=zero
AR[2]=two
# AR[3] left empty
AR[4]=four

echo \${AR[@]}
# → error zero two four
echo \${AR[*]}
# → error zero two four   (unquoted, looks the same)

echo \${AR[0]}          # → error
echo \$AR               # → error (same as \${AR[0]})
echo \${AR[2]}          # → two
echo \${AR[@]:1:2}      # → zero two   (holes 1 and 2)
echo \${AR[@]:2:2}      # → two four   (hole 2, then skip empty 3, then 4 — but count is by position, so with sparse arrays the result depends on Bash version's handling of gaps; the dense demo used contiguous data)

arr=("hello world" "I am" fine)
echo "\${arr[@]}"   # three words: "hello world"  "I am"  "fine"
echo "\${arr[*]}"   # one word:  "hello world I am fine"

11.8.4 Length and Gaps

Length is asked with #:

echo \${#array[@]}
echo \${#array[*]}

Both return the number of elements that are actually set. In the example with AR[0], AR[1], AR[2], AR[4] and nothing at AR[3], the length was 4, not 5.

AR[0]=error; AR[1]=zero; AR[2]=two; AR[4]=four
echo \${#AR[@]}   # → 4
echo \${#AR[*]}   # → 4
echo \${AR[@]}    # → error zero two four  (no blank where AR[3] would be)

Real-world illustration: administrators store lists of hosts, file names, or payroll fields in arrays and then loop safely:

hosts=(web1 web2 db1)
# or read from a file:
# mapfile -t hosts < hostlist.txt
for h in "\${hosts[@]}"; do
  echo "Checking \$h"
  ssh "\$h" uptime
done

To act on each element by index and show the position:

for idx in "\${!AR[@]}"; do
  printf "AR[%s]=%s\n" "\$idx" "\${AR[idx]}"
done

Real-world & domain connection: In DevOps and data pipelines, arrays turn a repeated scalar variable into a vector you can loop, filter, and slice. A build matrix stores versions=(14 16 18) and iterates for v in "\${versions[@]}"; do nvm use \$v && npm test; done. A log-rotation array logs=(/var/log/app.log /var/log/nginx/access.log) is filtered with for log in "\${logs[@]}"; do [ -f "\$log" ] && [ -s "\$log" ] && gzip "\$log"; done — the combination of array, for, and file tests (-f, -s) from 11.10 is exactly what this lecture was building toward.

11.9 String Tests and Operators

11.9.1 Equality, Inequality and Emptiness Tests

When comparing strings you use single-bracket tests [ … ] with string operators — integer operators like -eq are for numbers and will mis-handle words.

if [ -z "\$name" ]; then
  echo "name missing, stopping" >&2
  break
fi

Visual intuition: picture a ruler that measures the length of the string card "\$str". -z asks "is the ruler at zero?" (green if empty). -n asks "is the ruler past zero?" (green if any characters). = puts two cards side by side and asks "are they identical, character for character?".

11.9.2 Worked Walkthrough: string1.sh

A file named string1.sh built the checks step by step with STR="we":

STR="we"
printf "check -z\n"
if [ -z "\$STR" ]; then echo "empty"; else echo "not empty"; fi

printf "check -n\n"
if [ -n "\$STR" ]; then echo "not empty"; else echo "empty"; fi

printf "bare\n"
if [ "\$STR" ]; then echo "not empty"; else echo "empty"; fi

printf "equality\n"
if [ "\$STR" = "we" ]; then echo "strings are same"; else echo "strings are not same"; fi

Using operator -z
not empty
Using operator -n
not empty shown as non-zero length
bare test
not empty
we = we
strings are same

STR="hello"
if [ "\$STR" = "we" ]; then echo "strings are same"; else echo "strings are not same"; fi

Real-world & domain connection: Every robust shell pipeline starts with string guards. A deploy script does if [ -z "\$VERSION" ]; then echo "VERSION not set" >&2; exit 1; fi before touching production. An ETL job checks if [ "\$status" = "success" ]; then … else …; fi rather than [ \$status -eq … ]. The payroll CSV pattern this lecture used — [ -z "\$name" ] → break — is literally how HR batch jobs prevent emitting pay slips with blank names while letting optional fields through with continue.

11.10 File Tests and System Administration Checks

11.10.1 File Type Tests for Administrators

File tests are very useful for system and network administrators who must inspect many paths on a machine. The form is [ -letter "\$path" ] where the letter selects the test. The test runs the stat idea underneath and returns true (exit 0) if the path exists and has that file type.

The earlier for f in * loop gains power when combined with these tests. You can visit every name with * and then sort them by type inside the loop:

for f in *; do
  if [ -f "\$f" ]; then echo "\$f is a regular file"
  elif [ -d "\$f" ]; then echo "\$f is a directory"
  elif [ -L "\$f" ]; then echo "\$f is a symlink"
  elif [ -b "\$f" ]; then echo "\$f is a block device"
  elif [ -c "\$f" ]; then echo "\$f is a character device"
  fi
done

11.10.2 Permission and Special File Tests

Beyond type, tests check permissions and other properties — the questions an administrator asks during audits or before a destructive write.

if [ -x "\$file" ]; then echo "executable"; fi
if [ -d "\$file" ]; then echo "directory"; fi
if [ -b "\$file" ]; then echo "block file"; fi
if [ -c "\$file" ]; then echo "character file"; fi
if [ -w "\$file" ]; then echo "writable"; fi
if [ -s "\$file" ]; then echo "has content"; fi

Visual intuition: imagine each file as a card with five labelled holes (f, d, b, c, L) and three coloured stamps (r, w, x). Holding the card up to a light, the -letter test shines a beam through that hole — light comes through (true, 0) only when the hole is punched for that card. -s is a scale that tips only when the card has weight (size > 0).

11.10.3 Example Checks on Directories and Devices

A file named with a test for existence, often if_there.sh or similar, was used to ask about a path:

path="/dev/sda"
if [ -b "\$path" ]; then echo "block device"; else echo "not a block device"; fi

path="/dev/tty"
if [ -c "\$path" ]; then echo "character device"; else echo "not a character device"; fi

path="/tmp"
if [ -d "\$path" ]; then echo "directory"; else echo "not a directory"; fi

for f in *; do
  if [ -f "\$f" ]; then echo "\$f is a regular file"; fi
done

Real-world & domain connection: System and network administrators run these tests in nightly audit jobs that would be tedious by hand. A single loop for f in /var/log/*; do if [ -f "\$f" ] && [ -s "\$f" ] && [ ! -L "\$f" ]; then gzip "\$f"; fi; done archives only regular non-empty non-symlink logs. Before rotating a log you test [ -f "\$log" ] to be sure the log is a regular file; before writing you test [ -w "\$log" ]; before following a link you test [ -L "\$link" ] so you do not follow a symlink out of the intended directory. The permissions checks -r, -w, -x appear in hardening scripts that flag world-writable files ([ -w "\$f" ] plus mode checks) or non-executable scripts that should be executable.

Exam Guidance Summary

• Assignment is the major assessment for this block. Expect shell-scripting problems that require combining commands with arguments inside loops and branches — a single clever one-liner will not suffice. Group size is two; form your own group and submit one joint solution. Marks weight scripting and command fluency. Keep notes from this and the previous class together; the assignment draws on both. Slides for both sessions will be uploaded; a separate announcement will collect the group list, statement, and presentation schedule.

• Focus stays on shell control structures. No outside topics were introduced as examinable — keep effort on case (with ) , ;;, esac, * default, | alternation), for (list form for i in …; do … done and C-style for (( c=1; c<=5; c++ )) with Bash/sh portability), while (while [ \$i -le 5 ], while : infinite with 130 on Ctrl-C), until (until [ \$i -eq 10 ] for 0…9, the -le true-trap), break/continue (payroll essential→break, optional→continue, fix -eq→= and quoting), arrays (\${array[0]}, \${array[@]}, \${#array[@]}, slices \${array[@]:2:2}, gaps not counted), string tests (-z empty, -n/bare not-empty, =/!= with quotes), and file tests (-f, -d, -b, -c, -L/-h symlink vs -s non-empty, -r/-w/-x, -e).

• Question patterns practised and likely to recur:
• Fix a missing ;; or esac or ) in a case; predict output of case "\$input" in hello|hi) vs hello) vs *) vs "*") literal star.
• Compute a remainder with \$(( n % 2 )) versus ` expr \$n % 2 and branch on it with case \$remainder in 0) — and explain why a word input gives 0 (non-numeric → 0`, not ASCII) and therefore "even".
• Predict output of a for over a mixed list with * expansion (expands to file list when unquoted, stays * when '*'/"*"/\*), and of for i in 1 2 hello with \$(( i+1 )) (words → 1).
• Count from 0…9 with for, while, and until; the until bug until [ \$i -le 9 ] with i=0 gives nothing; the fix is until [ \$i -eq 10 ].
• Add a string emptiness test [ -z "\$name" ] before using a CSV field, choosing break vs continue by whether the column is essential.
• Write a file-type loop: for f in *; do if [ -f "\$f" ]; then echo "\$f is a regular file"; fi; done and variants with -d, -L, -x, -w, -s — with the -s vs -L distinction tested directly.
• Run echo \$? after a normal exit (0) vs after killing an infinite while : loop (130).

• Study advice — run, break, fix, re-run: Revisit every script from this and the previous class — case.sh, case_odd_num.sh, for1.sh, for2.sh, while guarded and infinite variants, until1.sh, the array demo, string1.sh, and the file-test example. Run them yourself, change one thing at a time, and read the error messages. The diagnostics that already appeared are your revision checklist: syntax error near unexpected token (missing ;;/)), integer expression expected (-eq on a word → use =), too many arguments (unquoted "\$var" with spaces or * → many words), and recursion level exceeded (i=i with \$(( \$i+1 )) → rename variable).

• Presentation advice — what graders reward: Start every script with a shebang #!/bin/bash on its own first line. Quote variables that hold strings ("\$var", "\$f", "\$name"). Show steps in comments. Put do and done (or then/fi, case/esac) on distinct lines rather than dense one-liners — clear flow is easier to grade. Make scripts executable (chmod +x) and test with both bash script.sh and sh script.sh when you rely on for (( )).

• Logistics and next quiz: Slides for today and the previous class will be uploaded shortly. Expect a separate announcement for group-list collection, assignment statement, and presentation schedule. A second quiz will come a little later after a few more topics are covered, so keep notes on loops, arithmetic, and tests fresh rather than cramming at the last minute.

Key Industry Applications

• Payroll and HR pipelines — while + CSV + case + break/continue: A production payroll job does while IFS=, read name days rate remark; do if [ -z "\$name" ]; then break; fi; case "\$days" in ''|*[!0-9]*) continue;; esac; pay=\$(( days * rate )); printf "%s,%s\n" "\$name" "\$pay"; done < payroll.csv. Essential fields (name, days) trigger break or validation with case patterns before arithmetic — because a word silently becomes 0 (hello→0→1 after +1 as seen in 11.3/11.4), so guarding before \$(( )) prevents a silent zero-pay error. Optional fields trigger continue. The case-dispatched odd-even logic and the string guards (-z, = ) are the same shapes you debugged in class.

• File-system and permission auditing — for f in * + file tests: System and network admins loop with for f in * (glob expands to names before the loop, Section 11.4.3) and sort inside with [ -f "\$f" ], [ -d "\$f" ], [ -b "\$f" ], [ -c "\$f" ], [ -L "\$f" ], [ -x "\$f" ], [ -w "\$f" ], [ -s "\$f" ], [ -e "\$f" ] — the exact set from 11.10. Examples: for f in /var/log/*; do if [ -f "\$f" ] && [ -s "\$f" ] && [ ! -L "\$f" ]; then gzip "\$f"; fi; done archives only regular non-empty non-symlink logs; if [ -w "\$log" ] guards a truncate before rotate; if [ -L "\$link" ] avoids following a symlink out of the intended directory; while :; do check_disk; sleep 60; done monitors forever until Ctrl-C (exit 130).

• Host-list and config vectors — arrays + quoted for: Data-prep and deployment scripts store hosts=(web1 web2 db1) or versions=(14 16 18) and iterate safely with for h in "\${hosts[@]}"; do ssh "\$h" uptime; done (Section 11.8). The \${#hosts[@]} count drives progress bars, \${hosts[@]:1:2} slices a rolling window, and gaps (hosts[0]=a hosts[4]=b) are handled by \${!hosts[@]} — the sparse-array lesson from AR[0]=error … AR[4]=four with length 4. Quoting "\${array[@]}" preserves spaces inside elements, the safe habit from 11.8.3.

• Input validation as a gate before arithmetic — string tests + case patterns: Treating a word as 0 when testing n % 2 (Section 11.3.4) is a known shell pitfall class. Production scripts precede remainder=\$(( n % 2 )) with case "\$n" in ''|*[!0-9]*) echo "not a number: \$n" >&2; continue;; esac or [ -z "\$n" ] guards — the same -z/-n/= operators from 11.9. Without that gate, empty CSV fields and stray words produce silently wrong branches in case \$remainder in 0) .

• Literal vs pattern handling at scale — quoting *: Log processing and file handling often need the literal character * or ? in searches; quoting or escaping (\*, "*", '*') keeps the character literal instead of expanding it to a file list (Section 11.4.4 and Q&A on "*") literal-star). The reverse — unquoted * as glob — is intentional when scanning a directory. Knowing which spelling to use is the difference between a regex that searches for *.log and a shell that expands *.log before grep even starts.

• Choosing the right loop form — list vs C-style vs test-driven: Both the classic list form for i in 1 2 3 4 5 and the C-like for (( i=1; i<=5; i++ )) appear in DevOps tooling (Section 11.4.5); the C-like form (c+=2 for steps) is common in Bash-heavy benchmark loops while the list form is the portable way to process arbitrary word lists and * glob results. Test-driven while [ "\$input" != "bye" ] and until [ \$i -eq 10 ] (Sections 11.5/11.6) implement interactive REPLs, until ping -c1 dbhost wait loops, and end-of-file readers — the triad you now choose from by wording: "while not …" → while, "until …" → until, "for each …" → for.