The source code for this chapter can be downloaded from here:

https://github.com/PacktPublishing/Mastering-Linux-Shell-Scripting-Second-Edition/tree/master/Chapter02

So far, in this book we have been able to see that the echo command is very useful and is going to be used in many of our scripts, if not all of them. When running the echo command, the built-in command will be used unless we state the full path to the file. We can test this with the following command:

$ which echo

To gain help on the built-in command, we can use man bash and search for echo; however, the echo command is identical to the internal command, so we recommend that you use man echo in most cases in order to display the command options.

The basic use of echo that we have seen so far will produce a text output and a new line. This is often the desired response, so we don't need to be concerned that the next prompt will append to the end of the echoed text. The new line separates the script output from the next shell prompt. If we do not supply...

When used as part of a script that prompts for user input, the suppression of the line feed is exactly what we want. We will begin by copying the existing hello2.sh script to hello3.sh and build an interactive script. Initially, we will use echo as the prompt mechanism, but, as we gradually enhance the script, we will generate the prompt directly from the shell built-in read command:

$ cp $HOME/bin/hello2.sh $HOME/bin/hello3.sh
$ chmod +x $HOME/bin/hello3.sh

Edit the $HOME/bin/hello3.sh script so that it reads as follows:

#!/bin/bash
echo -n "Hello $(basename $0)! May I ask your name: "
read
echo "Hello $REPLY"
exit 0

As we execute the script, we will be greeted and prompted with whatever is typed. This is echoed using the $REPLY variable in the echo statement. As we have not yet supplied a variable name to the read built-in command, the...

We should always introduce commenting scripts early in the piece. A script comment is prefaced with a # symbol. Anything after the # symbol is a comment and is not evaluated by the script. The shebang, #!/bin/bash, is primarily a comment and, as such, is not evaluated by the shell. The shell running the script reads the whole shebang, so it knows which command interpreter to hand the script over to. A comment may be at the start of a line or partway into the line. Shell scripting does not have the notion of multi-line comments.

If you are not already familiar with comments, then please note that they are added to the script to describe who wrote the script, when it was written and last updated, and what the script does. They are the metadata of the script.

The following is an example of comments in scripts:

#!/bin/bash
# Welcome to bash scripting
# Author: Mokhtar...

We have seen how we can use the built-in read to populate a variable. So far, we have used echo to produce the prompt, but this can be passed to read itself using the -p option. The read command will surpass the additional linefeed, so we reduce both the line count and the complexity to some degree.

We can test this at the command line itself. Try typing the following command to see read in action:

$ read -p "Enter your name: " name

We use the read command with the -p option. The argument that follows the option is the text that appears in the prompt. Normally, we would make sure that there is a trailing space at the end of the text to ensure that we can clearly see what we type. The last argument supplied here is the variable we want to populate; we simply call it name. Variables are case-sensitive too. Even if we do not supply the...

We have not needed this functionality in the scripts we have used so far, but we may need to ask users to hit any key to continue. At the moment, we have set it up in such a way that the variable is not populated until we hit the Enter key. Users have to hit Enter to continue. If we use the -n option followed by an integer, we can specify the number of characters to accept before continuing; we will set 1 in this case. Take a look at the following code extract:

#!/bin/bash
read -p "May I ask your name: " name
echo "Hello $name"
read -n1 -p "Press any key to exit"
echo
exit 0

Now the script will pause after displaying the name until we press any key; we can literally press any key before continuing, as we accept just 1 key stroke, whereas earlier we were required to leave the default behavior in place, as we could...

Even though we have limited the input to a single character, we do get to see the text on the screen. In the same way, if we type the name, we get to see the entered text before we hit Enter. In this case, it is just untidy, but if we are entering sensitive data, such as a PIN or a password, we should hide the text. We can use the silent option, or -s, to achieve this. A simple edit in the script will set this in place:

#!/bin/bash
read -p "May I ask your name: " name
echo "Hello $name"
read -sn1 -p "Press any key to exit"
echo
exit 0

Now, when we use a key to continue, it will not be displayed on the screen. We can see the behavior of the script in the following screenshot:

So far, we have seen in the first chapter how to read parameters from the user. Also, you can pass options. So, what are options? And how are they different from parameters?

$ ./script1.sh -a

$ ./script1.sh -a -b -c

#!/bin/bash
echo $1
echo $2
echo $3

$ ./script1.sh -a -b 20 -c

As you can see, the variable $3=20, which is the passed...

You may use bash scripts from GitHub, and you may notice that there is a standard option scheme that is followed. It's not required, but it is preferable.

These are some of the commonly used options:

• -a: List all items
• -c: Get a count of all items
• -d: Output directory
• -e: Expand items
• -f: Specify a file
• -h: Show the help page
• -i: Ignore the character case
• -l: List a text
• -o: Send output to a file
• -q: Keep silent; don't ask the user
• -r: Process something recursively
• -s: Use stealth mode
• -v: Use verbose mode
• -x: Specify an executable
• -y: Accept without prompting me

Our scripts are still a little trivial, and we have not looked at conditional statements so we can test for correct input, but let's take a look at some simple scripts that we can build with some functionality.

Now that we have created some scripts, we may want to back these up to a different location. If we create a script to prompt us, we can choose the location and the type of files that we want to backup.

Consider the following script for your first practice. Create the script and name it $HOME/backup.sh:

#!/bin/bash
# Author: @theurbanpenguin
# Web: www.theurbapenguin.com
# Script to prompt to back up files and location
# The files will be search on from...

Feel proud that you now have your I can read badge for shell scripting. We have developed our scripts to be interactive and to prompt users for input during the script execution. These prompts can be used to simplify user operations on the command line. In this way, they do not need to remember the command-line options or have passwords that end up stored in the command-line history. When using passwords, we can simply store the value using the read -sp options.

Also, we saw how to pass options with and without values, and how to identify values correctly. We saw how to pass options and parameters at the same time, thanks to the double dash.

In the next chapter, we will take our time to look at the conditional statements in bash.

1. How many comments are in the following code?

#!/bin/bash
# Welcome to shell scripting
# Author: Mokhtar

2. If we have the following code:

#!/bin/bash
echo $1
echo $2
echo $3

And we run the script with these options:

$ ./script1.sh -a -b50 -c

What is the result of running this code?

3. Check the following code:

#!/bin/bash
shift
echo $#

If we run it with these options:

$ ./script1.sh Mokhtar -n -a 35 -p

1. 1. What is the result?
   2. What is the dropped parameter?

Please see the following for further reading relating to this chapter:

• http://tldp.org/LDP/Bash-Beginners-Guide/html/sect_08_02.html
• https://ss64.com/bash/read.html
• http://www.manpagez.com/man/1/getopt/
• https://ss64.com/bash/getopts.html