Loops🔗

Part of a deep dive: Bash Scripting

Consult the map

Bash Scripting — step 5 of 6

← Conditionals · you are here · Functions →

Start the deep dive →

Loops are where scripting shifts from "commands in a file" to actual automation. Instead of running a command once, you run it against every server in a list, every log file in a directory, or every line of output from another command.

Where You Might Have Seen This🔗

If you've ever run the same command against a list of servers one at a time, you've already felt the problem loops solve — a loop is that repetition captured in a script. Windows batch files have FOR /F, every scripting language has the same concept; Bash just has two forms depending on whether you know the list upfront.

flowchart TD
    Q{"Do you know the full<br/>list before looping?"}
    Q -->|"Yes — an array, a glob,<br/>a range"| F["for loop"]
    Q -->|"No — reading a stream,<br/>waiting on a condition"| W["while loop"]

    style Q fill:#1a202c,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style F fill:#2f855a,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style W fill:#2f855a,stroke:#cbd5e0,stroke-width:2px,color:#fff

The for Loop🔗

Use for when you have a defined list to work through — servers to ping, files to process, values to validate. The list can be hardcoded, a glob pattern, an array, or a numeric range.

Iterating Over a List🔗

Basic for Loop
servers=("web-01" "web-02" "db-01")

for server in "${servers[@]}"; do   # (1)!
    ping -c 1 "${server}" &>/dev/null \
        && echo "UP:   ${server}" \
        || echo "DOWN: ${server}"
done

Always quote "${array[@]}" — without quotes, elements with spaces split into separate words.

Iterating Over Files🔗

The most common real-world use — process every file matching a glob pattern:

Loop Over Files
for logfile in /var/log/nginx/*.log; do
    echo "Processing: ${logfile}"
    wc -l "${logfile}"
done

When No Files Match

If *.log matches nothing, Bash passes the literal string *.log to your loop as the first item. Use shopt -s nullglob to expand an empty glob to nothing:

Safe Glob Handling
shopt -s nullglob   # (1)!
for logfile in /var/log/nginx/*.log; do
    wc -l "${logfile}"
done
shopt -u nullglob   # (2)!

Unmatched globs now expand to nothing — the loop body never runs if there are no files.
Restore default behaviour after the loop.

Iterating Over a Range🔗

Brace rangeWith stepC-style

Numeric Range
for i in {1..10}; do
    echo "Iteration ${i}"
done

Range with Step Size
for i in {0..100..10}; do
    echo "${i}%"
done

Use the C-style form when you need the index for arithmetic or need to control the step precisely:

C-Style for Loop
for (( i=0; i<5; i++ )); do
    echo "Index: ${i}"
done

The while Loop🔗

Use while when you don't know the list size upfront — reading a file line by line, waiting for a condition to become true, or processing a stream of unknown length.

Basic while Loop
count=1
while [[ ${count} -le 5 ]]; do
    echo "Count: ${count}"
    (( count++ ))
done

Reading a File Line by Line🔗

This is the canonical safe pattern — every part matters:

Read File Line by Line
while IFS= read -r line; do   # (1)!
    echo "Line: ${line}"
done < "/path/to/file.txt"    # (2)!

IFS= clears the field separator so leading/trailing whitespace is preserved. read -r prevents backslash from being treated as an escape character.
Redirects the file into the loop's stdin — the loop reads it line by line without a subshell.

Reading Command Output🔗

When the input is a live command rather than a file, use process substitution to feed it to the loop:

Read Command Output Line by Line
while IFS= read -r pod; do
    echo "Restarting: ${pod}"
    kubectl delete "${pod}"
done < <(kubectl get pods --field-selector=status.phase=Failed -o name)   # (1)!

< <(command) is process substitution — it runs the command and presents its output as a file-like stream. Unlike piping to while (which runs the loop in a subshell), this keeps any variables you set inside the loop visible in the parent shell.

Loop Control🔗

break and continue let you short-circuit a loop without restructuring the whole block:

break and continue
for file in /var/log/*.log; do
    if [[ ! -s "${file}" ]]; then
        continue   # (1)!
    fi

    if [[ "${file}" == *"debug"* ]]; then
        break      # (2)!
    fi

    echo "Processing: ${file}"
done

Skip empty files — move straight to the next iteration.
Stop the loop entirely when a debug log is reached.

Real-World Loop Patterns🔗

The patterns below draw on commands covered in other Essentials articles — grep for filtering and find for file discovery.

Server Health CheckLog File Batch ProcessingRetry Loop with Backoff

Iterate over a list of servers, track failures, and exit with a non-zero code if any are unreachable — making the script composable with monitoring and alerting tools:

Check a List of Servers
#!/usr/bin/env bash

servers=("web-01" "web-02" "web-03" "db-01")
failed=0

for server in "${servers[@]}"; do
    if ping -c 1 -W 2 "${server}" &>/dev/null; then
        echo "OK:   ${server}"
    else
        echo "FAIL: ${server}"
        (( failed++ ))
    fi
done

if [[ ${failed} -gt 0 ]]; then
    echo "${failed} server(s) unreachable" >&2
    exit 1
fi

echo "All servers reachable"

Process every log file in a directory and write a summary report — the kind of script that runs nightly from cron:

Summarise Every Log File
#!/usr/bin/env bash

log_dir="${1:-/var/log/nginx}"
report_file="/tmp/log-report-$(date +%Y%m%d).txt"

shopt -s nullglob
for logfile in "${log_dir}"/*.log; do
    size=$(du -sh "${logfile}" | cut -f1)
    lines=$(wc -l < "${logfile}")
    errors=$(grep -c " 5[0-9][0-9] " "${logfile}" 2>/dev/null || echo 0)
    echo "${logfile}: ${lines} lines, ${size}, ${errors} 5xx errors"
done >> "${report_file}"
shopt -u nullglob

echo "Report written to: ${report_file}"

Wait for a service to become available, retrying with increasing delays. Essential for deployment scripts that start a service and then need to use it:

Wait for a Service to Come Up
#!/usr/bin/env bash

max_attempts=5
attempt=1

while [[ ${attempt} -le ${max_attempts} ]]; do
    echo "Attempt ${attempt}/${max_attempts}..."

    if curl -sf "https://api.example.com/health" &>/dev/null; then
        echo "Service is up"
        exit 0
    fi

    echo "Not ready yet, waiting..."
    sleep $(( attempt * 5 ))   # (1)!
    (( attempt++ ))
done

echo "Service did not come up after ${max_attempts} attempts" >&2
exit 1

Increasing backoff: 5s, 10s, 15s, 20s, 25s — gives the service more time on each retry.

Practice Exercises🔗

Exercise 1: Count Files by Extension

Write a script that accepts a directory as its argument and prints the count of files with each of these extensions: .log, .gz, and .txt.

Solution

count-by-extension.sh
#!/usr/bin/env bash

dir="${1:-.}"

for ext in log gz txt; do
    count=$(find "${dir}" -maxdepth 1 -name "*.${ext}" | wc -l)
    echo ".${ext}: ${count} files"
done

find's full search options — filtering by age, type, and size — are covered in Finding Files.

Exercise 2: Process a Server List File

Write a script that reads a file of hostnames (one per line, # lines are comments) and for each hostname:

Skips blank lines and lines starting with #
Prints OK: <hostname> if ping succeeds
Prints FAIL: <hostname> if ping fails
Exits with a code equal to the number of failed hosts (0 if all pass)

Solution

check-hosts.sh
#!/usr/bin/env bash

hosts_file="${1:-hosts.txt}"
failed=0

while IFS= read -r host; do
    [[ -z "${host}" || "${host}" == \#* ]] && continue

    if ping -c 1 -W 2 "${host}" &>/dev/null; then
        echo "OK:   ${host}"
    else
        echo "FAIL: ${host}"
        (( failed++ ))
    fi
done < "${hosts_file}"

exit ${failed}

Quick Recap🔗

Use for when you have a defined list — hardcoded, a glob, an array, or a range
Use while when you don't know the size upfront — file input, streams, retry loops
while IFS= read -r line; do ... done < file — the correct pattern for reading files line by line
< <(command) — process substitution; feeds command output to a loop without a subshell
shopt -s nullglob before glob loops — prevents the literal glob string when no files match
Quote array expansions: "${array[@]}" — prevents word splitting on elements with spaces
break exits the loop; continue skips to the next iteration

What's Next?🔗

Head to Functions — how to group reusable logic, scope variables with local, and structure larger scripts with the main "$@" pattern.