How to Use First Argument in Bash Script [5 Cases]

In Bash, $1 represents the first argument of a script. This means when users provide the first argument while executing a script, it is accessible within the script by the first positional parameter ($1). In this article, primarily I will show how to provide and access the first argument. Moreover, I will try to satiate users’ various other queries related to the first argument in Bash.

How to Provide the First Argument in Shell Script?

To provide the first argument in a shell script, simply pass it as a command line argument while executing the script. For instance, if you have a script named “myscript.sh” and want to provide “Linux” as the first argument, then execute the script as follows:

./myscript.sh Linux

How to Access the First Argument in Bash Script?

To access the first argument in Bash script, use the first positional parameter $1. Here is a simple example:

#!/bin/bash

# Print the first argument
echo "First argument: $1"

Executing the script with the argument “Linux” shows the argument after the text “First Argument: ”. Within the script, $1 successfully refers to the first argument of the script.

5 Cases of Handling First Argument in Bash Script

Bash users often need to check the existence of the first argument in a script. Moreover, it is required to modify or skip the first argument occasionally. Therefore, handling the first argument effectively is an essential skill. The following discussion will highlight a few cases for effectively managing the first argument.

1. How to Check the Existence of the First Argument in Bash

To check the existence of the first argument, compare whether the first argument ($1) is empty or not. Use an if statement with -z test operator for this purpose. Here’s an example:

#!/bin/bash

if [ -z "$1" ]; then
    echo "First argument doesn’t exist or it’s empty."
else
    echo "First argument exists and its value is: $1"
fi

When the empty string "" or no argument is provided to the script it shows that “First argument doesn’t exist or it’s empty”. However, when the argument “a” is parsed it displays that the first argument exists.

2. How to Pass a File as the First Input Argument in Bash

Provide the file’s path as the first argument when running the script to pass a file as an input argument in a Bash script. Consider a file arg1.txt that contains some data:

#Users
Kenny
Anita
Smith
Mohammad

Now, write the following script that uses a while loop to process each line of the arg1.txt file after receiving it as the first argument:

#!/bin/bash
file="$1"
arr1=()

# Skip the first line and read the rest of the file
while read arg; do
  arr1+=("$arg")
done < <(tail -n +2 "$file")
# Print the elements of arr1
echo "${arr1[@]}"

Once executed the script prints the users listed in the “arg1.txt” file in an array by taking the file as the first argument.

3. Iterate Over Input Arguments Except First One

To iterate over input arguments except the first one in a Bash script, use a loop starting from the second argument onwards. The “$@” variable holds all the command line arguments. Looping over “${@:2}” allows you to access each argument individually, starting from the second argument($2). Here is an example:

#!/bin/bash

for i in "${@:2}"
do
    echo "$i"
done

Once the script is executed it iterates over all the command line arguments except the first one. Therefore, among the three arguments 1, 4 and 5 the script prints the second and third arguments.

4. Change the First Argument in Bash Script

Use the set command to change the first argument in a Bash script. Rewriting the arguments after set – –, reset the command line arguments. The script below demonstrates how set built-in is used to modify the first command line argument:

#!/bin/bash

# Update the arguments as required
set -- "5" "${@:2}"

# Display the updated arguments
echo "Updated arguments: $@"

Running the script with arguments “Null”, 7 and 13 changes the first argument “Null” to 5.

5. How to Skip the First Argument in Bash Script

Sometimes users want to get rid of the first argument passed to a Bash script. To skip the first argument, use the shift command to shift all the positional parameters to the left by one. Here’s how you can do it:

#!/bin/bash

# Skip the first argument
shift

# Now $1 refers to the second argument
echo "Second argument: $1"

# Loop through all remaining arguments
echo "Remaining arguments: $@"

Here, the script is executed with arguments 4,5 and 6. Due to the use of shift, all the arguments are shifted to the left by one position. As a result, the second argument becomes accessible by the first positional parameter ($1). Therefore, $@ prints 5 and 6 effectively skipping the first argument(4) provided to the script.

Conclusion

In conclusion, handling the first argument in Bash script is quite easy once you are familiar with the idea of positional parameters. The first positional parameter ($1) is used to access the first argument passed to a script. Moreover, the set built-in and shift command allows users to change or skip the first argument of a Bash script. I hope this article has helped you manipulate the first argument of your script.

People Also Ask

How to check if the first argument is empty?

To check whether the first argument is empty or not use the operators such -n or -z with the test command in an if statement. if [ -n "$1" ] holds true if the length of the first argument is nonzero. On the other hand,  if [ -z "$1" ] is true if the length of the first argument is 0.

What is the difference between $1 and $@?

Though both $1 and $@ are used to represent command line arguments, they don’t refer to the same set of arguments. $1 is used to access the first positional parameter whereas $@ expands to all the command line arguments. One can say, “$@” is equivalent to “$1” “$2” “$3″…up to the last argument.

How to store the first argument in a variable in Bash script?

Assign $1 as the value of a variable to store the first argument in a variable within a Bash script. For instance:

#!/bin/bash

# Store the first argument in a variable
arg1=$1

Here, variable arg1 contains the value of the first argument provided to the script.

Why is $1 in a function not printing the script’s first argument?

$1 in a function can’t print a script’s first argument. Arguments provided to a script are accessible using positional parameters only within the main level of the script not in a function body written in the script. A function can take its own set of arguments independent of the parent script containing the function. So, a function written in a script can access arguments that are provided to the function while calling the function within the script.

Related Articles

• How to Check Number of Arguments in Bash? [3 Methods]
• How to Get Argument in Bash? [4 Methods]
• How to Pass Arguments to Bash Script? [5 Methods]
• How to Parse Optional Arguments in Bash Script [2 Ways]
• How to Pass Array as an Argument in Bash Function? [3 Ways]
• How to Set Default Argument in Bash [2 Methods]
• How to Use OPTARG in Bash [3 Practical Examples]
• How to Use “getopts” in Bash [Complete Guide]
• [Solved] “bash: Argument list too long” Error

---

<< Go Back to Argument in Bash Script | Bash Functions | Bash Scripting Tutorial