Shell Scripting Parte 3:Estructuras de control de decisiones en Shell Scripts

¡Hola! Ya cubrimos los conceptos básicos de las secuencias de comandos de shell, como aceptar entradas, procesar datos a través de operaciones aritméticas y generar y mostrar resultados en las partes anteriores de este tutorial (parte 1 y parte 2). En esta parte, profundizaremos en un tema más avanzado en un lenguaje de programación:tomar decisiones en un programa, pero esta vez lo haremos usando bash shell. ¡Empecemos!

Introducción

La mayoría de nuestros lenguajes de programación actuales pueden tomar decisiones en función de las condiciones que establecemos. Una condición es una expresión que se evalúa como un valor booleano:verdadero o falso. Cualquier programador puede hacer que su programa sea inteligente en función de la decisión y la lógica que pone en su programa. El shell bash admite sentencias de decisión if y switch (case).

sentencia si

If es una declaración que permite al programador tomar una decisión en el programa en función de las condiciones que especificó. Si se cumple la condición, el programa ejecutará ciertas líneas de código; de lo contrario, el programa ejecutará otras tareas especificadas por el programador. La siguiente es la sintaxis admitida de la instrucción if en el shell bash.

Sintaxis general

Decisión única:

if <condition>
 then
     ### series of code goes here
 fi

Doble decisión:

if <condition>
 then
     ### series of code if the condition is satisfied
 else
     ### series of code if the condition is not satisfied
 fi

Múltiple si condición:

if <condition1>
 then
     ### series of code for condition1
 elif <condition2>
 then
     ### series of code for condition2
 else
     ### series of code if the condition is not satisfied
 fi

Sintaxis de paréntesis único

if [ condition ]
 then
     ### series of code goes here
 fi

Sintaxis de doble corchete

if ((condition))
 then
     ### series of code goes here
 fi

La sintaxis de corchete único es la sintaxis admitida más antigua en bash shell. Se usa junto con todas las declaraciones condicionales en Linux. Mientras tanto, la sintaxis de doble paréntesis se usa para una declaración condicional basada en números para proporcionar una sintaxis familiar a los programadores. Todos los tipos de declaraciones if necesitan una condición específica para ejecutar una tarea.

Declaraciones condicionales en Linux

Las sentencias condicionales se utilizan junto con una sentencia de control de decisiones. Hay diferentes tipos de declaraciones condicionales que puede usar en el shell bash, las más comunes son:condiciones basadas en archivos, basadas en cadenas y basadas en aritmética.

Condición basada en archivo

Las condiciones basadas en archivos son expresiones unarias y se usan a menudo para examinar el estado de un archivo. La siguiente lista muestra las condiciones basadas en archivos más utilizadas en el shell bash.

Tomar una decisión basada en un archivo

Veamos un ejemplo que ilustrará cómo construir una decisión basada en archivos en un script bash. En este ejemplo, crearemos una secuencia de comandos que determine si el archivo existe en el directorio de inicio.

#!/bin/bash
 
cd 
 ls
 if [ -e sample.sh ] 
 then 
     echo "file exists!" 
 else 
     echo "file does not exist" 
 fi

En este ejemplo, nos aseguramos de que el shell regrese al directorio de inicio independientemente de nuestro directorio activo actual usando el comando cd. Además, el comando ls se usa para mostrar la lista de archivos en el directorio para que verifiquemos que el archivo realmente existe o no. Como puede ver, la secuencia de comandos genera el texto "¡el archivo existe!" porque sample.sh está en el directorio de inicio.

Note: The shell compiler is very strict in terms of syntax especially with spaces. There should be a space between if and the open bracket and in between brackets and the condition.

Ahora mejoremos nuestro script haciendo que nuestro código sea más dinámico al permitir que el usuario ingrese un nombre de script y determine los permisos del archivo dado.

#!/bin/bash
 
cd
 ls -l 
 read -p "Enter a file name: " filename
 if [ -e $filename ] 
 then 
     echo "file exists!" 
     if [ -r $filename ]
     then 
          status="readable " 
     fi 
     if [ -w $filename ] 
     then 
          status=$status"writable " 
     fi 
     if [ -x $filename ] 
     then 
          status=$status"executable" 
     fi 
      echo "file permission: "$status 
 else 
     echo "file does not exist" 
 fi

Condición basada en cadenas

También es posible tomar decisiones basadas en una cadena ingresada por el usuario en el shell bash. La condición basada en cadenas devuelve una expresión binaria como resultado, lo que significa que devuelve verdadero si se cumple la condición especificada; de lo contrario, devuelve falso. Los siguientes son los operadores condicionales basados ​​en cadenas de uso común:

Vamos a crear un script de muestra usando una declaración condicional basada en cadenas. El script permitirá al usuario ingresar dos cadenas y evaluar si una de las cadenas es nula, ambas cadenas son iguales y no iguales.

#!/bin/bash 
 
read -p "First String: " str1 
 read -p "Second String: " str2 
 if [ -z "$str1" ] 
 then 
     echo "The 1st string is null" 
 elif [ -z "$str2" ] 
 then 
     echo "The 2nd string is null" 
 else 
     if [ $str1 == $str2 ] 
     then 
          echo "The strings are equal" 
     else 
         echo "The strings are not equal" 
     fi 
 fi

Condición basada en aritmética

El shell proporciona varias formas de declarar una condición basada en la aritmética. La primera es mediante el uso de mnemotécnicos que se pueden usar junto con la sintaxis de un solo paréntesis de estilo antiguo y la otra es usando símbolos matemáticos que se pueden usar junto con el doble paréntesis

A continuación se muestra la lista de mnemónicos disponibles para declaraciones condicionales basadas en aritmética en shell:

Vamos a crear un script que acepte un número entero del usuario y determine si el número entero es cero, negativo, impar o par.

#!/bin/bash 
 
read -p "Enter an integer: " int1 
 if [ $int1 -eq 0 ] 
 then 
     echo "Zero" 
 elif [ $int1 -lt 0 ] 
 then 
     echo "Negative" 
 else 
     if [ $((int1%2)) -eq 0 ] 
     then 
         echo "Even" 
     else 
         echo "Odd" 
     fi 
 fi

Operador aritmético para sintaxis de doble paréntesis:

Ahora, reconstruyamos nuestro script anterior y usemos la sintaxis de doble paréntesis:

#!/bin/bash

read -p "Enter an integer: " int1 
 if (( $int1 == 0 )) 
 then 
     echo "Zero" 
 elif (( $int1 < 0 )) 
 then 
     echo "Negative" 
 else 
     if (( $((int1%2)) == 0 )) 
     then 
         echo "Even" 
     else 
         echo "Odd" 
     fi 
 fi

Declaración de cambio

La declaración de cambio es otro tipo de declaración condicional en scripts de shell. Le permite a un programador comparar varios valores con una variable de una manera más fácil en comparación con la declaración condicional. La sintaxis para la declaración de cambio es:

 case  in
 <pattern1>)
     ##series of code for pattern1
     ;;
 <pattern2>)
     ##series of code for pattern2
     ;;
 <patternN>)
     ##series of code for patternN
     ;;
 *) 
     ##default statements
 esac
 

El patrón es el valor posible de la variable. Cada patrón se separa con un punto y coma doble que sirve como declaración de interrupción del patrón. La sentencia switch se cierra con una sentencia esac.

#!/bin/bash 
 clear 
 read -p "Integer1: " int1 
 read -p "Integer2: " int2 
 echo "======================" 
 printf "Menu: \n[a] Addition\n[b]Subtraction\n[c]Multiplication\n[d]Division\n" 
 echo "======================" 
 read -p "Your choice: " choice 
 res=0 
 case $choice in 
 a) 
     res=$((int1+int2)) 
 ;; 
 b) 
     res=$((int1-int2)) 
 ;; 
 c) 
     res=$((int1*int2)) 
 ;; 
 d) 
     res=$((int1/int2)) 
 ;; 
 *) 
     echo "Invalid input" 
 esac 
 echo "The result is: " $res

Conclusión

El shell bash proporciona muchas herramientas útiles para los programadores. Al igual que la mayoría de los lenguajes de programación actuales, también es capaz de tomar decisiones condicionales que hacen que los scripts de shell sean más interactivos e inteligentes. Presentaremos una estructura de control repetitiva en la próxima serie. 'Hasta la próxima.

Referencias

• http://www.gnu.org/software/bash/manual/html_node/Bash-Conditional-Expressions.html
• https://linuxacademy.com/blog/linux/condiciones-en-bash-scripting-if-statements/

La próxima lección: Estructuras de control de repetición