Parsing Parameters in Bash Scripts [5 Examples]

Parsing and passing arguments into bash or shell script is mostly similar to how we provide arguments to functions within Bash scripts. In this article, I will look through different examples of processes to parse parameters in bash scripts. So Let’s start.

Key Takeaways

• Understanding the concept of parsing parameters in bash script.
• Get familiar with parsing parameters without using the positional parameters.

Free Downloads

What is Parameters Parsing in Bash Script?

Parameter parsing in Bash script refers to the process of extracting and interpreting input values, known as parameters or arguments, provided to a script when it is executed. These parameters can be passed to the script either when running it from the command line or within the script itself. The script then uses these parsed parameters to perform specific actions or make decisions based on the provided input. Let’s look at the code given below. The objective is to do an arithmetic summation between two numbers.

#!/bin/bash

x=$1
y=$2
result=$((x + y))
echo "The sum of the two given numbers is: $result"

Here as the picture depicts, the intended numbers which are referred to as the bash arguments are passing by means of the command line. Those values are then linked with the code with positional parameters such as $1, $2, etc. So this is an example of parameters parsing in a bash script.

5 Practical Examples of Parsing Parameters in Bash Scripts

Bash scripts often require inputs or options from users, and parameter parsing is essential for retrieving these values and making decisions based on them. There are plenty of ways you can parse your arguments depending on the requirement of data you need to pass. Here I am going to discuss five different examples to illustrate the idea. Don’t forget to practice by yourself and make one or two codes on your own.

Example 01: Assigning Command Line Arguments With Bash Parameters

In Bash, you can access command–line arguments passed to a script or program using variables like $1, $2, and so on. These variables allow you to capture and manipulate input values provided when the script is executed. Follow the following bash script to understand the concept.

Steps to Follow >

❶ At first, launch an Ubuntu Terminal.

❷ Write the following command to open a file in Nano:

nano parsing_parameters.sh

❸ Copy the script mentioned below:

#!/bin/bash

echo "The 1st given Parameter = $1 "
echo "The 2nd given Parameter = $2 "

❹ Press CTRL+O and ENTER to save the file; CTRL+X to exit.

❺ Use the following command to make the file executable:

chmod u+x parsing_parameters.sh

❻ Run the script by the following command:

./parsing_parameters.sh 3 6

When I run this script with arguments 3 and 6, it displays the values of these parameters, making it a basic way to assign command-line arguments.

Example 02: Parsing Bash Parameters Without Using Positional Parameters

Instead of relying solely on positional parameters $1, $2, and so on, you can use for loop to handle the bash argument as many as you want. Here’s a brief example:

Script (parsing_parameters1.sh) >

#!/bin/bash

# Counter for parameter position
count=1

# Loop through all positional parameters
for arg in "$@"; do
    echo "The $count parameter is: $arg"
    ((count++))
done

Use the following code to run the script in your command line.

./parsing_parameters1.sh Hello 56 LinuxSimply World

Upon execution, the bash script successfully returns each argument’s value and states its positional number.

Example 03: Assign the Parsing Arguments to the Bash Variable

You can assign the parsed arguments to the bash variable and redirect it to the algorithm. Let’s say you want to take two positional arguments as your input data and do some arithmetic multiplication. See the code given below to understand the concept of it.

Script (assigning_value.sh) >

#!/bin/bash

num1=$1
num2=$2
product=$(($num1*$num2))
echo "The product of $num1 and $num2 is = $product"

Use the following code to run the bash script.

./assigning_value.sh 4 5

Upon execution, the code returns “The product of 4 and 5 is = 20” as the output of the given code.

Example 04: Parsing Short Command-Line Options With the “getopts” Command in Bash Script

You can use the getopts command in a Bash script to parse short command-line options. getopts is a built-in tool in Bash for this purpose. Here’s an example of how to use getopts to parse short options:

Script (short_command.sh) >

#!/bin/bash

# Initialize variables with default values
option_a=false
option_b=false

# Usage function
usage() {
  echo "Usage: $0 [-a] [-b]"
  echo "  -a: Enable option A"
  echo "  -b: Enable option B"
  exit 1
}

# Parse options using getopts
while getopts "ab" opt; do
  case $opt in
    a)
      option_a=true
      ;;
    b)
      option_b=true
      ;;
    \?)
      echo "Invalid option: -$OPTARG"
      usage
      ;;
  esac
done

# Shift to the next positional parameter (if any)
shift $((OPTIND-1))

# Main script logic
echo "Option A: $option_a"
echo "Option B: $option_b"

Use the following code to run the bash script.

./short_command.sh
./short_command.sh -a
./short_command.sh -ab

As the image depicts above, the script ./short_command.sh accepts command-line options -a and -b. When run without any options, both option_a and option_b are set to false by default. When invoked with the -a option, option_a is set to true, while option_b remains false. Similarly, when both -a and -b options are provided, both option_a and option_b are set to true.

Example 05: Parsing Long Command-Line Options With the “getopt” Command in Bash Script

To parse long command-line options (also known as flags or switches) in a Bash script, you can use the getopt command. Here’s an example of how to use getopt to parse long options:

Script (long_command.sh) >

#!/bin/bash

# Initialize variables with default values
option_a=false
option_b=false

# Usage function
usage() {
  echo "Usage: $0 [--option-a] [--option-b]"
  echo "  --option-a: Enable option A"
  echo "  --option-b: Enable option B"
  exit 1
}

# Parse options using getopt
TEMP=$(getopt -o '' --long option-a,option-b -- "$@")

if [ $? -ne 0 ]; then
  usage
fi

eval set -- "$TEMP"

# Loop through the options and arguments
while true; do
  case "$1" in
    --option-a)
      option_a=true
      shift
      ;;
    --option-b)
      option_b=true
      shift
      ;;
    --)
      shift
      break
      ;;
    *)
      echo "Invalid option: $1"
      usage
      ;;
  esac
done

# Main script logic
echo "Option A: $option_a"
echo "Option B: $option_b"

Use the following code to run the bash script.

./long_command.sh
./long_command.sh --option-a
./long_command.sh --option-a --option-b

The script ./long_command.sh is designed to accept long options –option-a and –option-b. When executed without any options, both option_a and option_b are set to false by default. If inserted with the –option-a flag, option_a is set to true, while option_b remains false. Similarly, when both –option-a and –option-b flags are provided, both option_a and option_b are set to true.

Conclusion

In conclusion, parsing parameters in Bash scripts is crucial for handling command-line inputs effectively. By using techniques like positional parameters, scripts can receive and process arguments, making them more interactive and versatile. In this article, I have provided 5 different examples to give you an understanding of the subject matter. However, If you have any questions or queries regarding the article, feel free to comment below. I am one click away from interacting with you. Thank You.

People Also Ask

Related Articles

• How to Pass All Parameters in Bash Scripts? [6 Cases]
• How to Use Positional Parameters in Bash Script? [2 Examples]
• 4 Methods to Pass Named Parameters in a Bash Script
• What is $0 in Bash Script? [4 Practical Examples]
• Difference Between $$ Vs $ in Bash Scripting [With Examples]
• How to Use Alias with Parameters in Bash Scripting? [6 Examples]
• How to Use Bash Function with Parameters? [6 Examples]

<< Go Back to Parameters in Bash Scripting | Bash Scripting Tutorial

LINUX
FUNDAMENTALS A Complete Guide for Beginners Enroll Course Now

Enroll Course Now