Programming in bash - part 3

For secure our concepts We will learn 2 very useful tools for programming that work perfectly in Bash. Learn to create features and define pipelines may seem complex at first, but then we will see the immense utility that they provide us.

Pipes

Specifically, and without taking too many turns, a pipeline is a method that allows directing the output of one process as the input of another, which allows a series of advantages, such as reducing lines of code, dispensing with storage variables for results and improving the efficiency of the script.

A pipe is generally recognized by having the symbol | that allows to concatenate expressions; Although it is used by default, there are other ways to create pipes.

Example: print recent kernel messages

#dmesg allows you to see recent kernel messages and loaded drivers #during system boot; tail prints the last parts of a file or #command

dmesg | tail

Although they can be complicated as much as we want, the basic structure of a pipeline allows the result of one command to be used as input to the next, which can provide input for a new command if we keep adding consecutive pipes.

Features

Functions are a set of statements that are grouped together so that they can be executed several times without having to rewrite them. It is equivalent to thinking that when we learn to cook a type of food we will write its recipe on a sheet, and every time we want to cook that food we consult the recipe instead of rewriting a new sheet with the same recipe.

Perhaps the most important thing about functions is the possibility of passing parameters, data that they will use to process them and generate an output. Its structure is as follows:

function function-name {

 processes,

}

Example: function that shows the services that work on the tcp protocol. We can also see how to apply more pipes.

# We define a function name, it can be the one we like.

function services_tcp {

#cat concatenates and displays the contents of the / etc / services folder, which is # that contains all the services with their associated ports.

#the first grep takes the list and removes the comments, with –v we invert the result

#the second grep shows only those related to tcp

 cat / etc / services | grep –v "^ #" | grep tcp

}

When we need to execute this function we just have to call it by its name:

tcp_services

In this case it works without parameters; In the event that it has them, we must add them so that the function works properly, otherwise the function will not work properly. Using return allows a function to return a value as a result of the process.

Example: function with input parameters that calculates the sum of 2 numbers.

#! / Bin / bash
function sum ()
{
 # with let we can execute the operation inside the quotes
 let "result = $ 1 + $ 2"

 #return allows to return the integer value. Once the return is executed, the value will be deposited inside the variable $?
 return $ result;
}
 
#The sum function is called and we pass 2 input parameters.

add 2 3

#prints the value of $? with echo evaluating the actual value of the variable in quotes
echo -e "Result = $?";

<<Go to the previous part