Bash Scripting

Definition of Bash scripting

 A bash script is a file containing a sequence of commands that are

executed by the bash program line by line. It allows you to perform a
series of actions, such as navigating to a specific directory, creating a
folder, and launching a process using the command line.
 By saving commands in a script, you can repeat the same sequence
of steps multiple times and execute them by running the script.
Advantages of Bash Scripting

 Bash scripting is a powerful and versatile tool for automating system

administration tasks, managing system resources, and performing
other routine tasks in Unix/Linux systems.
 Some advantages of shell scripting are:
 Automation: Shell scripts allow you to automate repetitive tasks and
processes, saving time and reducing the risk of errors that can occur
with manual execution.
 Portability: Shell scripts can be run on various platforms and
operating systems, including Unix, Linux, macOS, and even Windows
through the use of emulators or virtual machines.
 Flexibility: Shell scripts are highly customizable and can be easily
modified to suit specific requirements. They can also be combined
with other programming languages or utilities to create more
powerful scripts.
 Accessibility: Shell scripts are easy to write and don't require any
special tools or software. They can be edited using any text editor,
and most operating systems have a built-in shell interpreter.
 Integration: Shell scripts can be integrated with other tools and
applications, such as databases, web servers, and cloud services,
allowing for more complex automation and system management
tasks.
 Debugging: Shell scripts are easy to debug, and most shells have
built-in debugging and error-reporting tools that can help identify and
fix issues quickly.
 Overview of Bash Shell and Command
Line Interface

 The terms "shell" and "bash" are often used interchangeably. But
there is a subtle difference between the two.
 The term "shell" refers to a program that provides a command-line
interface for interacting with an operating system. Bash (Bourne-
Again SHell) is one of the most commonly used Unix/Linux shells and
is the default shell in many Linux distributions.
 Although Bash is a type of shell, there are other shells available as
well, such as Korn shell (ksh), C shell (csh), and Z shell (zsh). Each
shell has its own syntax and set of features, but they all share the
common purpose of providing a command-line interface for
interacting with the operating system.
 You can determine your shell type using the ps command:

ps
# output:

PID TTY TIME CMD

20506 pts/0 00:00:00 bash <--- the shell type
20931 pts/0 00:00:00 ps
In summary, while "shell" is a broad term that refers to any program that provides a
command-line interface,
"Bash" is a specific type of shell that is widely used in Unix/Linux systems.
How to Create and Execute Bash scripts

Script naming conventions

By naming convention, bash scripts end with .sh. However, bash scripts
can run perfectly fine without the sh extension.
Adding the Shebang
Bash scripts start with a shebang. Shebang is a combination of bash
# and bang ! followed by the bash shell path. This is the first line of the
script. Shebang tells the shell to execute it via bash shell. Shebang is
simply an absolute path to the bash interpreter.
Below is an example of the shebang statement.

#!/bin/bash
You can find your bash shell path (which may vary from the above) using
the command:
Creating your first bash script

Creating your first bash script

Our first script prompts the user to enter a path. In
return, its contents will be listed.

Create a file named run_all.sh using any editor of

your choice.
vim run_all.sh

Add the following commands in your file and

save it:
#!/bin/bash
echo "Today is " `date`

echo -e "\nenter the path to directory"

read the_path

echo -e "\n you path has the following files and folders: "
ls $the_path

Let's take a deeper look at the script line by

line. I am displaying the same script again,
but this time with line numbers.
1 #!/bin/bash
2 echo "Today is " `date`
3
4 echo -e "\nenter the path to directory"
5 read the_path
6
 Line #1: The shebang (#!/bin/bash) points
toward the bash shell path.
 Line #2: The echo command displays the current
date and time on the terminal. Note that
the date is in backticks.
 Line #4: We want the user to enter a valid path.
 Line #5: The read command reads the input and
stores it in the variable the_path.
 line #8: The ls command takes the variable with
the stored path and displays the current files and
folders.
 Executing the bash script
To make the script executable, assign execution rights to
your user using this command:
chmod u+x run_all.sh
chmod modifies the ownership of a file for the current
user :u.
+x adds the execution rights to the current user. This
means that the user who is the owner can now run the
script.
run_all.sh is the file we wish to run.
You can run the script using any of the mentioned
methods:
sh run_all.sh
bash run_all.sh
./run_all.sh
 Comments in bash scripting
Comments start with a # in bash scripting. This means that
any line that begins with a # is a comment and will be
ignored by the interpreter.
Comments are very helpful in documenting the code, and it
is a good practice to add them to help others understand the
code.

These are examples of comments:

# This is an example comment
# Both of these lines will be ignored by the interpreter
 Variables and data types in Bash
Variables let you store data. You can use variables
to read, access, and manipulate data throughout
your script.

There are no data types in Bash. In Bash, a variable

is capable of storing numeric values, individual
characters, or strings of characters.

In Bash, you can use and set the variable values in

the following ways:
 Assign the value directly:
country=Netherlands
2. Assign the value based on the output obtained from a program
or command, using command substitution. Note that $ is required
to access an existing variable's value.
same_country=$country
This assigns the value of country to the new
variable same_country.
To access the variable value, append $ to the variable name.
country=Netherlands
echo $country
# output
Netherlands
new_country=$country
echo $new_country
# output
Netherlands
Above, you can see an example of assigning and printing variable
 Variable naming conventions
In Bash scripting, the following are the variable naming conventions:
Variable name underscore (_).
Variable names can contain letters, numbers, and underscores (_).
Variable names are case-sensitive.
No spaces or special characters.
Use descriptive names that reflect the purpose of the variable.
Avoid such as if, then, else, fi, and so on as variable names.
Here are some examples of valid variable names in Bash:
Name, count, _varmyVar, MY_VAR
And here are some examples of invalid variable names:
# invalid variable names

2ndvar (variable name starts with a number)

my var (variable name contains a space)
my-var (variable name contains a hyphen)
 Input and output in Bash scripts
Gathering input:
In this section, we'll discuss some methods to provide input to
our scripts.
Reading the user input and storing it in a variable
We can read the user input using the read command.
#!/bin/bash
echo "What's your name?"
read entered_name
echo -e "\nWelcome to bash tutorial" $entered_name
 Command line arguments
 In a bash script or function, $1 denotes the initial
argument passed, $2 denotes the second argument
passed, and so forth.
 This script takes a name as a command-line argument
and prints a personalized greeting.
 #!/bin/bash
 echo "Hello, $1!“

 We have supplied golis as our argument to the

script.
 Displaying output
Here we'll discuss some methods to receive output
from the scripts.
Printing to the terminal:
echo "Hello, World!"
This prints the text "Hello, World!" to the terminal.

2. Writing to a file:
echo "This is some text." > output.txt
This writes the text "This is some text." to a file
named output.txt. Note that the > operator
overwrites a file if it already has some content.
3. Appending to a file:
echo "More text." >> output.txt
This appends the text "More text." to the end of the
file output.txt.
4. Redirecting output:
ls > files.txt
This lists the files in the current directory and writes
the output to a file named files.txt. You can
redirect output of any command to a file this way.
You'll learn about output redirection in detail in
section 8.5.
 Conditional statements (if/else)
Expressions that produce a boolean result, either true or false, are
called conditions. There are several ways to evaluate conditions,
including if, if-else, if-elif-else, and nested conditionals.
Syntax:
if [[ condition ]];
then
statement
elif [[ condition ]]; then
statement
else
do this by default
fi
 Syntax of bash conditional statements
We can use logical operators such as AND -a and OR -o to make
comparisons that have more significance.
if [ $a -gt 60 -a $b -lt 100 ]
This statement checks if both conditions are true: a is greater
than 60 AND b is less than 100.
Let's see an example of a Bash script that uses if, if-else, and if-elif-
else statements to determine if a user-inputted number is positive,
negative, or zero: