Loops and arguments

for item in list; do ... done iterates over a whitespace-separated list or a glob. The list is word-split and glob-expanded before the loop starts.

for color in red green blue; do
  echo "color: $color"
done

# Iterate over files — the glob expands before the loop
for f in /var/log/*.log; do
  echo "Processing $f"
  wc -l "$f"
done

When the glob matches nothing, $f holds the literal string /var/log/*.log by default. Add shopt -s nullglob at the top of your script to make non-matching globs expand to nothing instead.

For a numeric range, use brace expansion or C-style syntax:

for i in {1..5}; do echo "$i"; done
for (( i=0; i<5; i++ )); do echo "$i"; done

$1, $2, … hold positional arguments. $0 is the script name. $# is the count. "$@" expands each argument as a separate quoted word. Always use "$@" — never $* — when forwarding arguments to another command.

#!/usr/bin/env bash
echo "Script: $0"
echo "Arg count: $#"
echo "First arg: $1"

# Forward all arguments safely
rsync -av "$@" /backup/

"$@" with an argument my file.txt produces one word: my file.txt. $* (unquoted) or "$*" (quoted) joins all arguments into a single string — fine for printing, wrong for forwarding.

# With args: "file one.txt" "file two.txt"
for f in "$@"; do cp "$f" /backup/; done   # correct — 2 iterations
for f in $@;  do cp "$f" /backup/; done   # WRONG — splits on spaces → 4 iterations

shift discards $1 and renumbers remaining arguments: old $2 becomes new $1, etc. Use it to consume arguments one by one in option-parsing loops.

#!/usr/bin/env bash
verbose=0
output=""

while [[ $# -gt 0 ]]; do
  case "$1" in
    -v|--verbose) verbose=1; shift ;;
    -o|--output)  output="$2"; shift 2 ;;
    --)           shift; break ;;
    -*)           echo "Unknown option: $1" >&2; exit 1 ;;
    *)            break ;;
  esac
done

echo "verbose=$verbose output=$output remaining=$*"

shift 2 discards two arguments at once — needed after options that take a value (-o value). After parsing flags, "$@" holds the remaining positional arguments.

while read -r line; do ... done processes stdin line by line. The -r flag prevents read from interpreting backslashes. Without it, a line ending in \ is joined with the next line — a silent data corruption.

# Read lines from a file
while IFS= read -r line; do
  echo "Line: $line"
done < /etc/hosts

# Pipe into while read
find /var/log -name "*.log" | while IFS= read -r logfile; do
  echo "Found: $logfile"
done

IFS= (empty IFS) before read prevents stripping of leading/trailing whitespace from each line. Always pair IFS= read -r when reading file content faithfully.

while with a command condition loops until the command exits non-zero.

# Poll until a port opens (useful in startup scripts)
until nc -z localhost 5432 2>/dev/null; do
  echo "Waiting for postgres..."
  sleep 2
done
echo "Postgres is up"

# Process a queue file
while [[ -s queue.txt ]]; do
  item=$(head -1 queue.txt)
  process "$item"
  sed -i '1d' queue.txt
done

until is the inverse of while: it loops while the condition is non-zero (failure) and stops when it becomes zero (success). Both while and until evaluate the exit code of their condition command.