Shell scripting is a way to automate tasks in the Unix shell. It involves writing commands in a script file, which can then be executed by the shell to perform a series of tasks.

Here are a few basic concepts that you should understand when learning about shell scripting:

Shell: A shell is a command-line interpreter that allows you to interact with the operating system.

Use shebang lines: A shebang line is a special line at the beginning of a script that specifies the interpreter to use. For example, a shebang line of #!/bin/bash tells the system to use the Bash interpreter to run the script.

Script: A script is a text file that contains a series of commands that are executed by the shell. Scripts are usually written in a language that the shell can understand, such as Bash, but they can also include commands written in other languages, such as Python or Ruby.

Variables: Variables are named storage locations that hold data. You can use variables in a shell script to store and manipulate data, such as strings, numbers, and arrays.

Conditional statements: Conditional statements allow you to control the flow of your script based on certain conditions. For example, you can use an if statement to execute a certain block of code only if a certain condition is met.

Loops: Loops allow you to repeat a block of code multiple times. There are several types of loops available in shell scripting, including for loops, while loops, and until loops.

Exit status: Every command in a shell script returns an exit status code when it finishes execution. The exit status code is a number that indicates whether the command was successful or encountered an error. You can use the exit status code to control the flow of your script and handle errors.
Comments: Comments are lines in a script that are ignored by the shell. You can use comments to document your code and make it easier to understand. In Bash, comments are denoted by a # symbol.

Shell commands and interpretation

Bash (Bourne Again SHell) is a Unix-like shell that is widely used on Linux systems. It is a command-line interpreter that reads and executes commands from the user or from a script file.

When you enter a command in the Bash shell, the interpreter reads the command and checks to see if it is a built-in command. If it is a built-in command, the interpreter executes the command directly. If it is not a built-in command, the interpreter searches for the command in the directories listed in the PATH environment variable. If the command is found, the interpreter executes the command. If the command is not found, the interpreter displays an error message.

For example, if you enter the command ls, the interpreter will check to see if ls is a built-in command. If it is not, the interpreter will search for an executable file named ls in the directories listed in the PATH variable. If the ls executable is found, the interpreter will execute it. If the ls executable is not found, the interpreter will display an error message.

In addition to searching the directories listed in the PATH variable, the Bash interpreter also checks to see if the command is a shell script or an alias. If the command is a shell script, the interpreter will execute the script. If the command is an alias, the interpreter will execute the command or commands that the alias is set to.

Bash scripts are text files that contain a series of commands to be executed by the Bash interpreter. To run a Bash script, you can use the bash command followed by the name of the script file, like this:

Bash scripts are often used to automate tasks or perform multiple commands in a single operation. They can include variables, loops, conditional statements, and other programming constructs, and they can be used to perform a wide variety of tasks.

The PATH is an environment variable in the Linux operating system that specifies a list of directories that the shell searches when you enter a command.

The PATH variable is a colon-separated list of directories that the shell checks in order, from left to right, when you enter a command. For example, if the PATH variable is set to /usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin, the shell will search for the command in the following directories:

• /usr/local/bin
• /usr/bin
• /usr/local/sbin
• /usr/sbin

If the command is found in one of these directories, the shell will execute it. If the command is not found, the shell will display an error message.

You can use the echo command to print the value of the PATH variable:

You can also use the export command to set or modify the value of the PATH variable:

This will add the /new/directory directory to the end of the PATH variable.

Writing our first shell script

To write an executable shell file, you can create a text file that contains a series of shell commands, and then make the file executable by setting the appropriate permissions. Here is an example of how you can create an executable shell file:

1. Open a text editor and type the commands that you want to include in the script. For example:
   #!/bin/bash
echo "Hello, world!"
The first line is called a shebang line and specifies the interpreter to use to run the script. In this case, the script will be run using the Bash interpreter.
2. Save the file with a .sh extension, for example myscript.sh.
3. Open a terminal and navigate to the directory where you saved the script.
4. Make the script executable by using the chmod command:
   chmod +x myscript.sh
5. Run the script by typing its name:
   ./myscript.sh

This will execute the script and print “Hello, world!” on the screen.

Shebang line in shell scripts

A shebang line is a special line at the beginning of a script file that specifies the interpreter to use to run the script. It is denoted by the #! characters, followed by the path to the interpreter.

For example, the following shebang line specifies that the script should be run using the Bash interpreter:

The shebang line must be the first line of the script file, and it must be followed by a newline character.

The shebang line is used to tell the system which interpreter to use to run the script. When you run a script, the system checks the shebang line to determine which interpreter to use. If the shebang line is not present, or if it specifies an interpreter that is not available on the system, the script will not be executed.

Shebang lines are commonly used in shell scripts, but they can also be used in scripts written in other languages, such as Python or Ruby.

Variables in shell scripting

Shell scripts and positional variables

In a shell script, positional variables are variables that are set to the values of the command line arguments passed to the script when it is run. The positional variables are numbered, starting with $0 for the name of the script itself, and $1, $2, etc. for the individual arguments.

Here is an example of a simple shell script that prints the values of the positional variables:

To run this script, you can use the bash command followed by the name of the script file and the arguments you want to pass to the script, like this:

This will execute the script and print the following output:

You can use the positional variables in your script to access and manipulate the arguments passed to the script. For example, you can use them in arithmetic expressions or string manipulations.

To access all of the arguments passed to a shell script in Linux, you can use the $@ special variable. The $@ variable is an array that contains all of the arguments passed to the script, including the script name itself ($0).

Here is an example of a simple shell script that prints all of the arguments passed to the script:

To run this script, you can use the bash command followed by the name of the script file and the arguments you want to pass to the script, like this:

This will execute the script and print the following output:

set command to add positional parameters

In Bash, the set command is used to set or unset shell options and positional parameters, as well as to display the values of all shell variables.

Here are some examples of how set can be used:

shift command to remove positional parameters

In shell scripts, the shift command is used to shift the values of positional parameters (also known as arguments) to the left. When shift is run, the value of $2 becomes $1, the value of $3 becomes $2, and so on. The value of $1 is lost.

Here’s an example of how shift can be used in a Bash script:

You can specify a number as an argument to shift to shift the positional parameters multiple times at once. For example, shift 2 would shift the positional parameters twice, so that the value of $3 becomes $1, the value of $4 becomes $2, and so on.

Here is a list of some important environmental variables in Linux:

• HOME: The home directory of the current user.
• PATH: A list of directories where the system looks for executables.
• SHELL: The path to the current user’s default shell.
• USER: The name of the current user.
• HOSTNAME: The hostname of the system.
• PWD: The current working directory.
• LANG: The default system language.
• LC_ALL: The default language and locale settings for the system.
• EDITOR: The default text editor.
• MAIL: The path to the user’s mailbox.

These are just a few examples of the many environmental variables that are available in Linux. Environmental variables can be used to store information that is needed by programs or scripts, such as the system’s hostname, the user’s home directory, or the system’s path.

To use an environmental variable in a shell script, you can use the $ notation followed by the name of the variable. For example, to access the value of the HOME environmental variable, which specifies the home directory of the current user, you can use the following syntax:

You can also use environmental variables in commands or scripts. For example, to list the files in the home directory of the current user, you can use the ls command and the $HOME environmental variable like this: