So far you’ve seen how to write Linux bash scripts that interact with data, variables, files, and how to control the flow of the bash script. Today we will continue our series about Linux bash scripting.
I recommend you to review the previous posts if you want to know what we are talking about.
Table of Contents
Today we will know how to retrieve input from the user and deal with that input, so our script becomes more interactive.
The common method of passing data to your shell script is to use command line parameters.
Command line parameters enable you to add data values to the command line when you execute the script.
$ ./myscript 10 20
This example passes two command line parameters (10 and 20) to the script. So how to read these parameters in our bash script?
Reading parameters
The bash shell assigns special variables for dealing with input parameters:
- $0 is the script’s name.
- $1 is the 1st parameter.
- $2 is the 2nd parameter.
The last parameter is $9 which is for the 9th parameter.
Here’s a simple example of how to use command line parameters in a shell script
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | #!/bin/bash # Script name echo $0 # 1st parameter echo $1 # 2nd parameter echo $2 # 3rd parameter echo $3 |
Check the results of the following command:
./myscript 5 10 15
Here is another example of how we can use two parameters and calculate the sum of them.
1 2 3 4 5 6 7 8 9 | #!/bin/bash total=$(( $1 + $2 )) echo The first parameter is $1. echo The second parameter is $2. echo The sum is $total. |
The parameters are not restricted to numbers, they could be strings like this:
1 2 3 | #!/bin/bash echo Hello $1, how do you do |
./myscript Adam
And the result is as expected.
What if our parameter contains a space and we want to pass it as one value? I guess you know the answer from the previous posts. The answer is to use quotations.
If your script requires over nine parameters, you need to use braces around the variable number, such as ${10}.
Check Parameters
If you don’t pass parameters and your code expecting it, you’ll get an error message from your script.
So always check your parameters using if statement to make sure that they exist.
1 2 3 4 5 6 7 8 9 10 11 12 13 | #!/bin/bash if [ -n "$1" ] then echo Hello $1. else echo "No parameters found. " fi |
Counting parameters
You can count how many parameters were entered on the command line. The bash shell gives us a special variable for this purpose.
The special $# variable contains the number of the passed command line parameters.
1 2 3 | #!/bin/bash echo There were $# parameters passed. |
./myscript 1 2 3 4 5
How awesome is Linux bash scripting? This variable also provides a geeky way of getting the last parameter on the command line without having to know how many parameters were passed. Look at this trick:
1 2 3 | #!/bin/bash echo The last parameter was ${!#} |
Grabbing all parameters
The $* and $@ variables give you all of the passed parameters. So you don’t have to grab them by $# variable and iterate over them, just one step.
The $* variable holds all the parameters supplied on the command line as a single word.
The $@ variable takes all the parameters as separate words within the same string, it enables you to iterate over them.
This code shows how to use them:
1 2 3 4 5 6 7 | #!/bin/bash echo "Using the \$* method: $*" echo "-----------" echo "Using the \$@ method: $@" |
The same result, but if you want to know the difference look at the following example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | #!/bin/bash total=1 for param in "$*" do echo "\$* Parameter #$total = $param" total=$(( $total + 1 )) done total=1 for param in "$@" do echo "\$@ Parameter #$total = $param" total=$(( $total + 1 )) done |
Check the result to see the difference:
The $* variable handled all the parameters as a single parameter, while the $@ variable handled each parameter separately. So you can use any one of these variables according to your needs.
Shift command
The shift command has some little risk in Linux bash scripting, it literally shifts the command line parameters in their relative positions.
The shift command moves every parameter variable one position to the left by default, so the value for the variable $3 is shifted to $2, the value for variable $2 is shifted to $1, and the value for variable $1 is dropped (keep in mind that the value for variable $0, the script name, remains unchanged).
This is another way to iterate over parameters:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | #!/bin/bash count=1 while [ -n "$1" ] do echo "#$count = $1" count=$(( $count + 1 )) shift done |
Here, the script performs a while loop, checking the length of the first parameter’s value. When The length of the first parameter is zero, the loop stops. After examining the first parameter, the shift command is utilized to shift all the parameters one position.
Careful when using shift command because when a parameter is shifted, its value is removed and cannot be recovered.
Bash scripting options
Options are single letters with a dash before it, they modify the behavior of a command.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | #!/bin/bash echo while [ -n "$1" ] do case "$1" in # Message for -a option -a) echo "Found -a option" ;; # Message for -b option -b) echo "Found -b option" ;; # Message for -c option -c) echo "Found -c option" ;; # In case you typed a different option other than a,b,c *) echo "Option $1 not recognized" ;; esac shift done |
$ ./myscript -a -b -c -d
The code check for one of the correct options. If you typed one of them, the suitable commands will run.
Separate Options From Parameters
Sometimes you need to use options and parameters on the same script. You have to separate them. By doing this, you are telling the bash where are the parameters and where are the options.
The double dash (–) is used to end the options list. After the shell sees the double dash, the remaining inputs are treated as parameters and not as options.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 | #!/bin/bash while [ -n "$1" ] do case "$1" in # Message for -a option -a) echo "Found -a option" ;; # Message for -b option -b) echo "Found -b option";; # Message for -c option -c) echo "Found -c option" ;; # The double dash which separates options from parameters --) shift # Exit the loop using break command break ;; *) echo "Option $1 not recognized";; esac shift done total=1 for param in $@ do echo "#$total: $param" total=$(( $total + 1 )) done |
$ ./myscript -a -b -c -- 5 10 15
As you can see from the result, all the parameters after the double dash treated as command line parameters.
Process Options With Values
When you dig deep onto Linux bash scripting, sometimes you need options with additional parameter values like this:
./myscript -a value1 -b -c value2
There should be a way to identify any additional parameter for the options and be able to process it.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 | #!/bin/bash while [ -n "$1" ] do case "$1" in -a) echo "Found -a option";; -b) param="$2" echo "Found -b option, with value $param" shift ;; -c) echo "Found -c option";; # The double dash for separating options from parameters --) shift break ;; *) echo "Option $1 not recognized";; esac shift done total=1 for param in "$@" do echo "#$total: $param" total=$(( $total + 1 )) done |
And if we run it with these options:
$ ./myscript -a -b test1 -d
From the results, you can see that we get the parameter for the -b option using the $2 variable.
Standardizing Options
When you start your Linux bash scripting, it’s completely up to you to choose which letter is suitable for your option.
However, there are some letters that have a standard meaning in the Linux world.
And here is the list of the common options:
-a Shows all objects.
-c Produces a count.
-d Specifies a directory.
-e Expands an object.
-f To specify a file.
-h To show help page.
-i To ignore character case.
-l To list a text.
-n To say no for a question.
-o To send output to a file or so.
-q Runs in quiet mode.
-r To process something recursively.
-s Runs in silent mode.
-v Produces verbose output.
-x Excludes an object.
-y To say yes without prompting the user.
If you work with Linux, many of these options may look familiar to you.
Using these letters as your options helps users to use your script without having to worry about manuals.
Getting User Input
Sometimes you need data from the user while the bash scripting is running.
The bash shell uses the read command for this purpose.
The read command reads input from standard input (the keyboard) or from a file descriptor. After that, the read command stores the data into a variable and here is an example:
1 2 3 4 5 6 7 | #!/bin/bash echo -n "Enter your name: " read name echo "Hello $name," |
Notice that the echo command that generates the prompt uses the -n option. This disables the newline character at the end of the string, this will allow you to enter data immediately after the string, instead of the next line.
You can specify multiple variables like this:
1 2 3 4 5 | #!/bin/bash read -p "Enter your name: " first last echo "Your data for $last, $first…" |
If you don’t specify any variable for the read command the read command stores all incoming inputs in the special environment variable REPLY.
1 2 3 4 5 | #!/bin/bash read -p "Enter your name: " echo Hello $REPLY,. |
If you don’t need to wait for user input, you can use the -t option to specify a time. The -t option is used to specify the number of seconds to wait for input.
1 2 3 4 5 6 7 8 9 10 11 12 13 | #!/bin/bash if read -t 5 -p "Enter your name: " name then echo "Hello $name, welcome to my script" else echo "Sorry, too slow! " fi |
If you do not enter data for five seconds the script will execute the else clause and print a sorry message.
Reading password
In Linux bash scripting, sometimes you don’t want the user input to be displayed on the screen, like entering a password.
The -s option hides the data entered in the read command.
The data is actually printed on the screen, but the read command makes the text color as the background color of the shell.
1 2 3 4 5 | #!/bin/bash read -s -p "Enter your password: " pass echo "Is your password really $pass? " |
Reading from a file
If you pass a file to the read command, the read command will read a single line from the file on each call.
Now, if you want to get all file data, you can get the content using the cat command, then send it to the read command using while loop like this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | #!/bin/bash count=1 # Get file content then pass to read command by iterating over lines using while command cat myfile | while read line do echo "Line $count: $line" count=$(( $count + 1 )) done echo "Finished" |
We just pass the file content to while loop and iterate over every line and print the line number and the content, and each time you increase the count by one.
I hope you find this post interesting. Keep coming back.
Thank you.
Pingback: Linux bash scripting the awesome part3 | Ace Infoway()
Pingback: Shell scripting the awesome guide part4 - Like Geeks()
Pingback: Shell Scripting The Awesome Guide Part4 – TechNow()
Pingback: Bash scripting the awesome guide part6 Bash functions - Like Geeks()