Bash scripting tutorial for beginners

Tutorials
Bash scripting tutorial for beginners
5 (100%) 1 vote

In this article we will learn about different syntax in bash shell scripting. It is designed as descriptive so that it will be easy to understand.


ADVERTISEMENT

Whitespace and Linebreaks

bash shell scripts are very sensitive to whitespace and linebreaks. Because the “keywords” of this programming language are actually commands evaluated by the shell, you need to separate arguments with whitespace. Likewise, a linebreak in the middle of a command will mislead the shell into thinking the command is incomplete. Follow the conventions we present here and you should be fine.

Variables

$ MYVAR=6
$ echo $MYVAR
6

All values held in variables are strings, but if they are numeric the shell will treat them as numbers when appropriate.

$ NUMBER="10"
$ expr $NUMBER + 5
15

When you refer to a variable’s value in a shell script, it’s a good idea to surround it with double quotes to prevent certain runtime errors. An undefined variable, or a variable with spaces in its value, will evaluate to something unexpected if not surrounded by quotes, causing your script to malfunction.

$ FILENAME="My Document" Space in the name
$ ls $FILENAME Try to list it
ls: My: No such file or directory --- Oops! ls saw 2 arguments
ls: Document: No such file or directory
$ ls -l "$FILENAME" -------- List it properly
My Document ---------------- ls saw only 1 argument

If a variable name is evaluated adjacent to another string, surround it with curly braces to prevent unexpected behavior:

$ HAT="fedora"
$ echo "The plural of $HAT is $HATs"
The plural of fedora is ---------------------- Oops! No variable “HATs”
$ echo "The plural of $HAT is ${HAT}s"
The plural of fedora is fedoras ---------- What we wanted

Input and Output

Script output is provided by the echo and printf commands, which we described in “Screen Output” :

$ echo "Hello world"
Hello world
$ printf "I am %d years old\n" `expr 20 + 20`
I am 40 years old

Input is provided by the read command, which reads one line from standard input and stores it in a variable:

$ read name
Sandy Smith <ENTER>
$ echo "I read the name $name"
I read the name Sandy Smith

Booleans and Return Codes

Before we can describe conditionals and loops, we need the concept of a Boolean (true/false) test. To the shell, the value 0 means true or success, and anything else means false or failure.

Additionally, every Linux command returns an integer value, called a return code or exit status, to the shell when the command exits. You can see this value in the special variable $?:

$ cat myfile
My name is Sandy Smith and
I really like Fedora Linux
$ grep Smith myfile
My name is Sandy Smith and --------------- A match was found...
$ echo $?
0 -----------------------------------------...so return code is “success”
$ grep aardvark myfile
$ echo $? ------------------------------------No match was found...
1 ---------------------------------------------...so return code is “failure”

test and “[”

The test command (built into the shell) will evaluate simple Boolean expressions involving numbers and strings, setting its exit status to 0 (true) or 1 (false):

$ test 10 -lt 5 -------------------------Is 10 less than 5?
$ echo $?
1 ----------------------------------------No, it isn't
$ test -n "hello" -------------------------Does the string “hello” have nonzero length?
$ echo $?
0 ------------------------------------------Yes, it does

A list of common test arguments are found in Table 12, for checking properties of integers, strings, and files.
test has an unusual alias, “[” (left square bracket), as a shorthand for use with conditionals and loops. If you use this shorthand, you must supply a final argument of “]” (right square bracket) to signify the end of the test. The following tests are identical to those before:

$ [ 10 -lt 5 ]
$ echo $?
1
$ [ -n "hello" ]
$ echo $?
0

Remember that “[” is a command like any other, so it is followed by individual arguments separated by whitespace. So if you mistakenly forget some whitespace:

$ [ 5 -lt 4] ----------------------------------No space between 4 and ]
bash: [: missing ']'

then test thinks the final argument is the string “4]” and complains that the final bracket is missing.

-------------------------------------------
File tests
-------------------------------------------
-d name File name is a directory
-f name File name is a regular file
-L name File name is a symbolic link
-r name File name exists and is readable
-w name File name exists and is writable
-x name File name exists and is executable
-s name File name exists and its size is nonzero
f1 -nt f2 File f1 is newer than file f2
f1 -ot f2 File f1 is older than file f2
-------------------------------------------
String tests
---------------------------------------------
s1 = s2 String s1 equals string s2
s1 != s2 String s1 does not equal string s2
-z s1 String s1 has zero length
-n s1 String s1 has nonzero length
-----------------------------------------------
Numeric tests
-----------------------------------------------
a -eq b Integers a and b are equal
a -ne b Integers a and b are not equal
a -gt b Integer a is greater than integer b
a -ge b Integer a is greater than or equal to integer b
a -lt b Integer a is less than integer b
a -le b Integer a is less than or equal to integer b
----------------------------------------------------------
Combining and negating tests
-----------------------------------------------------------
t1 -a t1 And: Both tests t1 and t2 are true
t1 -o t2 Or: Either test t1 or t2 is true
! your_test Negate the test, i.e., your_test is false
\( your_test \) Parentheses are used for grouping, as in algebra

true and false
————————
bash has built-in commands true and false, which simply set their exit status to 0 and 1, respectively.

$ true
$ echo $?
0
$ false
$ echo $?
1

These will be useful when we discuss conditionals and loops.

Conditionals

————————-
The if statement chooses between alternatives, each of which may have a complex test. The simplest form is the if-then statement:

if command ------------------------------------------- If exit status of command is 0
then
body
fi
For example:
if [ `whoami` = "root" ]
then
echo "You are the superuser"
fi

Next is the if-then-else statement:

if command
then
body1
else
body2
fi
For example:
if [ `whoami` = "root" ]
then
echo "You are the superuser"
else
echo "You are an ordinary dude"
fi

 

Finally, we have the form if-then-elif-else, which may have as many tests as you like:

if command1
then
body1
elif command2
then
body2
elif ...
...
else
bodyN
fi
For example:
-------------
if [ `whoami` = "root" ]
then
echo "You are the superuser"
elif [ "$USER" = "root" ]
then
echo "You might be the superuser"
elif [ "$bribe" -gt 10000 ]
then
echo "You can pay to be the superuser"
else
echo "You are still an ordinary dude"
fi

The case statement evaluates a single value and branches to an appropriate piece of code:

echo 'What would you like to do?'
read answer
case "$answer" in
eat)
echo "OK, have a hamburger"
;;
sleep)
echo "Good night then"
;;
*)
echo "I'm not sure what you want to do"
echo "I guess I'll see you tomorrow"
;;
esac

The general form is:

case string in
expr1)
body1
;;
expr2)
body2
;;
...
exprN)
bodyN
;;
*)
bodyelse
;;
esac

where string is any value, usually a variable value like $myvar, and expr1 through exprN are patterns (run the command info bash reserved case for details), with the final * like a final “else.” Each set of commands must be terminated by ;; (as shown):

case $letter in
X)
echo "$letter is an X"
;;
[aeiou])
echo "$letter is a vowel"
;;
[0-9])
echo "$letter is a digit, silly"
;;
*)
echo "I cannot handle that"
;;
esac

Loops
———————————-

The while loop repeats a set of commands as long as a condition is true.

while command ----------------------------------------------- While the exit status of command is 0
do
body
done
For example, if this is the script myscript:
i=0
while [ $i -lt 3 ]
do
echo "$i"
i=`expr $i + 1`
done
$ ./myscript
0
1
2

The until loop repeats until a condition becomes true:

until command ------------------------------------------ While the exit status of command is nonzero
do
body
done
For example:
i=0
until [ $i -ge 3 ]
do
echo "$i"
i=`expr $i + 1`
done
$ ./myscript
0
1
2

The for loop iterates over values from a list:

for variable in list
do
body
done
For example:
for name in Tom Jack Harry
do
echo "$name is my friend"
done
$ ./myscript
Tom is my friend
Jack is my friend
Harry is my friend

The for loop is particularly handy for processing lists of files, for example, all files of a certain type in the current directory:

for file in *.doc
do
echo "$file is a stinky Microsoft Word file"
done

For an infinite loop, use while with the condition true, or until with the condition false:

while true
do
echo "forever"
done
until false
do
echo "forever again"
done

Presumably you would use break or exit to terminate these loops based on some condition.

Break and Continue

—————————————————————-
The break command jumps out of the nearest enclosing loop. Consider this simple script called myscript:

for name in Tom Jack Harry
do
echo $name
echo "again"
done
echo "all done"
$ ./myscript
Tom
again
Jack
again
Harry
again
all done

Now with a break:

for name in Tom Jack Harry
do
echo $name
if [ "$name" = "Jack" ]
then
break
fi
echo "again"
done
echo "all done"
$ ./myscript
Tom
again
Jack ------------------------------- The break occurs
all done

The continue command forces a loop to jump to its next iteration.

for name in Tom Jack Harry
do
echo $name
if [ "$name" = "Jack" ]
then
continue
fi
echo "again"
done
echo "all done"
$ ./myscript
Tom
again
Jack ---------------------------------- The continue occurs
Harry
again
all done

break and continue also accept a numeric argument (break N,continue N) to control multiple layers of loops (e.g., jump out of N layers of loops), but this kind of scripting leads to spaghetti code and we don’t recommend it.

Creating and Running Shell Scripts

———————————————————————-

To create a shell script, simply put bash commands into a file as you would type them. To run the script, you have three choices:

Prepend #!/bin/bash and make the file executable This is the most common way to run scripts. Add the line:

#!/bin/bash

to the very top of the script file. It must be the first line of the file, left-justified. Then make the file executable:

$ chmod +x myscript

Optionally, move it into a directory in your search path. Then run it like any other command:

$ myscript

If the script is in your current directory, but the current directory “.” is not in your search path, you’ll need to prepend “./” so the shell finds the script:

$ ./myscript

The current directory is generally not in your search path for security reasons.

Pass to bash

bash will interpret its argument as the name of a script and run it.

$ bash myscript

Run in current shell with “.”

The preceding methods run your script as an independent entity that has no effect on your current shell.shell (setting variables, changing directory, and so on), it can be run in the current shell with the “.” command:

$ . myscript

* Technically, it runs in a separate shell (a subshell or child shell) that inherits the attributes of the original shell, but cannot alter them in the original shell.

 

Command-Line Arguments
————————————————————–

Shell scripts can accept command-line arguments and options just like other Linux commands. (In fact, some common Linux commands are scripts.) Within your shell script, you can refer to these arguments as $1, $2, $3, and so on.

$ cat myscript
#!/bin/bash
echo "My name is $1 and I come from $2"
$ ./myscript Johnson Wisconsin
My name is Johnson and I come from Wisconsin
$ ./myscript Bob
My name is Bob and I come from
Your script can test the number of arguments it received with $#:
if [ $# -lt 2 ]
then
echo "$0 error: you must supply two arguments"
else
echo "My name is $1 and I come from $2"
fi

The special value $0 contains the name of the script, and is handy for usage and error messages:

$ ./myscript Bob
./myscript error: you must supply two arguments

To iterate over all command-line arguments, use a for loop with the special variable $@, which holds all arguments:

for arg in $@
do
echo "I found the argument $arg"
done

Exiting with a Return Code
————————————————————-

The exit command terminates your script and passes a given return code to the shell. By tradition, scripts should return 0 for success and 1 (or other nonzero value) on failure. If your script doesn’t call exit, the return code is automatically 0.

if [ $# -lt 2 ]
then
echo "Error: you must supply two arguments"
exit 1
else
echo "My name is $1 and I come from $2"
fi
exit 0
$ ./myscript Bob
./myscript error: you must supply two arguments
$ echo $?
1

In case of any ©Copyright or missing credits issue please check CopyRights page for faster resolutions.

Leave a Reply