How to use command-line arguments in shell script?

Using Command-Line Arguments in Shell Scripts

In shell scripting, command-line arguments are a powerful feature that allows you to pass data to your script when you run it. This data can be used to customize the script's behavior, make it more flexible, and automate various tasks.

Understanding Command-Line Arguments

When you run a shell script, you can provide additional information to the script by passing command-line arguments. These arguments are typically separated by spaces and can be accessed within the script using special variables.

The most commonly used variables for accessing command-line arguments are:

1. $0: This variable represents the name of the script itself.
2. $1, $2, $3, ..., $n: These variables represent the first, second, third, and subsequent command-line arguments, respectively.
3. $#: This variable represents the total number of command-line arguments passed to the script.
4. $@ and $*: These variables represent all the command-line arguments as a single string, with each argument separated by a space.

Using Command-Line Arguments

Here's an example of how you can use command-line arguments in a shell script:

#!/bin/bash

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

To run this script with command-line arguments, you would use the following command:

$ ./script.sh hello world 123

This would output:

Script name: ./script.sh
First argument: hello
Second argument: world
Number of arguments: 3
All arguments: hello world 123

You can use these command-line arguments to control the behavior of your script. For example, you could use the first argument to specify a file to process, the second argument to specify an output directory, and so on.

Validating and Handling Arguments

It's important to validate the command-line arguments to ensure that your script is used correctly. You can use various techniques, such as checking the number of arguments, checking the values of the arguments, and providing error messages or usage instructions.

Here's an example of how you can validate and handle command-line arguments:

#!/bin/bash

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

file="$1"
output_dir="$2"

if [ ! -f "$file" ]; then
    echo "Error: $file does not exist."
    exit 1
fi

if [ ! -d "$output_dir" ]; then
    echo "Error: $output_dir is not a directory."
    exit 1
fi

# Process the file and write the output to the specified directory
# ...

In this example, the script checks if the correct number of arguments (2) has been provided. If not, it prints a usage message and exits with an error code. It then checks if the file and output directory specified by the arguments exist and are valid. If any of these checks fail, the script prints an error message and exits with an error code.

Conclusion

Command-line arguments are a fundamental feature of shell scripting that allow you to make your scripts more flexible and powerful. By understanding how to access and use these arguments, you can create scripts that can be easily customized and integrated into various workflows.

Remember to always validate and handle the command-line arguments to ensure that your scripts are used correctly and provide meaningful error messages when necessary.