How to Iterate Over Arguments in a Bash Script

Bash scripting allows us to handle multiple arguments in a flexible way, and iterating over arguments is a common task when writing command-line scripts. This is especially useful when handling filenames or values passed to a script. Here’s a practical guide on various methods to loop over arguments, ensuring compatibility with arguments containing spaces or special characters.

Using "$@" to Handle All Arguments

To iterate over each argument passed to the script while preserving spaces and special characters, use "$@". This is the preferred method, as it treats each argument as a separate element, even if it contains spaces.

#!/bin/bash

for var in "$@"
do
    echo "$var"
done

Running this script with arguments like ./script.sh 1 2 "3 4" outputs:

1
2
3 4

Using "$@" ensures each argument is handled independently, even if it contains spaces. This is generally better than $*, which combines all arguments into a single string.

Using shift to Process Arguments Sequentially

shift allows you to treat arguments like a queue, removing each processed argument from the list. This approach is ideal when you want to process each argument in order, without going back.

#!/bin/bash

while [[ $# -gt 0 ]]
do
    echo "$1"
    shift
done

With shift, each call removes the first argument ($1) from the list, making $2 the new $1, and so on, until there are no arguments left.

Accessing Arguments as Array Elements

If you want to access arguments by index without iterating, you can store them in an array. This is particularly helpful if you need to reference specific arguments multiple times.

#!/bin/bash

argc=$#
argv=("$@")

for (( i=0; i<argc; i++ ))
do
    echo "${argv[i]}"
done

Using argv=("$@") preserves each argument as an array element, including arguments with spaces. For example, calling the script with ./script.sh arg1 "arg with space" arg3 correctly interprets each argument.

Iterating Using a Loop with $#

Another approach to access each argument is to loop based on the total number of arguments ($#). This way, you can use parameter expansion to access each argument by position.

#!/bin/bash

for (( i=1; i<=$#; i++ ))
do
    echo "${!i}"
done

This approach leverages ${!i} syntax, which dynamically references each positional parameter. Calling ./script.sh a b "c d" will output each argument separately:

a
b
c d

Summary of Argument Iteration Techniques

Method	Description	Suitable For
"$@"	Iterates over all arguments individually	General use, especially with spaces
shift	Removes each argument after processing	Sequential processing
Array (argv[@])	Access arguments as array elements	Accessing specific arguments by index
${!i} Loop	Loops based on argument count	Flexibility without shift or arrays

Using "$@" is typically the best practice for simple argument iteration, especially when dealing with filenames or parameters that may contain spaces. Choose the method that best fits your script’s requirements, and you’ll be ready to handle any command-line input with ease.