Linux command line parameters

How To Pass and Parse Linux Bash Script Arguments and Parameters

Parsing and Passing of Arguments into bash scripts/ shell scripts is quite similar to the way in which we pass arguments to the functions inside Bash scripts. We’ll see the actual process of passing on the arguments to a script and also look at the way to access those arguments inside the script.

Passing arguments before running

We can pass parameters just after the name of the script while running the bash interpreter command. You can pass parameters or arguments to the file. Just the command for running the script normally by adding the value of the parameters directly to the script. Every parameter is a space-separated value to pass to the shell script.

The above command will just run the script without passing the parameters.

Whereas the command below will pass the arguments to the script.

bash scriptname.sh parameter1 parameter2 parameter3 nth-parameter

Running bash script with passing parameters

The above screenshot displays the parameters passed to the script, how we’ll do that, which we’ll explain in the next section. But right now we can see we have passed in the parameters from outside of the script using bash environment variables. You can even use strings and other data types but beware of any whitespace. White space will make the variable a separate parameter. So, for strings especially, be careful to strictly surround them with quotation marks.

Detecting Command Line Arguments

Now, we’ll see how we access those parameters inside of the script. We’ll use the number of the parameters passed in the order i.e for the first parameters passed, we’ll parse(access) the parameter by using $1 as the variable. The first parameter is stored in the $1 variable. Furthermore, you can assign this variable to any other user-defined variable you like. For the nth parameter passed, you can use $n to access that particular parameter. Here, the variable name starts with 1 because the filename/ script name is the 0th parameter. If you have more than 9 parameters, make sure to use < >around the number as without the parenthesis, bash will only see $10 as $1 and exclude the 0, so use $ and so on instead of simply $10.

#!/bin/bash echo "1st parameter = $1 " echo "2nd Parameter = $2 "

The above script can access the parameters from the command line/ shell using the positional parameters, which are 1, 2, 3, and so on.

Accessing the arguments from the script.

As you can see, we have used <> to access the parameter variable numbers from 10 onwards. The script can be used for loops and while loops to iterate over the parameters, but we will discuss it in further sections.

Assign Provided Arguments To Bash Variable

We can also assign it to other custom variables to make the script more dynamic and mold it according to the needs. Though the above script when run will only print two parameters, surely you can access more parameters using the variable as the order of parameters in numbers. The script can access the positional variables from the command line and use them in the required places wherever needed within the script.

#!/bin/bash a=$1 b=$2 p=$(($a*$b)) echo "The product of $a and $b = $p"

Assign Provided Arguments To Bash Variable

The above script accesses the positional parameters i.e $1 and $2 passed into the script and stores the user-defined variables to access them later and modify them accordingly. We can also access more parameters using iterative methods as we’ll see in the upcoming sections.

We also have the ability to check for any NULL or empty parameters passed using the -z or -n flags. From this, we can verify whether the parameters were passed or not.

#!/bin/bash if [[ -z $1 ]]; then echo "No parameter passed." else echo "Parameter passed = $1" fi

Checking for positional parameters passed in or not.

With this script, we can detect whether any positional parameters were passed in or nothing was passed. The -z flag checks for any NULL or uninitialized variables in BASH. The -z flag returns true if the variable passed is NULL or uninitialized. Hence, we can make use of basic If-else statements to detect the parameters passed.

We can also use -n flag which returns true if no parameters are passed, so we have to make use of ! to reverse the condition.

#!/bin/bash if [[ ! -n $1 ]]; then echo "No parameter passed." else echo "Parameter passed = $1" fi

This script will also give the same output as well, but we are making use of -n flag instead of -z.

Reading Multiple Arguments with For or While loop

We can use “@” variable to access every parameter passed to the script via the command line. It is a special variable that holds the array of variables in BASH. In this case, we are using it alone, so it contains the array of positional parameters passed in. We can use it to iterate over the parameters passed using loops or while loop as well.

#!/bin/bash for i in $@ do echo -e "$i\n" done

Using loops and @ variable to access the parameters as array elements.

We used a range-based for loop to iterate over till there are elements in the @ array. We simply iterate over the array and print the element. We can simply assign it, modify the values, and make the required changes to the parameters and arguments to achieve the desired outcome from the script.

We can also print the arguments using the while loop and the environmental variables of BASH.

#!/bin/bash i=$(($#-1)) while [ $i -ge 0 ]; do echo $ i=$((i-1)) done

Using while loop to iterate over the passed parameters.

We are using the variable ‘#‘ as it holds the number of parameters passed in. We initialize the number of parameters and take away one as we are going to use an array to iterate over it. So, as usual, the array’s index starts from 0. As this array is initialized from the last element or parameter passed, we need to decrement the counter until 0 to print every parameter in the order it is passed. We simply use the BASH_ARGV array to access the parameters and print its value. Also, at every iteration, we decrease the value of i- the iterator or counter by one using the arithmetic double braces. From this, we simply print every parameter passed to the script using a while loop as shown from the output screenshot.

Reading With Parameter Names

Using getopts to parse arguments and parameters

We can use the getopts program/ command to parse the arguments passed to the script in the command line/ terminal by using loops and switch-case statements.

#!/bin/bash while getopts n:c: option do case "$" in n)nation=$;; c)code=$;; esac done echo "Nation : $nation" echo "code : $code"

Using getopts to parse arguments and parameters

Using getopts, we can assign the positional arguments/ parameters from the command line to the bash variables directly. This allows us to manage the parameters nicely and in a systematic way. In the above script, we have used two arguments to store the bash variables using the getopts syntax, while loops and switch-case statements.

Printing Values of All Arguments

We can print the arguments passed to the script by a simple powerful variable ‘@’ which stores all the parameters passed.

#!/bin/bash echo "The arguments passed in are : $@"

Printing Values of All Arguments

Accessing the number of Parameters passed

We can also use the variable ‘#’ to access the number of parameters passed from the command line. The # variable basically contains the number of parameters/ arguments which are passed into the script.

#!/bin/bash echo "The number of arguments passed in are : $#"

Accessing the number of Parameters passed

The following were the process and specification of passing and parsing the variables in the bash script. The logic of shifting and making modifications to the variables is in the hands of the user. This was just a demonstration of passing in and parsing down the arguments from the command line to the script to make them more dynamic.

Источник

How to Read Command Line Arguments in Shell Scripts?

While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.

Reading user input is one part of the equation. In today’s article, we’ll learn to read command-line arguments in shell scripts. Shell scripts are an essential tool for any Linux user. They play a major role in automating daily tasks and creating your own commands or macros. These shell scripts can receive input from the user in the form of arguments. When we pass arguments to a shell script, we can use them for local sequencing of the script. We can use these arguments to obtain outputs and even modify outputs just like variables in shell scripts.

What are Command-Line Arguments?

Command-line arguments are parameters that are passed to a script while executing them in the bash shell. They are also known as positional parameters in Linux. We use command-line arguments to denote the position in memory where the command and it’s associated parameters are stored. Understanding the command-line arguments is essential for people who are learning shell scripting. In this article, we will go over the concept of command-line arguments along with their use in a shell script.

How Shell Scripts Understand Command Line Arguments

Command-line arguments help make shell scripts interactive for the users. They help a script identify the data it needs to operate on. Hence, command-line arguments are an essential part of any practical shell scripting uses. The bash shell has special variables reserved to point to the arguments which we pass through a shell script. Bash saves these variables numerically ($1, $2, $3, … $n) Here, the first command-line argument in our shell script is $1, the second $2 and the third is $3. This goes on till the 9th argument. The variable $0 stores the name of the script or the command itself. We also have some special characters which are positional parameters, but their function is closely tied to our command-line arguments. The special character $# stores the total number of arguments. We also have $@ and $* as wildcard characters which are used to denote all the arguments. We use $$ to find the process ID of the current shell script, while $? can be used to print the exit code for our script.

Read Command-line Arguments in Shell Scripts

Now we have developed an understanding of the command-line arguments in Linux. Now it’s time to use this knowledge for practical application of the netstat command. For this tutorial, we will go over an example to learn how to use the command-line arguments in your shell script. First, we will create a shell script to demonstrate the working of all the reserved variables which we discussed in the previous section. Use nano or any preferred editor of your choice and copy the following. This is the shell script which we plan to use for this purpose.

#!/bin/sh echo "Script Name: $0" echo "First Parameter of the script is $1" echo "The second Parameter is $2" echo "The complete list of arguments is $@" echo "Total Number of Parameters: $#" echo "The process ID is $$" echo "Exit code for the script: $?" 

Once we are done, we will save the script as PositionalParameters.sh and exit our text editor. Now, we will open the command line on our system and run the shell script with the following arguments.

./PositionalParameters.sh learning command line arguments 

The script will run with our specified arguments and use positional parameters to generate an output. If you followed the step correctly, you should see the following screen. Our output shows the correct output by substituting the reserved variables with the appropriate argument when we called it. The process was run under the process ID 14974 and quit with the exit code 0.

Wrapping up

Being able to read command-line arguments in shell scripts is an essential skill as it allows you to create scripts that can take input from the user and generate output based on a logical pathway. With the help of command-line arguments, your scripts can vastly simplify the repetitive task which you may need to deal with on a daily basis, create your own commands while saving you both time and effort. We hope this article was able to help you understand how to read the command line arguments in a shell script. If you have any comments, queries or suggestions, feel free to reach out to us in the comments below.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases. Learn more about us

Источник