Bash scripts are files containing a series of commands that are executed in sequence by the Bash shell. These scripts are used for everything from simple file management to complex system administration tasks. One of the most essential aspects of Bash scripting is the ability to pass arguments to your scripts. This feature allows scripts to be flexible and dynamic, capable of handling various inputs and performing different actions based on those inputs.

In this article, we will explore how to pass arguments to Bash scripts, the special variables involved, and some real-world examples to illustrate these concepts.

Basics of Passing Arguments to Bash Scripts

When you pass arguments to a Bash script, they are stored in positional parameters, which are special variables:

  • $0 is the name of the script.
  • $1, $2, and so on represent the arguments passed to the script.
  • $# gives the number of arguments passed.
  • $@ and $* represent all the arguments passed.

Let’s create an example script.

#!/bin/bash

echo "Script name: $0"
echo "First argument: $1"
echo "Second argument: $2"
echo "Total number of arguments: $#"
echo "All arguments: $@"

Now, we’ll run this script using the following arguments:

bash script.sh arg1 arg2

Output:

Script name: script.sh
First argument: arg1
Second argument: arg2
Total number of arguments: 2
All arguments: arg1 arg2

In this example, the script prints the script’s name, the first and second arguments, the total number of arguments, and all arguments as a list.

Handling Multiple Arguments

If your script needs to handle various arguments, you can loop through them. You can also use the shift command to move through the arguments.

Let’s create a script with the following content.

#!/bin/bash

echo "All arguments: $@"
echo "Looping through the arguments:"

while (( "$#" )); do
    echo "Argument: $1"
    shift
done

Now, we’ll run this script:

bash script.sh one two three four

Output:

All arguments: one two three four
Looping through the arguments:
Argument: one
Argument: two
Argument: three
Argument: four

In this example, the while loop continues until no more arguments ($# becomes zero). The shift command moves each argument out of $1, making the next one the first.

Combining Positional Arguments with Flags

Scripts often need to handle options or flags (like -f or –file). Here’s how you can do this using getopts, a built-in command for parsing options.

Here is an example script:

#!/bin/bash

while getopts ":f:o:" opt; do
  case $opt in
    f) echo "File option passed with value: $OPTARG" ;;
    o) echo "Output option passed with value: $OPTARG" ;;
    \?) echo "Invalid option: -$OPTARG" ;;
  esac
done

Run the above script:

bash script.sh -f input.txt -o output.txt

Output:

File option passed with value: input.txt
Output option passed with value: output.txt

In this example, getopts is used to parse the -f and -o options, and $OPTARG holds the value of each option. If an invalid option is passed, the script catches it and prints an error.

Error Handling: Validating Input

Good scripts should validate input to ensure they have the necessary arguments. This prevents errors or unexpected behavior.

Here is an example script:

#!/bin/bash

if [ $# -lt 2 ]; then
  echo "Error: You need to provide at least two arguments."
  exit 1
fi
echo "Arguments are valid. Proceeding..."

Run the above script:

bash script.sh one

Output:

Error: You need to provide at least two arguments.

Here, the script checks if fewer than two arguments were provided. If so, it prints an error message and exits.

Conclusion

Passing arguments to Bash scripts allows you to write flexible, reusable, and dynamic scripts. You can now create scripts that handle a variety of inputs, making them more powerful and useful in real-world applications. Try using Bash scripts to automate application deployment on VPS hosting from Atlantic.Net!