Command documentation sourced from the linux-command project This comprehensive command reference is part of the linux-command documentation project.
break - Exit from for, while, or until loops
The break command is a shell builtin that allows you to exit from for, while, or until loops prematurely. It provides a fundamental control flow mechanism in shell scripting, enabling early termination of loops based on specific conditions. The break command is essential for implementing efficient loop control, error handling, and conditional processing in shell scripts. It can exit from nested loops by specifying a break level, making it a powerful tool for complex loop structures.
Basic Syntax
break [n]
Parameters
n- Optional integer specifying the number of enclosing loops to exit from (default: 1)
Basic Usage Examples
# Exit current loop
break
# Exit from 2 enclosing loops
break 2
# Exit from 3 nested loops
break 3
Loop Control Basics
For Loop Control
# Basic for loop with break
for i in {1..10}; do
echo "Processing item $i"
if [ $i -eq 5 ]; then
echo "Reached item 5, breaking loop"
break
fi
done
# For loop over files with condition
for file in *.log; do
if [ -f "$file" ]; then
echo "Processing $file"
if grep -q "ERROR" "$file"; then
echo "Found error in $file, stopping processing"
break
fi
fi
done
While Loop Control
# While loop with user input
while true; do
read -p "Continue processing? (y/n): " choice
case $choice in
[Nn]* ) break ;;
[Yy]* ) echo "Continuing..." ;;
* ) echo "Please answer y/n" ;;
esac
done
# While loop with timeout
counter=0
while [ $counter -lt 60 ]; do
if check_service_status; then
echo "Service is running"
break
fi
sleep 1
((counter++))
done
Until Loop Control
# Until loop with break condition
until ping -c 1 google.com &> /dev/null; do
echo "Waiting for network connection..."
attempts=$((attempts + 1))
if [ $attempts -gt 10 ]; then
echo "Maximum attempts reached, giving up"
break
fi
sleep 2
done
Advanced Loop Control
Nested Loop Control
# Breaking from nested loops
for i in {1..3}; do
echo "Outer loop: $i"
for j in {1..5}; do
echo " Inner loop: $j"
if [ $j -eq 3 ] && [ $i -eq 2 ]; then
echo " Breaking both loops"
break 2
fi
done
done
# Three-level nested loops
for dir in */; do
for subdir in "$dir"*/; do
for file in "$subdir"*.txt; do
if [ -f "$file" ]; then
echo "Found: $file"
if grep -q "critical" "$file"; then
echo "Critical file found, stopping search"
break 3
fi
fi
done
done
done
File Processing with Break
# Process files until condition met
for file in *.data; do
if [ ! -f "$file" ]; then
continue
fi
echo "Processing $file"
size=$(stat -f%z "$file" 2>/dev/null || stat -c%s "$file" 2>/dev/null)
if [ $size -gt 10485760 ]; then # 10MB
echo "Large file found: $file ($size bytes)"
break
fi
# Process file content
process_file "$file"
done
# Log file analysis
for logfile in /var/log/app*.log; do
if [ -f "$logfile" ]; then
echo "Analyzing $logfile"
if tail -20 "$logfile" | grep -q "FATAL ERROR"; then
echo "Fatal error detected in recent logs"
echo "File: $logfile"
tail -10 "$logfile"
break
fi
fi
done
Practical Scripting Examples
Menu Systems with Break
#!/bin/bash
# Interactive menu with break
while true; do
echo "=== System Administration Menu ==="
echo "1. Check disk space"
echo "2. Show running processes"
echo "3. Network status"
echo "4. Exit"
echo "=================================="
read -p "Select an option: " choice
case $choice in
1)
echo "Disk space usage:"
df -h
echo ""
;;
2)
echo "Running processes:"
ps aux | head -10
echo ""
;;
3)
echo "Network status:"
ip addr show
echo ""
;;
4)
echo "Exiting menu..."
break
;;
*)
echo "Invalid option. Please try again."
echo ""
;;
esac
read -p "Press Enter to continue..."
clear
done
echo "Menu exited successfully"
Error Handling with Break
#!/bin/bash
# Robust file processing with error handling
process_files() {
local file_count=0
local error_count=0
local max_errors=3
for file in "$@"; do
if [ ! -f "$file" ]; then
echo "Error: File '$file' not found"
((error_count++))
if [ $error_count -ge $max_errors ]; then
echo "Maximum error count reached, aborting"
return 1
fi
continue
fi
echo "Processing: $file"
if ! process_single_file "$file"; then
echo "Error processing '$file'"
((error_count++))
if [ $error_count -ge $max_errors ]; then
echo "Maximum error count reached, aborting"
return 1
fi
else
((file_count++))
echo "Successfully processed '$file'"
fi
done
echo "Processed $file_count files successfully"
return 0
}
# Main execution
if ! process_files "$@"; then
echo "Processing failed due to errors"
exit 1
fi
Search and Replace with Break
#!/bin/bash
# Search for specific pattern in multiple files
target_pattern="CRITICAL_ERROR"
replacement_pattern="RESOLVED_ERROR"
max_matches=5
total_matches=0
for file in $(find . -name "*.log" -type f); do
echo "Checking $file..."
if grep -q "$target_pattern" "$file"; then
match_count=$(grep -c "$target_pattern" "$file")
echo "Found $match_count matches in $file"
total_matches=$((total_matches + match_count))
# Ask user before making changes
read -p "Replace occurrences in $file? (y/n): " confirm
if [[ $confirm =~ ^[Yy]$ ]]; then
sed -i.bak "s/$target_pattern/$replacement_pattern/g" "$file"
echo "Replacements made in $file"
fi
if [ $total_matches -ge $max_matches ]; then
echo "Reached maximum match limit ($max_matches)"
echo "Total matches found: $total_matches"
break
fi
fi
done
echo "Search complete. Total matches processed: $total_matches"
System Administration Applications
Service Monitoring with Break
#!/bin/bash
# Monitor multiple services and break on first failure
services=("nginx" "mysql" "redis" "postgresql")
max_wait_time=30
check_interval=2
echo "Starting service monitoring..."
for service in "${services[@]}"; do
echo "Checking $service service..."
wait_time=0
while [ $wait_time -lt $max_wait_time ]; do
if systemctl is-active --quiet "$service"; then
echo "✓ $service is running"
break 2 # Exit both loops - service is running
fi
echo "Waiting for $service to start... ($wait_time/$max_wait_time)"
sleep $check_interval
wait_time=$((wait_time + check_interval))
done
echo "✗ $service failed to start within $max_wait_time seconds"
echo "Stopping monitoring due to service failure"
break
done
echo "Service monitoring complete"
Disk Space Management
#!/bin/bash
# Monitor disk space and take action when threshold exceeded
threshold=90
check_dirs=("/var/log" "/tmp" "/home")
action_taken=false
for dir in "${check_dirs[@]}"; do
if [ -d "$dir" ]; then
usage=$(df "$dir" | awk 'NR==2 {print $5}' | sed 's/%//')
echo "Directory $dir usage: ${usage}%"
if [ $usage -gt $threshold ]; then
echo "WARNING: $dir usage is ${usage}% (threshold: ${threshold}%)"
# Find and remove old files
find "$dir" -type f -mtime +7 -exec rm -v {} \;
action_taken=true
# Recheck usage
new_usage=$(df "$dir" | awk 'NR==2 {print $5}' | sed 's/%//')
echo "New usage after cleanup: ${new_usage}%"
if [ $new_usage -gt $threshold ]; then
echo "Still above threshold after cleanup, stopping further checks"
break
fi
fi
fi
done
if [ "$action_taken" = true ]; then
echo "Disk space cleanup completed"
else
echo "All directories within normal usage limits"
fi
Data Processing Scenarios
CSV Processing with Break
#!/bin/bash
# Process CSV files and break on data integrity issues
input_files=("data1.csv" "data2.csv" "data3.csv")
required_columns=5
processed_count=0
for csv_file in "${input_files[@]}"; do
if [ ! -f "$csv_file" ]; then
echo "Error: File $csv_file not found"
break
fi
echo "Processing $csv_file..."
# Check header
header=$(head -1 "$csv_file")
column_count=$(echo "$header" | tr ',' '\n' | wc -l)
if [ $column_count -ne $required_columns ]; then
echo "Error: $csv_file has $column_count columns (expected $required_columns)"
echo "Header: $header"
break
fi
# Check for empty rows
empty_rows=$(awk -F',' 'NF==0 {count++} END {print count+0}' "$csv_file")
if [ $empty_rows -gt 0 ]; then
echo "Warning: $csv_file contains $empty_rows empty rows"
fi
# Process data
line_number=0
while IFS=, read -r col1 col2 col3 col4 col5; do
((line_number++))
# Skip header
[ $line_number -eq 1 ] && continue
# Validate data
if [[ -z "$col1" || -z "$col2" || -z "$col3" ]]; then
echo "Data integrity error at line $line_number in $csv_file"
echo "Missing required fields"
break 2 # Exit both loops
fi
# Process valid row
process_data_row "$col1" "$col2" "$col3" "$col4" "$col5"
done < "$csv_file"
((processed_count++))
echo "Successfully processed $csv_file"
done
echo "CSV processing complete. Processed $processed_count files"
Log Analysis with Break
#!/bin/bash
# Analyze log files for critical events and break on first finding
log_directories=("/var/log" "/opt/app/logs" "/home/user/logs")
critical_patterns=("SEGMENTATION FAULT" "OUT OF MEMORY" "DATABASE CONNECTION FAILED")
found_critical=false
for log_dir in "${log_directories[@]}"; do
if [ ! -d "$log_dir" ]; then
continue
fi
echo "Scanning directory: $log_dir"
for pattern in "${critical_patterns[@]}"; do
echo " Searching for: $pattern"
if grep -r -l "$pattern" "$log_dir" 2>/dev/null; then
echo "CRITICAL: Found '$pattern' in logs!"
echo "Directory: $log_dir"
echo "Recent occurrences:"
grep -r "$pattern" "$log_dir" 2>/dev/null | tail -5
found_critical=true
break 3 # Exit all loops
fi
done
done
if [ "$found_critical" = true ]; then
echo "Critical issues detected - immediate attention required!"
exit 1
else
echo "No critical issues found in logs"
exit 0
fi
Advanced Programming Patterns
State Machine with Break
#!/bin/bash
# State machine implementation using break
states=("INIT" "CONNECTING" "AUTHENTICATING" "PROCESSING" "COMPLETED" "ERROR")
current_state=0
# State machine loop
while true; do
case ${states[$current_state]} in
"INIT")
echo "State: INIT - Starting process"
if initialize_system; then
current_state=1 # Move to CONNECTING
else
current_state=5 # Move to ERROR
fi
;;
"CONNECTING")
echo "State: CONNECTING - Establishing connection"
if connect_to_service; then
current_state=2 # Move to AUTHENTICATING
else
echo "Connection failed"
break # Exit state machine
fi
;;
"AUTHENTICATING")
echo "State: AUTHENTICATING - Verifying credentials"
if authenticate; then
current_state=3 # Move to PROCESSING
else
echo "Authentication failed"
break # Exit state machine
fi
;;
"PROCESSING")
echo "State: PROCESSING - Handling data"
if process_data; then
current_state=4 # Move to COMPLETED
else
echo "Processing failed"
current_state=5 # Move to ERROR
fi
;;
"COMPLETED")
echo "State: COMPLETED - Process finished successfully"
break # Exit state machine
;;
"ERROR")
echo "State: ERROR - Process failed"
cleanup_on_error
break # Exit state machine
;;
esac
sleep 1 # Prevent tight loop
done
echo "State machine exited"
Retry Logic with Break
#!/bin/bash
# Advanced retry mechanism with break and exponential backoff
max_attempts=5
base_delay=1
max_delay=32
retry_operation() {
local operation="$1"
local attempt=1
local delay=$base_delay
echo "Starting operation: $operation"
while [ $attempt -le $max_attempts ]; do
echo "Attempt $attempt/$max_attempts..."
if eval "$operation"; then
echo "✓ Operation succeeded on attempt $attempt"
return 0
fi
echo "✗ Operation failed on attempt $attempt"
if [ $attempt -eq $max_attempts ]; then
echo "Maximum attempts reached, giving up"
break
fi
echo "Waiting ${delay}s before next attempt..."
sleep $delay
# Exponential backoff
delay=$((delay * 2))
if [ $delay -gt $max_delay ]; then
delay=$max_delay
fi
((attempt++))
done
return 1
}
# Usage examples
operations=(
"ping -c 1 google.com"
"curl -s --max-time 5 http://example.com"
"wget --timeout=5 http://test.org"
)
for op in "${operations[@]}"; do
echo "Testing: $op"
if retry_operation "$op"; then
echo "Success: $op"
else
echo "Failed: $op - skipping to next operation"
break # Skip to next operation in outer loop
fi
echo "---"
done
Integration with Other Commands
Combining Break with Conditional Logic
#!/bin/bash
# Complex conditional logic with break
validate_and_process() {
local files=("$@")
local validation_passed=true
for file in "${files[@]}"; do
echo "Validating $file..."
# File existence check
if [ ! -f "$file" ]; then
echo "Error: File $file does not exist"
validation_passed=false
break
fi
# File size check
size=$(stat -c%s "$file" 2>/dev/null || stat -f%z "$file" 2>/dev/null)
if [ $size -eq 0 ]; then
echo "Warning: File $file is empty"
continue # Continue with next file
fi
# File type check
if ! file "$file" | grep -q "text"; then
echo "Error: File $file is not a text file"
validation_passed=false
break
fi
echo "✓ $file passed validation"
done
if [ "$validation_passed" = true ]; then
echo "All files validated successfully"
for file in "${files[@]}"; do
echo "Processing $file..."
process_file "$file"
done
else
echo "Validation failed, no files processed"
return 1
fi
}
# Example usage
validate_and_process "file1.txt" "file2.txt" "file3.txt"
Break with Pipeline Processing
#!/bin/bash
# Pipeline processing with early termination
process_pipeline() {
local input_source="$1"
local max_processed=100
local processed_count=0
echo "Processing data from: $input_source"
# Process with break condition
while IFS= read -r line; do
((processed_count++))
# Process each line
echo "Processing line $processed_count: $line"
# Check for termination condition
if [[ "$line" == *"TERMINATE"* ]]; then
echo "Found termination signal, stopping processing"
break
fi
# Check maximum processed limit
if [ $processed_count -ge $max_processed ]; then
echo "Reached maximum processed limit ($max_processed)"
break
fi
# Actual processing
process_data_line "$line"
done < "$input_source"
echo "Pipeline processing complete. Processed $processed_count lines"
}
# Example usage
echo -e "line1\nline2\nTERMINATE\nline4\nline5" > test_data.txt
process_pipeline "test_data.txt"
Troubleshooting
Common Issues and Solutions
Break Not Working in Pipes
# Problem: Break doesn't work in pipelines
cat file.txt | while read line; do
if [[ "$line" == *"STOP"* ]]; then
break # This won't work as expected
fi
echo "$line"
done
# Solution: Use process substitution or file redirection
while read line; do
if [[ "$line" == *"STOP"* ]]; then
break # This works correctly
fi
echo "$line"
done < file.txt
# Alternative with process substitution
while read line; do
if [[ "$line" == *"STOP"* ]]; then
break
fi
echo "$line"
done < <(cat file.txt)
Break Levels Confusion
# Problem: Incorrect break level usage
for i in {1..3}; do
for j in {1..3}; do
for k in {1..3}; do
if [ $i -eq 2 ] && [ $j -eq 2 ] && [ $k -eq 2 ]; then
break 2 # Exits two levels (j and k loops)
# To exit all three loops, use: break 3
fi
echo "$i $j $k"
done
done
done
# Solution: Use clear break levels and comments
for outer in {1..2}; do # Level 1
echo "Outer loop: $outer"
for middle in {1..3}; do # Level 2
echo " Middle loop: $middle"
for inner in {1..3}; do # Level 3
echo " Inner loop: $inner"
if [ $middle -eq 2 ] && [ $inner -eq 2 ]; then
echo " Breaking to outer loop (break 2)"
break 2 # Exit middle and inner loops
fi
done
done
done
Break in Functions
# Problem: Break behavior in functions
function_with_break() {
for i in {1..5}; do
echo "Function loop: $i"
if [ $i -eq 3 ]; then
break # Breaks only the loop inside the function
fi
done
echo "Function completed"
}
# Solution: Use return to exit function early
function_with_return() {
for i in {1..5}; do
echo "Function loop: $i"
if [ $i -eq 3 ]; then
echo "Returning from function"
return 0 # Exit the function completely
fi
done
echo "This line won't be reached"
}
# Usage
echo "Testing function with break:"
function_with_break
echo -e "\nTesting function with return:"
function_with_return
echo "Function returned"
Related Commands
continue- Skip to next iteration of loopexit- Exit the shell or scriptreturn- Return from a shell functionfor- Shell loop constructwhile- Shell while loopuntil- Shell until loopcase- Conditional statementif- Conditional statement
Best Practices
- Use descriptive break conditions - Make it clear why a loop is being terminated
- Add logging before break - Record the reason for breaking for debugging purposes
- Use appropriate break levels - Specify the correct number of loops to exit
- Clean up resources - Ensure proper cleanup before breaking from loops
- Combine with error handling - Use break as part of comprehensive error handling
- Document complex break logic - Add comments explaining multi-level breaks
- Test break conditions - Verify break triggers under expected conditions
- Avoid excessive breaking - Use break judiciously to maintain code readability
- Consider alternatives - Sometimes returning from functions is cleaner than breaking
- Handle cleanup properly - Ensure file handles, locks, and resources are released
Performance Tips
- Early break efficiency - Breaking early saves unnecessary iterations and CPU cycles
- Minimal break conditions - Keep break condition checks simple and fast
- Break levels overhead - Higher break levels have minimal performance impact
- Loop optimization - Place break conditions at strategic points in loops
- Avoid complex expressions - Keep break condition evaluation lightweight
- Use break for large datasets - Prevent processing entire datasets when not needed
- Combine with continue - Use continue to skip iterations, break to exit loops
- Profile break usage - Monitor performance impact of break statements in critical paths
The break command is a fundamental control flow tool in shell scripting that provides efficient loop termination capabilities. Its ability to exit from nested loops makes it essential for implementing complex algorithms, error handling, and conditional processing in shell scripts.