How to Pass all Arguments in Bash Scripting

Last updated: March 17, 2023 | Linuxopsys

Bash arguments are one of the ways users provide inputs to the executing scripts. Using bash arguments, we create reusable scripts avoiding redundant code.

In this guide, we learn various approaches to passing all arguments in bash scripting.

Bash Pass all Arguments

Bash arguments are specified through the command-line after the script name. In the script to get the actual argument that was passed we use the dollar ($) sign, the syntax is $n, where n is an integer between 0 and 9. $0 is reserved for the script name, to get all bash arguments, we use either $@ or $*.

The $@ variable

In bash scripting, $@ represents the position of arguments, starting from one. For instance, when calling our arguments.sh script, we passed 4 and 7. Therefore, $@ will be equal to 4 7.

$@ is used to get all arguments individually quoted as “$1”, “$2”, ”$3”… The following bash script gets all arguments using $@ syntax.

#!/bin/bash
# script name: arguments.sh


# this is the script name
echo "getting the script name."
ARG0=$0
echo "\$0 is $ARG0"
ARG1=$1
ARG2=$2
let SUM=$ARG1+$ARG2
echo "showing the sum"
echo "$ARG1 + $ARG2 = $SUM"


echo
echo "getting all arguments using \$@"
echo "$@"
Pass all arguments using $@ variable

The output shows two arguments 4 and 7 that were passed via the script. In our script, we assume the arguments are numbers and we calculate the sum. In our example, the sum of 4 and 7 is 11 as shown, and $@ is 4 7.

The $* variable

When we want to store all bash arguments as a single string, we use $*. For instance, in our arguments.sh script above, $* will be equal to “4 7”.

$* gets all arguments as one string, that is, “$1 $2 $3…”. The separator is defined using the first character in $IFS (internal file separator). For instance, if IFS=”-=,#”, the separator will be “-”.

To check the IFS characters defined in your operating system, run the following command:

check the IFS characters

In our operating system, the first item, the separator, is an empty space (“ “) as shown in the above screenshot. We can change this by setting IFS to what we desire. 

In our sample script below, we change the IFS to “-” and the output is concatenated by a “-”.

#!/bin/bash
# script name: all-arguments.sh


first_name=$1
last_name=$2
email=$3
profession=$4
address=$5


# print "$*"
echo "showing vars using \$*"
echo "value for \$IFS: $(set | grep ^IFS)"
IFS="-"
echo "$*"
pass all arguments using $*

In the above screenshot, we set the first item of IFS to an hyphen(“-”). The output is concatenated with an hyphen when we use $* to process the arguments.

The following script shows the difference between $* and $@. For $* we can set a field separator using IFS.

#!/bin/bash
# script name: different.sh


# setting the IFS operator
IFS="-"
echo "all arguments using \$@"
echo "$@"
echo "all arguments using \$*"
echo "$*"
difference between $@ and $*

The screenshot above shows the difference between the $* and $@.

Examples

1. Bash Pass all Arguments as String

In bash script, to pass all arguments as string we use $*. As discussed earlier, we can set the IFS depending on our specific use case. The following script shows an example of passing all arguments as a string.

#!/bin/bash
# script name: args-as-string.sh


# we use $* to get
echo "processing all args as string."
echo "$*"
pass all arguments as string

The output screenshot returns all arguments as a string using $*.

2. Read all Arguments using Loop

To read all bash arguments, we use loops. In this section, we are going to demonstrate reading all bash arguments using while and for loops.

$* with loop

The following scripts uses a for loop with “$*” to get all arguments as one string.

#!/bin/bash
# script name: all-args.sh


for val in "$*"; do
 echo "value: $val"
done
$* with loop

The above script using a for-loop outputs the result as a one string.

$@ with loop

Now, with the same script, we use a while loop to read all arguments. The same construct will apply for a for loop with “$@”. Let’s dig in:

The following script uses a while loop:

#!/bin/bash
# script name: all-args.sh


counter=1
while (( "$#" )); do
 echo "$1"
 shift
 ((counter++))
done

Here is the output of the above script:

$@ with loop

We will now use a for-loop to obtain the same result as above.

#!/bin/bash
# script name: all-args.sh


for el in "$@"; do
 echo "$el"
done

The output of the above script is the same as for the while loop. It is as follows:

$@ with for loop

The for loop gives the same output as the while loop with a counter and a shift operator. It prints each element one by one.

3. Using the shift command

The shift operator shifts the current positional parameters ‘c’ times towards the left and the current positional parameter is assigned the value of the parameter ‘c’ places ahead of it.

If ‘c’ is not specified, it is left shifted by 1.

Assuming there is a script accepting 10 arguments, a shift 4 will result in the following:

  • Older $1, $2 and $3 are discarded.
  • Older $4 becomes $1
  • Older $5 becomes $2 
  • Older $5 becomes $3  
  • Older $10 becomes $7 

Here’s the syntax:

shift c

Shift command takes just one non-negative optional argument ‘c’ which determines the number of positions the parameters should be left shifted. If c is passed as 0, no parameters are shifted. c has a default value of 1.

#!/bin/bash
echo "Current values of parameter 1 and 2: " $1 and $2 
shift
echo "After 1 shift: " $1 and $2
shift 3
echo "After 3 more shifts: " $1 and $2

Run the script as follows:

./shiftScript.sh 1 2 3 4 5 6 7 8 9
using shift command

In the above example, $1 holds the value 1 and $2 holds 2. A single shift results in $1 holding the value 2 and $2 having a value of 3. Another 3 shifts makes $1 and $2 have a value of 5 and 6 respectively.

4. Bash Pass all Arguments as Array

An array is a sequence of characters or strings. We use $@ to get an array of arguments passed in, then we process them using a loop. This is useful when we want to perform a repetitive task on the provided input.

To process arrays in bash scripts, we use the following syntax.

#!/bin/bash
# script name: arrays.sh


# array
ARGS=$@


for arg in $ARGS; do
 echo "$arg"
done

The output is as follows:

pass all arguments as array

We use a for loop to process the passed in arguments as an array.

5. Read all arguments after the nth position

We are going to use the concept of extracting a substring from the main string. The substring will be taken from the nth position till the length of the string.

Here’s the syntax:

${var:offset:length}

Here, 

  • The string is stored in the variable var
  • Offset is the position from where to start the string extraction.
  • Length is the number of characters to be extracted from the offset. 
#!/bin/bash
args=($@)			# Storing the command line arguments in a bash array
echo "arguments are" ${args[@]}

count=$(echo "$#")		 # Storing the number of command line arguments
count2=${#args[@]}		# Storing the length of the array
echo "count of arguments is" $count
echo "length of the array is also" $count2

ind3_1=${args[@]:3:$count}
ind3_2=${args[@]:3:$count2}
echo "Extracting from third index using count1: " $ind3_1
echo "Extracting from third index using count2: " $ind3_2

Run the script as follows:

./positionalScript.sh 1 2 3 4 5 6 7 8 9
argument reading after nth position

The first step is to gather all the command line arguments in a bash array ‘args’. After that, we are counting the length of this array or the number of command line arguments passed to the script. Once we have these two ready, we are able to extract the parameters from the nth position just like we extract substrings from strings in bash.

6. Bash All Arguments to use Arithmetic

The first argument is $0. Using $@ and $* gives us all arguments after the first. The arguments passed can be of any type, that is, integer or string. Therefore, as programmers, we must ensure to process and parse the arguments correctly.

For instance, to calculate the sum of three integers, we get arguments and calculate the sum. The following script illustrates this.

#!/bin/bash
# script name: three-sum.sh


# define the sum
for el in $@; do
 let SUM+=$el
done
echo "the sum of $@ is: $SUM"

The output is as follows:

reading all argument - arithmetic operation

The above screenshot processes arguments after the first argument, the script name. The arguments we get are 3, 4, and 7. The script calculates the sum.

Conclusion

In this guide, we have demonstrated various ways to pass all arguments in bash with examples.

Another convenient way to handle command-line arguments is by using getopts which allows the script to specify which options are valid and what arguments they take.

SHARE

Comments

Please add comments below to provide the author your ideas, appreciation and feedback.

Leave a Reply

Leave a Comment