Bash For Loop on Linux

Bash For Loop on Linux

Bash scripting is a powerful tool for automating repetitive tasks and streamlining workflows on Linux systems. One of the most essential constructs in Bash scripting is the for loop, which allows you to iterate over a list of items and execute a set of commands for each item. Mastering the for loop is crucial for any Linux user or system administrator looking to enhance their productivity and efficiency.

In this comprehensive guide, we will dive deep into the world of Bash for loops, exploring their syntax, various use cases, and practical examples. Whether you’re a beginner or an experienced Linux user, this article will provide you with the knowledge and skills necessary to harness the full potential of loops in your Bash scripts. Let’s get started!

What is a Bash For Loop?

A Bash for loop is a programming construct that allows you to repeatedly execute a block of commands for a specified number of times or for each item in a list. It provides a concise and efficient way to automate tasks that involve iterating over a collection of items, such as files, directories, or command output.

The basic syntax of a Bash for loop is as follows:

for variable in list; do

Here’s a breakdown of the components:

  • variable: A variable name that will hold the current item from the list in each iteration.
  • list: A space-separated list of items to iterate over. This can be a static list, a range of numbers, or the output of a command.
  • commands: The block of commands to be executed for each item in the list.

The for loop starts by assigning the first item from the list to the variable. It then executes the commands inside the loop body. After each iteration, the loop moves to the next item in the list and repeats the process until all items have been processed.

Basic Syntax and Structure

Let’s take a closer look at the basic syntax and structure of a Bash for loop. Here’s an example that demonstrates how to loop through a static list of values:


for fruit in apple banana orange; do
    echo "I like $fruit!"

In this example, the for loop iterates over a list of three fruits: apple, banana, and orange. For each iteration, the current fruit is assigned to the variable fruit, and the echo command is executed, printing a message that includes the fruit name.

The output of this script would be:

I like apple!
I like banana!
I like orange!

As you can see, the loop body (the commands between do and done) is executed once for each item in the list, with the fruit variable holding the current item.

Types of Bash For Loops

For Loop with Static List

We’ve already seen an example of a for loop with a static list of values. This is the simplest form of a for loop, where you explicitly specify the items to iterate over. Here’s another example:


for color in red green blue; do
    echo "The color is $color"

This script will output:

The color is red
The color is green
The color is blue

For Loop with Range

Bash allows you to create a for loop that iterates over a range of numbers using the {start..end} notation. Here’s an example:


for i in {1..5}; do
    echo "Number: $i"

This script will output:

Number: 1
Number: 2
Number: 3
Number: 4
Number: 5

You can also specify an increment value by adding another .. followed by the increment. For example, {1..10..2} will generate the sequence 1, 3, 5, 7, 9.

C-style For Loop

Bash also supports a C-style for loop syntax, which is useful when you need more control over the loop variables. The syntax is as follows:

for ((initialization; condition; increment/decrement)); do

Here’s an example that prints the even numbers from 0 to 10:


for ((i=0; i<=10; i+=2)); do
    echo "Number: $i"

This script will output:

Number: 0
Number: 2
Number: 4
Number: 6
Number: 8
Number: 10

In this case, the loop variable i is initialized to 0, the loop continues as long as i is less than or equal to 10, and i is incremented by 2 in each iteration.

Advanced Techniques

Using Command Output as List

One of the powerful features of Bash for loops is the ability to iterate over the output of a command. This is achieved by using command substitution $(). Here’s an example that loops through the files in a directory:


for file in $(ls); do
    echo "Processing file: $file"
    # Additional commands to process each file

In this script, the ls command is executed, and its output (a list of files in the current directory) is used as the list for the for loop. Each file name is assigned to the file variable, and the loop body is executed for each file.

Nested For Loops

You can also nest for loops inside each other to iterate over multiple dimensions. Here’s an example that generates a multiplication table:


for ((i=1; i<=5; i++)); do
    for ((j=1; j<=5; j++)); do
        echo -n "$result "

This script uses two nested for loops to generate a 5×5 multiplication table. The outer loop iterates over the rows (1 to 5), while the inner loop iterates over the columns (1 to 5). The result of multiplying the current row and column values is stored in the result variable and printed.

Practical Examples

Looping through Files and Directories

One common use case for for loops is processing files and directories. Here’s an example that renames all .txt files in a directory to have a timestamp appended to their names:


for file in *.txt; do
    timestamp=$(date +%Y%m%d_%H%M%S)
    mv "$file" "${file%.txt}_$timestamp.txt"

This script loops through all files with the .txt extension in the current directory. For each file, it generates a timestamp using the date command and renames the file by appending the timestamp to its name.

Iterating over Arrays

Bash allows you to store multiple values in an array and iterate over them using a for loop. Here’s an example:


fruits=("apple" "banana" "orange")

for fruit in "${fruits[@]}"; do
    echo "I like $fruit!"

In this script, an array named fruits is defined with three elements. The for loop iterates over the array using the “${fruits[@]}” syntax, which expands to all the elements of the array. Each element is assigned to the fruit variable, and the loop body is executed for each fruit.

Processing Command Line Arguments

For loops can also be used to process command line arguments passed to a script. Here’s an example:


for arg in "$@"; do
    echo "Processing argument: $arg"
    # Additional commands to process each argument

In this script, “$@” represents all the command line arguments passed to the script. The for loop iterates over each argument, assigning it to the arg variable. The loop body can then process each argument as needed.


Bash for loops are a powerful tool for automating repetitive tasks and processing collections of items in Linux. By understanding the different types of for loops, their syntax, and common use cases, you can write more efficient and effective Bash scripts.

Remember to follow best practices, such as using descriptive variable names, quoting variable references, and incorporating conditional statements for error handling. Additionally, be mindful of performance considerations and use built-in Bash constructs whenever possible.

With the knowledge gained from this comprehensive guide, you are now equipped to tackle a wide range of tasks using Bash for loops. Practice using for loops in your scripts, experiment with different techniques, and continue exploring the vast possibilities of Bash scripting.


r00t is a seasoned Linux system administrator with a wealth of experience in the field. Known for his contributions to, r00t has authored numerous tutorials and guides, helping users navigate the complexities of Linux systems. His expertise spans across various Linux distributions, including Ubuntu, CentOS, and Debian. r00t's work is characterized by his ability to simplify complex concepts, making Linux more accessible to users of all skill levels. His dedication to the Linux community and his commitment to sharing knowledge makes him a respected figure in the field.
Back to top button