Shell Script Loops: Complete Guide and Reference

Table of Contents

Introduction to Shell Loops {#introduction}

Shell loops are fundamental control structures that allow you to execute a block of code repeatedly based on specific conditions or iterate through collections of data. They are essential for automating repetitive tasks, processing files, handling arrays, and creating efficient shell scripts.

Loops in shell scripting provide the ability to: - Process multiple files or directories - Repeat operations until a condition is met - Iterate through command-line arguments - Handle data from files or command output - Create menu-driven interfaces - Perform batch operations

Types of Loops {#types-of-loops}

Shell scripting supports three primary types of loops, each designed for specific use cases:

| Loop Type | Purpose | When to Use | |-----------|---------|-------------| | for | Iterate through a known list or range | When you know the number of iterations or have a specific set of items | | while | Continue while condition is true | When you need to loop based on a condition that may change during execution | | until | Continue until condition becomes true | When you want to loop until a specific condition is achieved |

Loop Syntax Comparison Table

| Loop Type | Basic Syntax | Condition Check | Termination | |-----------|--------------|-----------------|-------------| | for | for var in list; do ... done | Implicit (list exhaustion) | When list is exhausted | | while | while condition; do ... done | At beginning of each iteration | When condition becomes false | | until | until condition; do ... done | At beginning of each iteration | When condition becomes true |

For Loops {#for-loops}

The for loop is the most commonly used loop in shell scripting. It iterates through a list of items, executing the loop body for each item.

Basic For Loop Syntax

`bash for variable in list do # commands to execute done `

Alternative Compact Syntax

`bash for variable in list; do commands; done `

For Loop Variations

#### 1. Iterating Through a Simple List

`bash #!/bin/bash

Example 1: Basic list iteration

for fruit in apple banana orange grape do echo "Processing: $fruit" done `

Output: ` Processing: apple Processing: banana Processing: orange Processing: grape `

#### 2. Iterating Through Files

`bash #!/bin/bash

Example 2: Processing files in current directory

for file in *.txt do if [ -f "$file" ]; then echo "Found text file: $file" wc -l "$file" fi done `

#### 3. C-Style For Loop

`bash #!/bin/bash

Example 3: C-style for loop with numeric range

for ((i=1; i<=10; i++)) do echo "Number: $i" done `

#### 4. Using Brace Expansion

`bash #!/bin/bash

Example 4: Brace expansion for ranges

Numeric range

Character range

Step increment

#### 5. Command Substitution in For Loops

`bash #!/bin/bash

Example 5: Using command output as list

Process all users from /etc/passwd

Process files from find command

#### 6. Array Iteration

`bash #!/bin/bash

Example 6: Iterating through arrays

Declare array

Method 1: Direct array expansion

Method 2: Index-based iteration

For Loop with Command Line Arguments

`bash #!/bin/bash

Example 7: Processing command line arguments

echo "Processing all arguments:" for arg in "$@" do echo "Argument: $arg" done

Alternative using $*

While Loops {#while-loops}

The while loop continues executing as long as the specified condition remains true. It's ideal for situations where you don't know the exact number of iterations needed.

Basic While Loop Syntax

`bash while condition do # commands to execute done `

While Loop Examples

#### 1. Basic Counter Loop

`bash #!/bin/bash

Example 1: Simple counter

counter=1 while [ $counter -le 5 ] do echo "Count: $counter" counter=$((counter + 1)) done `

#### 2. Reading File Line by Line

`bash #!/bin/bash

Example 2: Reading file contents

filename="data.txt" line_number=1

while IFS= read -r line do echo "Line $line_number: $line" line_number=$((line_number + 1)) done < "$filename" `

#### 3. Menu-Driven Interface

`bash #!/bin/bash

Example 3: Interactive menu

choice="" while [ "$choice" != "quit" ] do echo "Menu Options:" echo "1. List files" echo "2. Show date" echo "3. Show users" echo "Type 'quit' to exit" read -p "Enter your choice: " choice case $choice in 1) ls -la ;; 2) date ;; 3) who ;; quit) echo "Goodbye!" ;; *) echo "Invalid option" ;; esac done `

#### 4. Monitoring System Resources

`bash #!/bin/bash

Example 4: System monitoring

while true do clear echo "System Monitor - $(date)" echo "========================" # CPU usage echo "CPU Usage:" top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1 # Memory usage echo "Memory Usage:" free -h | grep Mem # Disk usage echo "Disk Usage:" df -h | grep -E '^/dev/' echo "Press Ctrl+C to exit" sleep 5 done `

#### 5. Waiting for File Creation

`bash #!/bin/bash

Example 5: Wait for file to be created

target_file="/tmp/important_file.txt"

echo "Waiting for $target_file to be created..." while [ ! -f "$target_file" ] do echo "Still waiting... $(date)" sleep 2 done

echo "File $target_file has been created!" `

#### 6. Reading User Input Until Valid

`bash #!/bin/bash

Example 6: Input validation

valid_input=false while [ "$valid_input" = false ] do read -p "Enter a number between 1 and 10: " number if [[ "$number" =~ ^[0-9]+$ ]] && [ "$number" -ge 1 ] && [ "$number" -le 10 ]; then echo "Valid input: $number" valid_input=true else echo "Invalid input. Please try again." fi done `

Until Loops {#until-loops}

The until loop is the opposite of the while loop. It continues executing until the specified condition becomes true.

Basic Until Loop Syntax

`bash until condition do # commands to execute done `

Until Loop Examples

#### 1. Basic Counter with Until

`bash #!/bin/bash

Example 1: Counter using until

counter=1 until [ $counter -gt 5 ] do echo "Count: $counter" counter=$((counter + 1)) done `

#### 2. Wait Until Service is Running

`bash #!/bin/bash

Example 2: Wait for service to start

service_name="apache2"

echo "Waiting for $service_name to start..." until systemctl is-active --quiet $service_name do echo "Service not running, waiting..." sleep 3 done

echo "$service_name is now running!" `

#### 3. Wait Until File Size Reaches Threshold

`bash #!/bin/bash

Example 3: Monitor file size

target_file="/var/log/application.log" target_size=1048576 # 1MB in bytes

until [ -f "$target_file" ] && [ $(stat -f%z "$target_file" 2>/dev/null || stat -c%s "$target_file" 2>/dev/null || echo 0) -ge $target_size ] do current_size=$(stat -f%z "$target_file" 2>/dev/null || stat -c%s "$target_file" 2>/dev/null || echo 0) echo "Current file size: $current_size bytes, waiting for $target_size bytes..." sleep 5 done

echo "File has reached the target size!" `

#### 4. Network Connectivity Check

`bash #!/bin/bash

Example 4: Wait for network connectivity

host="google.com"

echo "Checking network connectivity to $host..." until ping -c 1 "$host" &> /dev/null do echo "No connectivity to $host, retrying..." sleep 5 done

echo "Network connectivity to $host established!" `

Loop Control Statements {#loop-control-statements}

Loop control statements allow you to alter the normal flow of loop execution.

Control Statement Types

| Statement | Purpose | Effect | |-----------|---------|---------| | break | Exit the loop immediately | Terminates the current loop and continues with the next statement after the loop | | continue | Skip current iteration | Skips the remaining commands in the current iteration and moves to the next iteration |

Break Statement Examples

#### 1. Breaking Out of For Loop

`bash #!/bin/bash

Example 1: Break in for loop

for num in {1..10} do if [ $num -eq 6 ]; then echo "Breaking at $num" break fi echo "Number: $num" done echo "Loop ended" `

#### 2. Breaking Out of While Loop

`bash #!/bin/bash

Example 2: Break in while loop

counter=1 while true do echo "Counter: $counter" if [ $counter -eq 5 ]; then echo "Breaking out of infinite loop" break fi counter=$((counter + 1)) done `

#### 3. Breaking Out of Nested Loops

`bash #!/bin/bash

Example 3: Breaking from nested loops

for i in {1..3} do echo "Outer loop: $i" for j in {1..5} do if [ $j -eq 3 ]; then echo " Breaking inner loop at j=$j" break fi echo " Inner loop: $j" done done `

Continue Statement Examples

#### 1. Skipping Even Numbers

`bash #!/bin/bash

Example 1: Skip even numbers

for num in {1..10} do if [ $((num % 2)) -eq 0 ]; then continue fi echo "Odd number: $num" done `

#### 2. Processing Valid Files Only

`bash #!/bin/bash

Example 2: Process only readable files

for file in /etc/* do if [ ! -r "$file" ]; then echo "Skipping unreadable file: $file" continue fi if [ -d "$file" ]; then echo "Skipping directory: $file" continue fi echo "Processing file: $file" # Process the file here done `

Nested Loops {#nested-loops}

Nested loops are loops inside other loops. They're useful for processing multi-dimensional data or performing complex iterations.

Nested Loop Examples

#### 1. Multiplication Table

`bash #!/bin/bash

Example 1: Multiplication table

echo "Multiplication Table (1-5):" echo " | 1 2 3 4 5" echo "---|---------------"

for i in {1..5} do printf "%2d | " $i for j in {1..5} do result=$((i * j)) printf "%2d " $result done echo done `

#### 2. File Processing in Multiple Directories

`bash #!/bin/bash

Example 2: Process files in multiple directories

directories=("/home/user/docs" "/home/user/projects" "/home/user/scripts") extensions=("txt" "log" "conf")

for dir in "${directories[@]}" do if [ -d "$dir" ]; then echo "Processing directory: $dir" for ext in "${extensions[@]}" do echo " Looking for .$ext files:" for file in "$dir"/*.$ext do if [ -f "$file" ]; then echo " Found: $(basename "$file")" fi done done fi done `

#### 3. Matrix Operations

`bash #!/bin/bash

Example 3: Simple matrix display

rows=3 cols=4

echo "Matrix ${rows}x${cols}:" for ((i=1; i<=rows; i++)) do for ((j=1; j<=cols; j++)) do value=$((i * cols + j - cols)) printf "%3d " $value done echo done `

Practical Examples {#practical-examples}

Example 1: Log File Analyzer

`bash #!/bin/bash

Log file analyzer script

log_file="/var/log/access.log" temp_dir="/tmp/log_analysis"

Create temporary directory

echo "Analyzing log file: $log_file" echo "================================"

Count different HTTP status codes

echo "HTTP Status Code Summary:" for status in "${!status_codes[@]}" do echo "Status $status: ${status_codes[$status]} occurrences" done

Find top 10 IP addresses

Example 2: System Backup Script

`bash #!/bin/bash

System backup script with progress indication

backup_source="/home/user/important_data" backup_dest="/backup/$(date +%Y%m%d_%H%M%S)" exclude_patterns=(".tmp" ".log" "cache/*")

echo "Starting backup process..." echo "Source: $backup_source" echo "Destination: $backup_dest"

Create backup directory

Build exclude options

Get total number of files to backup

echo "Total files to backup: $total_files" echo "Progress:"

Backup with progress indication

echo -e "\nBackup completed successfully!" echo "Backup location: $backup_dest" `

Example 3: Network Port Scanner

`bash #!/bin/bash

Simple network port scanner

target_host="$1" start_port="${2:-1}" end_port="${3:-1000}" timeout=1

if [ -z "$target_host" ]; then echo "Usage: $0 [start_port] [end_port]" echo "Example: $0 192.168.1.1 1 1000" exit 1 fi

echo "Scanning $target_host for open ports ($start_port-$end_port)..." echo "================================================"

open_ports=() closed_count=0

for ((port=start_port; port<=end_port; port++)) do # Use timeout and netcat to check port if timeout $timeout bash -c "echo >/dev/tcp/$target_host/$port" 2>/dev/null; then echo "Port $port: OPEN" open_ports+=($port) else ((closed_count++)) fi # Progress indicator if [ $((port % 100)) -eq 0 ]; then echo "Scanned up to port $port..." fi done

echo "================================================" echo "Scan completed!" echo "Open ports: ${open_ports[@]}" echo "Closed/filtered ports: $closed_count" `

Best Practices {#best-practices}

Performance Optimization

| Practice | Description | Example | |----------|-------------|---------| | Use appropriate loop type | Choose the right loop for your use case | Use for for known lists, while for conditions | | Minimize command substitution | Avoid expensive operations inside loops | Store command output in variables before the loop | | Use built-in operations | Prefer shell built-ins over external commands | Use $((i++)) instead of i=$(expr $i + 1) | | Quote variables properly | Always quote variables to handle spaces | "$variable" instead of $variable |

Code Quality Guidelines

#### 1. Proper Variable Quoting

`bash

Good practice

Bad practice - unquoted variables

#### 2. Error Handling in Loops

`bash #!/bin/bash

Good practice with error handling

files_processed=0 errors=0

for file in *.txt do if [ ! -f "$file" ]; then echo "No .txt files found" break fi if cp "$file" "/backup/" 2>/dev/null; then echo "Successfully copied: $file" ((files_processed++)) else echo "Error copying: $file" >&2 ((errors++)) fi done

echo "Summary: $files_processed files processed, $errors errors" `

#### 3. Using Arrays Effectively

`bash #!/bin/bash

Efficient array processing

Declare array

Process array efficiently

Memory and Resource Management

#### 1. Handling Large Files

`bash #!/bin/bash

Memory-efficient file processing

large_file="/var/log/huge_logfile.log" chunk_size=1000

line_count=0 while IFS= read -r line do # Process line echo "Processing line $((++line_count)): ${line:0:50}..." # Process in chunks to avoid memory issues if [ $((line_count % chunk_size)) -eq 0 ]; then echo "Processed $line_count lines, pausing..." sleep 1 fi done < "$large_file" `

#### 2. Resource Cleanup

`bash #!/bin/bash

Proper resource cleanup

temp_files=() trap 'cleanup' EXIT

cleanup() { echo "Cleaning up temporary files..." for temp_file in "${temp_files[@]}" do if [ -f "$temp_file" ]; then rm "$temp_file" echo "Removed: $temp_file" fi done }

Main processing loop

Common Pitfalls and Solutions {#common-pitfalls}

Pitfall Analysis Table

| Pitfall | Problem | Solution | Example | |---------|---------|----------|---------| | Infinite loops | Loop condition never becomes false | Always ensure loop variable is modified | Use counters or break conditions | | Unquoted variables | Variables with spaces break | Always quote variables | Use "$var" not $var | | Command substitution in loops | Performance degradation | Move expensive operations outside | Pre-calculate values | | File globbing issues | Patterns don't match files | Check for file existence | Use conditional checks |

Common Mistakes and Fixes

#### 1. Infinite Loop Prevention

`bash

Problem: Infinite loop

Solution: Always modify loop variable

#### 2. Proper File Handling

`bash

Problem: Doesn't handle files with spaces

Solution: Use glob patterns directly

#### 3. Array Iteration Issues

`bash

Problem: Incorrect array iteration

Solution: Proper quoting

#### 4. Loop Variable Scope

`bash

Problem: Variable scope in subshells

Solution: Use process substitution or here-string

This comprehensive guide covers all aspects of using loops in shell scripts, from basic syntax to advanced techniques and best practices. The examples provided demonstrate real-world applications and common scenarios you'll encounter when writing shell scripts with loops.