How to use command-line arguments in shell scripts?

Using Command-Line Arguments in Shell Scripts

In shell scripting, command-line arguments are a powerful way to make your scripts more flexible and dynamic. They allow you to pass information to your script when you run it, enabling you to customize its behavior and input data. This can be especially useful when you need to perform repetitive tasks with varying parameters.

Understanding Command-Line Arguments

When you run a shell script, you can pass one or more arguments to it. These arguments are accessible within the script as special variables, typically denoted as $1, $2, $3, and so on. The first argument is stored in $1, the second in $2, and so on. The special variable $0 represents the name of the script itself.

Here's an example of a simple shell script that demonstrates the use of command-line arguments:

#!/bin/bash

echo "Script name: $0"
echo "First argument: $1"
echo "Second argument: $2"
echo "Third argument: $3"

If you save this script as example.sh and run it with the following command:

$ ./example.sh hello world 123

The output will be:

Script name: ./example.sh
First argument: hello
Second argument: world
Third argument: 123

Handling Optional Arguments

Sometimes, you may want to make certain arguments optional, allowing your script to function even if they are not provided. You can achieve this by using conditional statements, such as if-else or case statements, to check if the arguments are present before using them.

Here's an example of a script that takes an optional name argument:

#!/bin/bash

if [ -z "$1" ]; then
    echo "No name provided. Using 'Guest' as the default."
    NAME="Guest"
else
    NAME="$1"
fi

echo "Hello, $NAME!"

If you run this script without any arguments, it will use the default "Guest" name. If you provide a name as an argument, it will use that instead.

$ ./example.sh
No name provided. Using 'Guest' as the default.
Hello, Guest!

$ ./example.sh Alice
Hello, Alice!

Validating Arguments

It's often a good practice to validate the arguments passed to your script to ensure they meet the expected criteria. This can help you catch and handle errors more gracefully, improving the overall user experience.

For example, you can check if the number of arguments is correct, if the arguments are within a certain range, or if they match a specific pattern. Here's an example that checks if the user provided two numeric arguments:

#!/bin/bash

if [ "$#" -ne 2 ]; then
    echo "Usage: $0 <number1> <number2>"
    exit 1
fi

if ! [[ "$1" =~ ^[0-9]+$ ]] || ! [[ "$2" =~ ^[0-9]+$ ]]; then
    echo "Error: Both arguments must be numbers."
    exit 1
fi

RESULT=$((RANDOM % ($2 - $1 + 1) + $1))
echo "Random number between $1 and $2: $RESULT"

In this script, we first check if the correct number of arguments (2) was provided. If not, we display a usage message and exit the script with a non-zero status code to indicate an error. Then, we use regular expressions to validate that both arguments are numeric. If either argument is not a number, we display an error message and exit the script.

Accessing All Arguments

Sometimes, you may need to access all the arguments passed to your script, not just the individual ones. You can use the special variable $@ to get a list of all the arguments, or $* to get a single string containing all the arguments.

Here's an example that demonstrates the difference between $@ and $*:

#!/bin/bash

echo "All arguments (using \$@):"
for arg in "$@"; do
    echo "$arg"
done

echo "All arguments (using \$*):"
echo "$*"

If you run this script with the following command:

$ ./example.sh one two three four

The output will be:

All arguments (using $@):
one
two
three
four
All arguments (using $*):
one two three four

The $@ variable treats each argument as a separate element, while $* combines all the arguments into a single string.

Conclusion

Command-line arguments are a fundamental feature of shell scripting that allow you to make your scripts more flexible and adaptable. By understanding how to access and validate these arguments, you can write more powerful and user-friendly shell scripts that can be tailored to different use cases and scenarios. Remember to always validate your arguments to ensure your scripts handle errors gracefully and provide a good user experience.