Bash theory

0. Index

1. Things that happen to most people
2. Structure of a script
3. Print on screen
4. Read user INPUT
5. Calculations in bash
6. Terms of use
7. Loops
8. Features
9. getops

1. Things that happen to most people

/ bin / bash or / bin / sh

One of the first things the machine does when executing our script is looking at which shell it should do it with. On most current linux systems / bin / sh is a link to / bin / bash, but this is not always the case, for example in distributions that use busybox they bring Sh and usually they also bring Bash, but if you use / bin / sh, it will not run with Bash. That is why I recommend always using / bin / bash.

Unicode vs. ASCII

Have you ever wondered why you can't use "¿" or "ñ" in your scripts? Or use accents? It can be quite annoying in interactive scripts. That is because the default encoding of Bash is ASCII, or what is the same, the English character set. To change it, we only have to tell our script that we want to use Unicode. For that you have to add a line just after the command interpreter:

# - * - ENCODING: UTF-8 - * -

Be careful, it is important that this line is at the beginning of the script.

Make the script executable

It's funny how many people run the scripts with «$ bashscript.sh" instead of "$ ./script.sh'After all, this is what we have defined a shell for.

To add execution permissions, you must execute:

sudo + x script.sh

BIN = "folder where we have the scripts" PATH = "$ BIN $ PATH"

2. Structure of a script

1. Head
2. Definition of global variables
3. Help
4. Features
5. Main body

The header is where we indicate which shell we want to use and the encoding. The advantage of the functions is to reuse code that is repeated by writing it only once and to make it easier to understand the script, for code that exceeds 100 lines it is very useful.

In order to use functions, they must be defined with before the main body of our script. And if we want to use variables at the global level of all our script, both in the main body and in the functions, we must define them at the beginning of everything, just after the header.

Lastly, it is good practice to write a helper function for when our script runs badly or with bad parameters. Obviously, in those cases we want to exit the script immediately, without reading the functions. For that we can use:

function help () {echo "" "Our well-formatted help text." "" exit if [[-z $ 1 || $ 1 == "-h" || $ 1 == "--help"]]; then help fi

If we add "exit" to the help function, we will exit the script every time we run help, for example after error messages, etc. We save a few lines of code.

The condition indicates display help on the screen and exit if the script is run without parameters or if -h / –help is specified. If you look that is the standard behavior of most linux programs.

3. Print on screen

There are 2 main commands for printing to screen in bash: «threw out" Y "printf«. They are both just as fast and both are part of bash. The main difference for a beginner is that echo adds a newline at the end, whereas «printf»Does not.

Echo is very good and is what most people use, however when reading the user's INPUT, or when you want to print variables taken from files by word processing, strange things can happen. They are usually easily solved, as easy as changing the double quotes to single or vice versa, or taking the variable references out of the quotes. «Echo»Does strange things also depending on how it was compiled, if we always use Ubuntu or always Fedora, it doesn't affect us, but if we change the distribution it does.

That is why I use «printf«, Which does not give me headaches and also behaves more like«printf»From C or the«print»Of Python, that is very important if you ever want to port your script to another programming language.

4. Read user INPUT

Everything we write after the name of our script and before hitting the ENTER key is automatically saved in special variables. These variables are of the type $ X where X is a number.

«$0»Indicates the name of our script and from«$1»To infinity everything that we have written later is variable. For example:

cat << EOF >> test.sh #! / bin / bash # - * - ENCODING: UTF-8 - * - printf "\ $ 0 = $ 0 \ n" printf "\ $ 1 = $ 1 \ n" printf "\ $ 2 = $ 2 \ n "EOF chmod + x script.sh ./script.sh my file.txt

We create a test script, make it executable, and run it with 2 parameters. We obtain the screen output of:

$ 0 = ./script.sh $ 1 = my $ 2 = file.txt

Using quotes we could have passed "my file.txt" to "$ 1".

We can also read the INPUT of a user with the "read" command, directly indicating the variable where we want to save the parameter. For example:

printf "What's your name? \ n" read NAME printf "Hello, $ NAME. \ n"

5. Calculations in Bash

For that we can use «expose«, As long as we don't need to do complex calculations. Two things should be noted, the first is that «expose»Only admits whole numbers, the second is that the division returns the whole result, to see the rest we can use«%«.

Usually we will want to assign the result of expr to a variable. We can do that in two ways:

VAR2 = `expr $ VAR1 / 10` VAR2 = $ (expr $ VAR1 / 100)

You can also skip «expose»Using double parentheses:

VAR2 = $ (($ VAR1 / 100))

6 Terms

It has already been written in a very extensive way about «if","else","elif»And conditions. You can read about that in:

• Programming in bash: part 1
• Bash: if, then, else conditions
• Check if a file or folder exists or not and more with an if loop
• Programming in bash: part 2

I just want to highlight the difference between the use of simple square brackets, «[]«, And double brackets,«[[]]«, For the conditions. With double brackets we can use additional conditions:

• «&&»For and
• «||»For or

To use "&&" Y "||»With simple square brackets, each part should be separated in separate square brackets. The example used for the part of the script that looks to see if help needs to be executed would be:

if [-z "$ 1"] || ["$ 1" == "-h"] || ["$ 1" == "--help"]]; then help fi

It also saves us from having to write variable names in quotes to prevent errors. For example:

if [$ 1 = 1]; then printf "The parameter is equal to 1."; fi if ["$ 1" = 1]; then printf "The parameter is equal to 1."; fi if [[$ 1 = 1]]; then printf "The parameter is equal to 1."; fi

If script.sh is run without any parameters, the first case would give an error:

bash: [: =: unary operator expected

What has not been talked about is «CASE​«, Used to simplify«if«. Let's start at the beginning, when we don't have any «if»All the code will be executed. If we add a condition «if»We will have two cases, one in which the code block that is inside the«if»And the other case where this block is not executed.

If we add a «else«We will also have two cases, but these two cases are different from the previous ones. Because now there will be two conditional code blocks, A and B, and a C block, which is the rest of the program. A or B will be executed, and C. In the previous case it was A and C or only C.

To avoid writing conditions «if / else" within "else»And to simplify the reading of the code, it was created«elif«. When we have many conditions that depend on the previous one, for example range of numbers or the type:

VAR1 = $ 1 if [[$ VAR1 = 1]]; then printf "1 \ n" elif [[$ VAR1 = 2]]; then printf "2 \ n" elif [[$ VAR1 = 3]]; then printf "3 \ n" else printf "none \ n" fi

In the case of the last «elif»Many conditions will be read. With case this process is streamlined:

VAR1 = $ 1 case $ VAR in 1) printf "1 \ n" ;; 2) printf "2 \ n" ;; 3 | 4) printf "3 or 4, it depends \ n" ;; *) printf "none \ n" ;; that C

A variable will be read, in this case VAR1, and it will be checked if it is equivalent to any of the cases, if not, the default case "*" will be executed. Double semicolons are equivalent to «break«, They tell«CASE​»That has to end.

7. Loops

Very few loops are known in any programming language. In Bash they are «while","until" Y "for«. It has already been written in the blog about these:

• Programming in bash: part 1
• Programming in Bash: part2

There are two types of loops «for«, Those that are of the type«$ for VAR in FOODS»And what are of type C«$ for ((I = 0; I <= 10; I ++))«. The second type of loops «for»Are very useful, it has 3 parts at the beginning of the loop:

• Declaration and initiation of variables (In this case an auxiliary variable "I = 0").
• Execution condition (until I is less than or equal to 10).
• Increase of the auxiliary variable

In my opinion it is the most powerful loop of all. An example, which prints all numbers from 0 to 10, inclusive:

#! / bin / bash for ((I = 0; I <= 10; I ++)); do printf "$ I \ n" done

8. Functions

There are some things that Bash doesn't allow us to do, right? At first glance, bash functions prevent you from doing 3 things: declaring local variables in functions, passing parameters to functions, and returning parameters. Everything has a solution.

Do nothing like:

#! / bin / bash VAR = 1 printc "$ VAR \ n" function hello () {VAR = 2 printf "$ VAR \ n"} hello printf "$ VAR \ n"

This prints to screen 1, 2 and 2.

To declare local variables, add «local»When declaring:

#! / bin / bash VAR = 1 printf "$ VAR1 \ n" function foo () {local VAR1 = 2 printf "$ VAR1 \ n"} printf "$ VAR1 \ n" foo printf "$ VAR1 \ n"

This prints 1, 1, 2, 1 on screen.

How do you pass parameters to a function?

#! / bin / bash # - * - ENCODING: UTF-8 - * - function hello () {printf "Hello $ 1 \ n"}

printf "What's your name? \ n"
readVAR1
hello $ VAR1

How are parameters returned?

#! / bin / bash # - * - ENCODING: UTF-8 - * - function hello () {printf "Hello holita"} printf "What's your name? \ n" read VAR1 VAR1 = $ (hello) # HERE IT IS printf "$ VAR1 $ VAR2 \ n"

As you can see, this has two drawbacks, you can only return one parameter, which can be a vector 😀, and if you want to return a parameter, you can no longer print on the screen from that function.

9. Getops

One of the last things you need to know about Bash to create complex scripts is «getops«. It is used to pass options to the script regardless of the order. The only downside is that it only affects short options:

#! / bin / bash # - * - ENCODING: UTF-8 - * - VARC = 0 function help () {printf "Help message \ n" exit} if [[-z $ 1]]; then help fi while getopts: ha: b: c OPT; do case $ OPT in h) help ;; :) help ;; a) VARA = $ OPTARG ;; b) VARB = $ OPTARG ;; c) VARC = 1 ;; \?) help ;; esac done # Main block of the script that # does things with VARA, VARB and VARC

«getopts»Reads the options one by one, so a loop is needed.

There are 2 types of options that can be passed using «tops«:

• Parameters called flags, in this case -c or -h. They are specified with the letter we want to use. They are like Boolean variables, «true»(Are) or«false" (They're not here).
• Parameters with associated arguments, -a anything, -b anything. They are specified with the letter that we want with a colon below. The argument is stored in OPTARG (this name is unchangeable).

What does this script do?

Displays the help message when no option is passed, when the "-h" parameter is passed, when an invalid parameter is passed (for example "-x", this is done by "\?") Or when a valid parameter with no argument (":"). In the rest of the cases it saves the presence of "-c" as a 1 in VARC, and the values ​​passed with "-a" and "-b" in VARA and VARB.