How to Use Nested “for” Loop in Bash [7 Examples]

Nesting means combination. When one loop is placed inside another, it is called a nested loop. A nested loop is a great tool for handling multidimensional data. With proper outer and inner loops, programmers can quickly iterate through each level of data and do any kind of data processing operation by developing commands inside the inner loops. I will go through every possible approach to using Bash nested for loop in this article. Let’s get started.

What is Nested “for” Loop in Bash?

A nested loop is an approach of placing one loop inside another. The body of the outer loop contains another complete loop. The for loop and the while loop can be nested within each other.

The general syntax of nested “for” loops in Bash is:

for outer_item in [list]
do
    for inner_item in [list]
    do
        [Commands]
    done
    [Commands]
done

For executing commands from the command line interface or terminal, the syntax of one line nested for loop is:

for item in [list]; do for item in [list]; do [Commands]; done; done

7 Practical Examples of Nested “for” Loop in Bash

Nested for loop in Bash can iterate through datasets and do necessary data processing, look for a specific pattern inside multidimensional array elements, and check particular conditions on data. In this section, I have listed some examples related to these. Hope you will enjoy it.

1. Simple Nested “for” Loop in Bash

Bash script can generate a specific pattern on numbers. Two loops nested within one another can do this task. The outer loop controls the row, and the inner loop controls the repetition of numbers within each row.

Here is a bash script that prints each number from the outer loop three times in a row, then moves to a new row with a new value at the outer loop:

#!/bin/bash
#outer for loop to print a number 3 times
for (( i = 1; i <= 3; i++ ))
do
    #inner for loop
    for (( j = 1 ; j <= 3; j++ ))
    do
        echo -n "$i "
    done
    #new line
    echo
done

A simple nested for loop has printed a list of numbers.

2. Bash Nested “for” Loop in One Line

The nested loop can be written in a single line. It makes the code concise, reducing the line number. Here is a bash script to print letters from the outer loop and numbers from the inner loop:

for i in a b c; do for j in 2 4 6; do echo "$i : $j"; done; done

3. Nested “for” Loop in Bash to Print Specific Pattern

The nested for loop can generate a specific pattern made of asterisks (*). The nested loops control the number of spaces and asterisks printed on each line to develop a particular pattern.

Here is a bash script to generate an isosceles triangle:

#!/bin/bash
for p in 1 2 3 4 5 6 7 8 9 10
do
    for q in $(seq  -10 -$p)
    do
        echo -n  ' '
    done
    for r in $(seq 1 $p)
    do
        echo  -n  "* "
    done
    echo
done

The image shows that the nested loop has printed a specific pattern.

4. Nested “for” Loop to Automate Data Tasks

Proper naming of the files makes the system clean and efficient. Nested for loop enables users to rename files within multiple subdirectories of a specified directory, which automates a long task one by one. Here, a bash script is developed that will iterate over each subdirectory inside a specified directory and then rename the file in a predefined format:

#!/bin/bash
directory="/home/susmit/backup"
for subdirectory in "$directory"/*; do
    if [ -d "$subdirectory" ]; then
        echo "Entering directory: $(basename "$subdirectory")"
        counter=1
        for file in "$subdirectory"/*; do
            if [ -f "$file" ]; then
                new_file="file_${counter}.txt"
                mv "$file" "$subdirectory/$new_file"
                echo "Renamed: $(basename "$file") to $new_file"
                ((counter++))
            fi
        done
    fi
done

5. Using Conditional Statements in Nested “for” Loop

Nested for loop helps to make decisions by processing big datasets. For this, one loop is placed inside another loop. Then, an if statement is placed inside the inner loop to make decisions and accomplish the task. Here, a bash script is developed to check whether an array element is odd or even.

#!/bin/bash
# Defining 2D array
declare -A arr=( [0,0]=1 [0,1]=2 [1,0]=3 [1,1]=4 )
#Looping through the rows and columns
for (( a=0; a<=1; a++ ))
do
    for (( b=0; b<=1; b++ ))
    do
        if (( ${arr[$a,$b]} % 2 == 0 ))
        then
            echo "Even number found at position [$a,$b]: ${arr[$a,$b]}"
        else
            echo "Odd number found at position [$a,$b]: ${arr[$a,$b]}"
        fi
    done
done

Nested for loop has done some data analysis.

6. Using Nested “for” Loop to Match Pattern

Nested for loop allows programmers to search for a specific pattern within a string inside a 2D associative array and comma-separated values. It will iterate through each array element and split each string at the specified Internal Field Separator (IFS). Then, it will search for a specific pattern within each word. Here is a script to split each array element at commas and search for ‘n’ within each word:

#!/bin/bash
# Defining 2D array
declare -A arr=( [0,0]="red,green" [0,1]="yellow,blue" [1,0]="violate,majenta" [1,1]="orange,purple" )
#Looping through the rows and columns of the array
for (( a=0; a<=1; a++ ))
do
    for (( b=0; b<=1; b++ ))
    do
        #Split the string at commas and loop through the resulting array
        IFS=',' read -ra words <<< "${arr[$a,$b]}"
        for word in "${words[@]}"
        do
            #searching for words having “n”
            if [[ $word == *n* ]]
            then
                echo " “n” found at the position [$a,$b]: $word"
            fi
        done
    done
done

The nested for loop has done a pattern matching.

7. Nested “for” Loop in Bash to Create Chessboard

The chessboard possesses two boxes of alternating colours in eight-by-eight dimensions. The nested for loop in Bash helps programmers to create this type of chessboard easily. Nested for loop allows iteration over each box position, and the American National Standards Institute (ANSI) code serves the purpose of setting two alternating colors.

To create a chessboard copy this bash script:

#!/bin/bash
#Outer for loop
for (( a = 1; a <= 8; a++ ))
do
    #Inner for loop
    for (( b = 1 ; b <= 8; b++ ))
    do
        sum=$(( $a + $b))
        temp=$(( $sum % 2))
        #setting colors of the chessboard using odd and even number logic
        if [ $temp -eq 0 ];
        then
            echo -e -n "\033[47m  "
        else
            echo -e -n "\033[40m  "
        fi
    done
    #printing a new line
    echo " "
done

The image shows the creation of a chessboard using nested for loop.

Debugging Nested “for” Loops: Common Errors and Solutions

Error in nested loops is very common as it contains many delicate code expressions and variables. This problem is on a bigger scale when working with large datasets. In this section, some traditional errors of nested for loop are listed, along with a few hacks to overcome these:

1. Infinite Loops: The infinite loop is the situation when a loop never terminates. It happens if the loop condition is not defined accurately or the loop variables are not incremented or decremented properly. To solve this error, make sure that the loop conditions are defined accurately and that the loop variables are incremented or appropriately decremented in each iteration.
2. Incorrect Loop Order: The incorrect loop order means keeping the loop in the wrong order, resulting in inaccurate or unexpected output. Improper nesting of the inner loop inside the outer loop or inaccurate definition of loop conditions causes this error. To overcome this problem, properly nest your loops and define your loop conditions.
3. Memory Issue: Large datasets contain a lot of information and data to process, which might cause memory issues that exceed system resource limits. To solve this problem, split the large dataset into smaller modules to reduce memory usage.
4. Performance Issues: It is one of the common issues when working with large datasets or complex computing tasks. To overcome this issue, find out the bottleneck by profiling, then optimize the performance of your nested loops or incorporate parallel processing.

Advanced Techniques for Nested Loops in Bash Scripts

Nested for loop in Bash scripting enables programmers to automate complex tasks that require a lot of execution time without using the loop. Incorporating advanced techniques would help programmers fine-tune the scripts’ performance and efficiency. Here are some advanced techniques for using nested loops in Bash scripts:

1. Continue and Break Statement: The continue and the break statements regulate the flow of a script. The continue statement skips the current iteration of the loop and jumps to the next iteration without executing the commands after the continue statement inside the loop. This helps to skip a certain iteration when a certain condition is met.
   On the other hand, the break statement terminates the loop and jumps to the next portion after the loop without executing any command after the break statement. This helps to terminate the loop when a certain condition is met.
2. Parallel Processing: To accelerate the speed of nested loops, you can use the & operator and the parallel command. These tools will help you to perform the loops in parallel.
3. Optimizing Loop Structure: Selecting a proper order of loops and efficient algorithms are essential to developing a nested loop. An optimized order can shorten the execution time by reducing the number of iterations and making the script more concise and readable.
4. Using Functions: Using functions helps create a capsule of a specific part of the script. This segmentizes a long bash script into different modules, making it easier for readers and hassle-free to maintain for developers.

Conclusion

The nested for loop in bash equips users to automate the multilevel task and saves time. The nested loop can be defined by following generalized or one-line syntax, offering versatility. This article will allow beginners and advanced users to learn about nested for loop in Bash and use it whenever necessary.

People Also Ask

What is the purpose of nested for loop?

The purpose of nested for loop is to iterate through multidimensional data. When using a nested for loop, the outer loop initializes the nested loop, and the inner loop does the specified operation on the data iterating through matrix and tabular data.

Can you nest for loops in Bash?

Yes, you can nest for loops in Bash. The nested for loop enables you to do repetitive tasks like printing permutations and combinations of numbers or processing multidimensional data by iterating within multiple levels.

How many loops can be taken in a nested loop?

The number of loops for defining a nested loop is any reasonable number based on your needs. However, system resources and code complexity might influence your practical limit.

What are the two types of nested loops?

The two types of nested loops are the inner loop and the outer loop. The inner loop or the outer loop can be for loop, while loop, or do while loop.

What kind of loop can be nested?

Any kind of loop can be nested with another kind of loop. This practice is very liberal; you can use any kind of loop, whether an inner loop or an outer loop.

Is there any danger in using nested loops?

Here, I have listed some limitations or dangers associated with using nested loops:

1. Complexity and Readability: Too much nesting might make reading code difficult. Limiting the depth of nesting is a solution to this problem.
2. Performance: Too much nesting increases the total number of iterations, which might increase the execution time. To overcome this issue, think about the effectiveness before nesting.
3. Infinite Loops: This happens if the loop conditions or logic is incorrect. Check the loop conditions, logic, and initialization to avoid this issue.

Related Articles

• 10 Common Bash “for” Loop Examples [Basic to Intermediate]
• How to Iterate Through List Using “for” Loop in Bash
• How to Use Bash “for” Loop with Variable [12 Examples]
• Bash Increment and Decrement Variable in “for” Loop
• How to Use Bash Parallel “for” Loop [7 Examples]
• How to Loop Through Array Using “for” Loop in Bash
• How to Use Bash “for” Loop with Range [5 Methods]
• How to Use Bash “for” Loop with “seq” Command [10 Examples]
• How to Use “for” Loop in Bash Files [9 Practical Examples]
• Usage of “for” Loop in Bash Directory [5 Examples]
• How to Use “for” Loop in One Line in Bash [7 Examples]
• How to Create Infinite Loop in Bash [7 Cases]
• How to Use Bash Continue with “for” Loop [9 Examples]

---

<< Go Back to For Loop in Bash | Loops in Bash | Bash Scripting Tutorial