Curso de Linux 10/60 | Bash Script Avanzado I

Esta ya es nuestra décima clase en nuestro Curso de Linux, esta vez vamos a ver Bash Script avanzado lo vamos a ver en 2 etapas:

  1. Operadores.
  2. Arreglos o arrays.
  3. Funciones.
  4. La asignación de comandos.

la asignación del resultados de comandos a una variable y vamos a combinar eso con el comando awk para hacer filtrado de salidas al estándar ouput y utilizar esos datos para asignarlos a una variable. Entonces comencemos

OPERADORES NUMERICOS

  • -eq Igual que.
  • -ge Mayor o igual que.
  • -gt Mayor que.
  • -le Menor o igual que.
  • -lt Menor que.
  • -ne Distinto que.

Bueno vamos a comenzar por los operadores, los operadores que vamos a ver son los matemáticos, creamos un archivo if.sh le colocamos el encabezado y vamos a utilizar la estructura if porque es la que mejor nos puede ilustrar los operadores, vamos a pasarle parámetros, vamos a utilizar $1 y $2 para comparar, el primero que vamos a utilizar es el:

Igual que, que es -eq entonces colocamos echo que nos muestre si se cumple y le agregamos los permisos de ejecución , una ves le agregamos los permisos de ejecución pues hacemos la comparación si es igual coloca el mensaje, si no es igual pues no coloca el mensaje y el código será el siguiente.

EJEMPLO IGUAL QUE

#!/bin/bash
if [ $1 -eq $2 ];
then
echo “hola”
fi

EJEMPLO mayor o igual que

Entonces ahora vamos a modificar nuestro script para ver el operador mayor o igual que que es –ge comparamos si es igual nos da, si es mayor que nos da y si no es igual o mayor que no nos da ejemplo:

#!/bin/bash
if [ $1 -ge $2 ];
then
echo “hola”
fi

EJEMPLO mayor que

Ahora vamos con el mayor que modificamos la condición y ahora agregamos –gt asi que, si es mayor que nos da si es menor que no nos da y si es igual tampoco nos da.

#!/bin/bash
if [ $1 -gt $2 ];
then
echo “hola”
fi

EJEMPLO menor o igual que

Vamos a seguir con el menor o igual que, es -le entonces vemos si es igual nos da si es menor nos da pero si es mayor que no nos da.

#!/bin/bash
if [ $1 –le $2 ];
then
echo “hola”
fi

EJEMPLO menor que

Entonces seguimos con el ejemplo menor que es -lt y aquí vemos en los ejemplos que si es igual no nos da, si es mayor no nos da pero si es menor si nos da.

#!/bin/bash
if [ $1 –lt $2 ];
then
echo “hola”
fi

EJEMPLO distinto que

Vamos a ver el distinto que es –ne entonces si es igual no nos da pero si es distinto nos imprime hola no importa que sea mayor o menor lo que importa es que sea distinto.

#!/bin/bash
if [ $1 -ne $2 ];
then
echo “hola”
fi

OPERADORES DE CADENA

  • = Iguales
  • != Diferentes
  • -n Con longitud mayor que 0
  • -z Con longitud igual a 0 o vacío

EJEMPLO igual que

Los operadores de cadena, ya no vamos a comparar números si no que vamos a comparar cadenas, el primero operador es igual =, vamos a ejecutar nuestro comando le vamos a dar abc como primer parámetro y abc como segundo parámetro, como son iguales nos imprime hola, pero si no son iguales no imprimirá en pantalla hola.

#!/bin/bash
if [ $1 = $2 ];
then
echo “hola”
fi

EJEMPLO diferentes

La diferencia != es lo inverso a igual que si damos como parámetros abc y xyz nos da porque es diferente, pero si damos abc abc no imprimirá hola porque es igual.

#!/bin/bash
if [ $1 != $2 ];
then
echo “hola”
fi

EJEMPLO con longitud mayor que 0

Vamos a medir si la cadena viene vacía o no entonces primero con –n vamos a ver que la cadena tenga un contenido entonces colocamos una variable que se llama cadena con un contenido y vamos a decirle al operador que nos verifique si esa cadena tiene un contenido, ejecutamos nuestro script y automáticamente nos muestra el mesaje hola

#!/bin/bash
cadena=’j’
if [ -n $cadena ];
then
echo “hola”
fi

EJEMPLO con longitud igual a 0 o vacio

También hay un operador para que venga vacío que es –z con -z vamos a ver que ahora que la variable cadena esta vacía se nos va a cumplir porque la variable viene vacía.

#!/bin/bash
cadena=’’
if [ -z $cadena ];
then
echo “hola”
fi

OPERADORES DE ARCHIVO

  • -d es un directorio
  • -e existe el fichero
  • -f es un fichero ordinario
  • -r es leíble
  • -s es no vacío
  • -w es escribible
  • -x es ejecutable
  • -o eres el dueño del fichero
  • -G el grupo del fichero es igual al tuyo
  • -nt fichero1 es mas reciente que fichero2
  • -ot fichero1 es mas antiguo que fichero2

Ahora vamos a ver los operadores de archivo primero vamos a verificar si un archivo es directorio, vemos que al correrlo nos muestra que es un directorio vamos a borrar esta partecita que nos sobraba (cadena=’ ’) y vamos a verificar si no es un directorio entonces como este es un archivo regular como vamos a ver aquí en el ls primero vamos a ver prueba_if que es un directorio y prueba_if2 es un archivo regular, por eso en la primera prueba nos dio que era un directorio y en la segunda no nos dio porque era un archivo regular.

EJEMPLO es un directorio (prueba1)

#!/bin/bash
if [ -d ./prueba_if ];
then
echo “hola”
fi

EJEMPLO es un directorio (prueba2)

#!/bin/bash
if [ -d ./prueba_if2 ];
then
echo “hola”
fi

Ahora vamos a ver si el archivo existe vamos a hacerlo sobre prueba_if2 que es un archivo que existe, por eso se cumple la condicional.

EJEMPLO existe el fichero

#!/bin/bash
if [ -e ./prueba_if2 ];
then
echo “hola”
fi

pero vamos a colocarle digamos if que es un directorio que también existe, ifd que no existe porque no es un archivo dentro del sistema de archivos.

Luego esta el parámetro –f es si es un archivo ordinario entonces esto nos ayuda a ver si es un archivo o un directorio ósea a diferencia del directorio que vimos primero, a ver si es un archivo regular esto lo hacemos con el operador -f

EJEMPLO es un fichero ordinario

#!/bin/bash
if [ -f ./prueba_if2 ];
then
echo “hola”
fi

Ahora vamos a ver otro operador que es –r que es si el archivo se puede leer entonces lo colocamos

EJEMPLO es leible

#!/bin/bash
if [ -r ./prueba ];
then
echo “hola”
fi

Lo ejecutamos y el archivo prueba nos dice que no se puede leer, Porque no se puede leer? Porque es de root y no tiene absolutamente ningún permiso, estamos como el usuario fox pero entonces si le colocamos prueba_if2 si nos lo va poder leer entonces si se cumple la condicional.

#!/bin/bash
if [ -r./prueba_if2 ];
then
echo “hola”
fi

Con w vemos que el archivo es escribible entonces verificamos los permisos y vemos que se cumple la variable porque el archivo es escribible

EJEMPLO es escribible

#!/bin/bash
if [ -w./prueba_if2 ];
then
echo “hola”
fi

Luego vamos a ver si el archivo es ejecutable y efectivamente se cumple cuando es ejecutable

EJEMPLO es ejecutable

#!/bin/bash
if [ -x./prueba_if2 ];
then
echo “hola”
fi

y si lo hacemos con ./prueba_if3 pues que no es ejecutable pues no se cumple la condicional.

Ahora vamos a verificar si el archivo pertenece a quien esta ejecutando el scrip con el operador –o, aquí vemos que se cumple porque el usuario es fox, si nosotros ejecutamos por ejemplo sobre ./prueba que pertenece a root pues entonces no se va a cumplir la condicional porque ./prueba no pertenece a fox que es el usuario que lo esta ejecutando

EJEMPLO Eres el dueno del fichero

#!/bin/bash
if [ -o./prueba_if3 ];
then
echo “hola”
fi

Después vamos a verificar el grupo con –G (mayúscula) sobre ./prueba no es nuestro grupo porque es el grupo root pero si lo colocamos sobre ./prueba_if3 vamos a poder validarlo porque si pertenece al grupo fox que es nuestro usuario

EJEMPLO el grupo del fichero es igual al tuyo

#!/bin/bash
if [ -G./prueba_if3 ];
then
echo “hola”
fi

Ahora vamos a utilizar el operador –nt que es para ver si el fichero es mas reciente que otro fichero, entonces vamos a comparar si ./prueba_if3 es mas reciente que ./prueba_if2 entonces le colocamos el archivo –nt y el otro archivo con el que vamos a comparar, cuando hacemos la comparación se cumple porque ./prueba_if3 es mas nueva que ./prueba_if2

EJEMPLO fichero1 es mas reciente que fichero 2

#!/bin/bash
if [ ./prueba_if3 –nt ./prueba_if2 ];
then
echo “hola”
fi

con –ot hacemos lo contrario entonces no se cumple porque es mas antiguo pero si invertimos el orden de los archivos pues nos va a dar porque ./prueba_if2 es mas antiguo que ./prueba_if3

EJEMPLO fichero1 es mas antiguo que fichero 2

#!/bin/bash
if [ ./prueba_if2–ot ./prueba_if3 ];
then
echo “hola”
fi

OPERADORES BOLEANOS

! Negacion
-a and
-o or

Los operadores boléanos funcional de la siguiente forma vamos a crear 4 parámetros con $1 $2 $3 $4 y a ellos le vamos a colocar la comparación de equivalencia numérica entonces primero vamos a ver el operador and (-a) ósea el y para que se cumpla la equivalencia del $1 $2 y el $3 $4

 

EJEMPLO and

#!/bin/bash
if [ $1 -eq $2 -a $3 -eq $4 ];
then
echo “hola”
fi

Entonces grabamos nuestro Scrip y lo ejecútanos como lo vamos a ejecutar? Pues teniendo 2 igualdades, entonces vamos a colocar 1 1 como parámetros $1 $2 y luego 2 2 como parámetros $3 $4 y se nos cumple cuando cambiamos un parámetro pues entonces no se nos cumple porque and (-a) obliga a que las 2 condicionales se cumplan para poder cumplir la otra condicional.

Ya cuando pasamos al or (-o) se puede cumplir o una o la otra si nosotros volvemos y hacemos el ejemplo y pasamos 1 1 2 2 se cumple una o la otra porque las 2 son iguales, luego 1 1 2 3 se cumple una de ellas por eso también se cumple la condicional pero si colocamos 1 3 2 3 no se cumple ninguna de las 2 igualdades entonces no nos muestra el aviso hola

EJEMPLO or

#!/bin/bash
if [ $1 -eq $2 -o $3 -eq $4 ];
then
echo “hola”
fi

OPERADORES ARITMETICOS

+ Suma
-Resta
\* Multiplicación
/ División

Después siguen los operadores aritméticos son con los que podemos hacer operaciones para esto se utiliza el comando expr y vamos a hace primero una suma 20+30

EJEMPLO suma

#!/bin/bash
expr 20 + 30

ejecutamos nuestro Scrip obviamente nos da 50. Luego vamos a hacer una resta entonces le restamos a 30 20

EJEMPLO suma

#!/bin/bash
expr 30 - 20

guardamos nuestro Scrip , lo ejecutamos nos va dar 10. Vamos con la multiplicación el de la multiplicación es el * colocamos 30*20 guardamos pero aquí hay una cosa si nostros ejecutamos nuestro Scrip va a presentar un error de sintaxis porque se tiene que colocar una contra barra, contra slash para que para que el asterisco funcione

EJEMPLO multiplicacion

#!/bin/bash
expr 30 \* 20

Así ya nos da la multiplicación bien. Ahorita vamos a ser la división se hace con la barra normal ósea el slash si dividimos 30 entre 20

EJEMPLO División

#!/bin/bash
expr 30 / 20

pues nos va a dar 1.25 pero el sistema redondea a 1 si tiene alguna duda pues entonces colocan 40 /20

EJEMPLO Division 2

#!/bin/bash
expr 40 / 20

esto nos va a dar 2. Con esto terminamos la parte de los operadores y entramos en la parte de los arreglos.

ARREGLOS

Los arreglos son variables que tienen varios datos dentro, no solo tienen un dato sino que tienen varios datos. Entonces comenzamos nuestro Scrip con el encabezado que ya sabemos al interprete de la bash vamos a declarar nuestra variable que va a ser una variable llamada frutas y dentro va tener varios datos como en una especie de casilleros, eso se llama arreglo vamos a colocar en la posición 1 la fruta limón luego vamos a copiar idéntico la sintaxis de la array vamos a replicarla otros 4 espacios mas y vamos a poner las demás frutas manzana, platano, naranja y pera, luego vamos a nombrar cada una de las casillitas le vamos a colocar el numero que sigue

#!/bin/bash
frutas [0] =’limon’
frutas [1] =’manzana ’
frutas [2] =’platano’
frutas [3] =’naranja’
frutas [4] =’pera’

Aquí ya tenemos nuestro arreglo completo y podemos pasar ahora como se imprime, con un echo si nosotros queremos imprimir una casilla en particular pues colocamos el símbolo de pesos llaves luego el nombre de la variable y entre corchetes la posición en el arreglo

#!/bin/bash
frutas [0] =’limon’
frutas [1] =’manzana ’
frutas [2] =’platano’
frutas [3] =’naranja’
frutas [4] =’pera’
echo ${frutas[1]}

Entonces grabamos nuestro Scrip, le colocamos los permisos de ejecución lo ejecutamos y nos va amostrar   la posición donde esta fruta manzana si nosotros cambiamos el numero digamos por el numero 4 entonces nos va a imprimir pera.

Que pasa si queremos verlos todos entonces colocamos @ dentro de la casilla y nos va a mostrar todo el contenido del arreglo

#!/bin/bash
frutas [0] =’limon’
frutas [1] =’manzana ’
frutas [2] =’platano’
frutas [3] =’naranja’
frutas [4] =’pera’
echo ${frutas[@]}

Entonces ya queda un poquito claro que es una variable tipo arreglo, pero hay otra forma de declarar las variables tipo arreglo con declare –a abre paréntesis y cada uno de los datos que están relacionados al arreglo se colocan entre comillas separadas por espacio, comilla simples entonces hacemos lo mismo limón manzana, platano, pera, naranja vez tenemos colocados nuestros datos del arreglo procedemos a asignarle la variable frutas

#!/bin/bash
declare –a frutas=(‘limon’ ‘manzana’ ‘platano’ ‘pera’);
echo ${frutas[@]}

Ahora grabamos y ejecutamos nuestro arreglo que nos muestra limón manzana bueno todos los miembros del arreglo si nosotros otra vez colocamos la posición del arreglo entonces nos va amostrar cada uno de los diferentes datos en las diferentes posiciones del arreglo ,como habíamos echo en la primera forma.

FUNCIONES

Una vez terminamos con los arreglos vamos a hablar de las funciones, las funciones son pedazos de código que se pueden reutilizar   dentro de nuestro código entonces como lo hacemos? Lo hacemos con function damos el nombre de la función abrimos llaves colocamos lo que va hacer esa función y luego cerramos llaves, en este caso vamos a colocar el comando crear,

#!/bin/bash
function limpiar {
clear
}

vamos a declarar otra función que se llama n_procesos y dentro de n_procesos vamos a colocar ps xa | wc que es Word count -l que es cuenta el numero de líneas y así vamos a saber la cantidad de procesos que están corriendo en el momento

function n_procesos {
ps xa | wc -l
}

de la misma forma que lo hicimos arriba, vamos a declarar otra función que se va a llamar suma con la cual vamos a sumar 2 números como hicimos con en la parte de los operadores aritméticos entonces vamos a poner expr 10 + 10

function suma {
expr 10+10
}

entonces ahora vamos a llamar la primera función que es limpiar ejecutamos enteste caso no pasamos parámetro y nos limpio la pantalla

#!/bin/bash
function limpiar {
clear
}

function n_procesos {
ps xa | wc -l
}

function suma {
expr 10+10
}

limpiar

Ahora vamos a quitar este limpiar y colocamos n_procesos, cuando ejecutamos n_procesos nos va a mostrar el numero de procesos que están corriendo que es 183

#!/bin/bash
function limpiar {
clear
}

function n_procesos {
ps xa | wc -l
}
function suma {
expr 10+10
}
n_procesos

Luego vamos a borrar n_procesos y colocamos suma, cuando colocamos suma guardamos y ejecutamos el scrip nos trajo la suma 10+10   que teníamos en función

#!/bin/bash
function limpiar {
clear
}

function n_procesos {
ps xa | wc -l
}

function suma {
expr 10+10
}
suma

Si queremos las podemos llamar todas , entonces colocamos   la función limpiar como la función n_procesos y la función suma una debajo de la otra y cuando lo ejecutemos vamos a ver que las 3 funciones se ejecutaron una detrás de la otra

#!/bin/bash
function limpiar {
clear
}
function n_procesos {
ps xa | wc -l
}
function suma {
expr 10+10
}
limpiar
n_procesos
suma

Entonces guardamos nuestro archivo, ejecutamos y limpio , 183 procesos y 20 que es la suma de 10+10

ASIGNACIÓN

Ahora vamos a ver la asignación, nosotros podemos ejecutar comandos y el resultado de esa ejecución la podemos asignar a una variable, entonces vamos a ver el ejemplo que hemos echo durante todas estas clases que es la de contar los procesos con ps xa | wc –l entonces el numero se lo vamos a agregar a la variable procesos, entonces el comando se ejecuta y el resultado se le asigna a procesos y echo mostrará el contenido de la variable que va a ser el numero de procesos que están en ejecución actualmente.

#!bin/bash
procesos=$(ps xa | wc -l)
echo $procesos

entonces guardamos, vamos a darle los permisos de ejecución, siempre se le debe dar los permisos de ejecución para que funcione el scrip (chmod u+x asignacion.sh) y ejecutamos el Scrip asignación y nos va a dar como resultado 184 procesos que están corriendo.

También lo podemos hacer con otros comandos digamos que vamos a contar el numero de archivos que hay donde estamos parados con ls –l

#!bin/bash
procesos=$(ls -l | wc -l)
echo $procesos

Ejecutamos el script y nos dará el número de archivos que hay en la ubicación actual. Esto es muy potente si nosotros lo combinamos con otro comandito. Entonces primero vamos a ver un archivo que es el archivo donde están los usuarios ([email protected]:~# cat /etc/passwd) del sistema linux , vemos que es un archivo que esta separado por carácter : entonces vamos a tratarlo, vemos que esta el usuario una x y el id del usuario, vamos a utilizar el comando awk. El comando awk con el parámetro menos –F (mayúscula) nos va diferenciar cual es el separador que va a ir entre comillas dobles entonces colocamos el : que es nuestro separador , luego dentro de comillas simples y dentro de llaves vamos a colocar la palabra print y una variable, el va comenzar a contar las columnas 1 2 3 4 entonces la primera columna seria la columna 1 que seria la del usuario, entonces vamos a darle cat /etc/passwd y por medio de la tuberia vamos a pasarle la salida a la awk para que nos filtre y nos separe por los 2 puntos (:)

[email protected]:~#awk -F “:” ‘{print $1}’
^c
[email protected]:~# cat /etc/passwd | awk -F “:” ‘{print $1}’

Entonces aquí ya tenemos que la primera columna que es el $1 es la columna del usuario, si le ponemos $2 es donde estaba la x y si le colocamos $3 ya nos da el id de los usuarios que estan en el passwd entonces esto lo vamos a meter dentro de un scrip se lo vamos a metre dentro a una variable para utilizarlo

[email protected]:~# cat /etc/passwd | awk -F “:” ‘{print $3}’

Entonces editamos nuestro scrip asignacion.sh colocamos nuestro comando luego colocamos un filtro adicional con el grep que ya habiamos visto en las clases pasadas y cvamos a buscar el usuario fox para que nos de unicamente el id del usuario fox porque ya nos habia mostrado los de todos los usuarios, con esto vamos a ver el usuario fox le vamos a cambiar el nombre de las variables que se llame foxid

#!bin/bash
foxid=$’( cat /etc/passwd | grep fox | awk -F “:” ‘{print $3}’)’
echo $foxid

con esto vamo a grabar nuestro scrip y ejecutarlo y ahí no da el id de nuestro usuario fox, si nosotros por ejemplo editamos el archivo y le colocamos el usuario root entonces cuando ejecutemos nuestro scrip pues nos va adar el id 0 que es el id del root

bueno espero que les aya gustado la clase, cara resumir vimos operadores tanto numéricos como de carácter operadores lógicos operadores de archivo y también vimos operadores aritmeticos, vimos como se declaran las variables de tipo arreglo vimos tambien como crear una funcion también vimos como asignar el resultado de un comando a una variable y acerlo también con el filtrado por medio de awk, la próxima clase vamos haber como utilizar esto de forma practica en ejemplos un poco mas complejos .

Sobre Fernando Alberto Velasquez Aguilera

Un comentario

  1. Muy buen curso buena iniciativa

Comentar

Su dirección de correo electrónico no será publicada.Los campos necesarios están marcados *

*

x

Check Also

Cómo instalar Linux CentOS paso a paso 15/60

Hoy vamos a ver Cómo instalar Linux CentOS, En este capitulo 15 del Curso de ...