The Linux shell

A shell or command interpreter is a program interface that allows a user to write instructions to the operating system. In the Linux environment there are three major families of shells: sh, csh and ksh. The bash shell (Bourne Again Shell) belongs to the family sh

One of the main features of a command interpreter is that it can be programmed using text files that contain commands that are to be interpreted in the execution of the same

These text files are called files commands or scripts (also scripts, shell scripts or scripts shell). Therefore, a file of commands is a text file executable that contains commands that can be interpreted by the shell

Features

The first line of the file indicates the type of shell that must be interpreted, in our case bash:

#!/bin/bash

Each line of the file contains a command that will be executed by the interpreter

If you want to run multiple commands on the same line must be separated by ‘;’

test $a == $b; echo $a

To continue a command in the next line it must end with '/'

echo 'I do not fit everything in this line\
continued on the next'

The ‘#’ character at the beginning of a line indicates that it is a comment and therefore the interpreter will not execute it

#is a comment

To display text or variables on the screen, use the echo command

Variables

Each shell has associated with some variables, that the user can use. There are two types of variables:

• Local Variables: Are not inherited by the child processes of the shell when doing a fork
• Environment Variables: Are inherited by the child process when a fork

All variables are preceded by ‘$’

Use of variables

To define a new variable or a value to a variable use the =operator

$variable=value

As we have mentioned before, to display on the screen the value of the variable use the echo command

echo $variable

To convert a local variable into an environment variable use the export command

export $variable

To delete a variable and its value from memory, use the command unset

unset $variable

To display all variables (local and environment), we will use the set command

set

To show only environment variables, use the command env

env

We can use the following environment variables pre-defined within the shell

Arguments

Like any program, a script can receive values through arguments or parameters, in the command line. The arguments received are stored in a series of variables that the script can use

Quotes

Simple ‘ ‘

String of characters that the shell takes literally

Reverse ` `

Must enclose a complete command (with its name and its arguments) produces a run in three phases:

1. Evaluation of variables
2. Substitution of the command for a string that contains the standard output of the command
3. Execution of the result

Dobles " "

Allow the evaluation of variables and command substitution

Commands flow control

Sentence if

if expression; Then
    command_list
elif expression1; Then
    command_list_1
...
elif expressionN; Then
    command_list_N
else
    command_list_else
fi

expression can be a comparison expression or a command. Its value will be the one that returns the expression or the execution of a command

To enter by the branch that follows then, expression must have returned a 0 (true) and to enter an elif branch or an else branch, expression must have returned a value other than 0 (false)

Expressions

If we want to compare two values we must use the test

test expression
test [expression]

test evaluates the expression. If this is true it returns code 0 and if this is false a code other than 0

The most common expressions are:

These expressions elementals can be combined using parenthesis and the following operators:

Case statement

case string in
pattern1)
        command_list_1
	;;
...
patternN)
        command_list_N
	;;
...
*)
        default_command_list
	;;
esac

Compares the string with the patterns, executing the list of commands corresponding to the first pattern with which it agrees, after which the execution of the case statement ends. A pattern can include any of the metacharacters of the shell

* is the default pattern and runs when none of the others

For statement

for variable in value_list
do
	command_list
done

The list of commands is executed as many times as items are in the list. Before each iteration the next value of the list is assigned to variable, starting the first iteration by the first value

It is very useful if we want to go through all the arguments

for arg in $*
do
	command_list
done

Sentence while

while expression
do
	command_list
done

command_list runs as many times as true expression

Judgment until

until expression
do
	command_list
done

command_list is executed as many times as false expression

OR operator

command1 | | command2

command1 is executed; if it returns an error code other than 0 then the command2 is executed, and the code it returns is the code returned by the complete command; if command1 succeeds (code 0) then command2 is not executed and all expression succeeds

test -f fich1 | | echo 'fich1 does not exist' >&2

The previous example checks to see if the fich1 file exists. If it exists, nothing is done, otherwise a message is displayed by the standard error channel

AND operator

command1 && command2

command1 is executed; if it returns an error code equal to 0 then the command2

test -d dir1 && ls dir1

In the example checks to see if there is a directory called dir1. If it exists, the content is displayed, otherwise nothing is done

Note: there is an operator object command

Read command

read value_list

value_list are variables separated by a space

The execution of the read command reads from its standard input a line of text divided into words (i.e. strings separated by blanks or tabs)

Assigns the first word to the first variable, the second to the second variable, and so on until you complete the value_list

If not entered enough words, to the variables remaining to be assigned the null string

If in the line there are more words than variables, then it is assigned to the last variable a string consisting of all the words leftovers

Example of trace line to line of a file

while read line
do
	command_list
done < name_of_file

Exit command

All command returns a code to notify the end if its execution has been correct or if it has appeared an error. If the execution has been correct, it returns error code 0, and if there has been any problem it is returned as a code any positive number

The files command returned at the end of a code error; the exact error code returned by the last command in the file that is running. To modify this situation by default we have to use the exit command

exit n

Where the optional argument n will be an integer greater than or equal to 0. If you do not specify an argument is equivalent to exit 0

When running the exit command, it immediately terminates the execution of the file command and is returned as an error code the integer n