Estructuras de control en shell scripting

English version: Shell scripting control structures

Los scripts de shell ejecutan los comandos en secuencia de manera similar a otros lenguajes de programación y las estructuras de control pueden cambiar el orden de ejecución de estos comandos.

Condicionales

Las estructuras condicionales son aquellas que permiten ejecutar una acción si se cumple una determinada condición. La estructura de control más común en shell scripting es el comando if. Este comando permite evaluar una expresión y, si se cumple la condición, ejecutar un bloque de comandos.

if

El siguiente es un ejemplo de if:

#!/bin/bash

if [ condition ]; then
  Do something
elif [ condition 2 ]; then
  Do something
else
  Do something
fi

Los espacios entre la condición y los corchetes es necesario (en bash).

Una alternativa de construir las condiciones es [[ condition ]].

El fin de la estructura se cierra con la palabra fi (if al revés).

Existen múltiples operadores que se pueden emplear en las condiciones como:

Cadenas:

[ "abc" \= "abc" ] => Si la cadena 1 es exactamente igual a la cadena 2 (verdadero).

[ "abc" != "abc" ] => Si la cadena 1 no es igual a la cadena 2 (falso).

[[ "abcd" \= *bc* ]] => Si la cadena 1 contiene la cadena 2 (verdadero).

[[ "abe" \= "ab**[cd]**" ]] => Si el tercer caracter de la cadena 1 es c o d (falso).

[ -z $var ] => Si la variable está vacía o es null.

[ -n $var ] => Si la longitud de la cadena es distinta de 0.

Números:

[ 5 -eq 5 ] => Si el número 1 es igual al número 2 (verdadero).

[ 5 -ne 5 ] => Si el número 1 no es igual al número 2 (falso).

[ 5 -gt 5 ] => Si el número 1 es mayor al número 2 (falso).

[ 5 -ge 5 ] => Si el número 1 es mayor o igual al número 2 (verdadero).

[ 5 -lt 5 ] => Si el número 1 es menor al número 2 (falso).

[ 5 -le 5 ] => Si el número 1 es menor o igual al número 2 (verdadero).

Archivos:

[ -e file ] => Si el archivo existe.

[ -f file ] => Si es un archivo regular.

[ -d /dir ] => Si el parámetro es un directorio.

[ -s file ] => Si el tamaño del archivo es distinto de 0.

[ -r file ] => Si el archivo tiene permisos de lectura.

[ -w file ] => Si el archivo tiene permisos de escritura.

[ -x file ] => Si el archivo tiene permisos de ejecución.

Lógicos:

[ ! -e file ] => Niega el resultado.

[ condition ] && [ condition ] => Ambas condiciones deben ser verdaderas para que el resultado sea verdadero.

[ condition ] || [ condition ] => Una de las condiciones debe ser verdadera para que el resultado sea verdadero.

case

El siguiente es un ejemplo de case:

#!/bin/bash

case $choice in
  1)
    Do something
    ;;
  2)
    Do something
    ;;
  *)
    Do something
    ;;
esac

El espacio (o el salto de línea) entre el paréntesis y el comando es necesario.

Cada bloque dentro del case debe cerrarse con ;; .

Se pueden colocar los ;; de cierre al final del último comando, pero como buena práctica se lo cola en una línea nueva para ayudar a la legibilidad.

Bucles

Las estructuras de bucle permiten ejecutar un bloque de comandos repetidas veces hasta que se cumpla una condición. En shell scripting, existen dos tipos de estructuras de bucle: for y while.

for

El siguiente es un ejemplo de for:

#!/bin/bash

for variable in lista; do
  Do something
done

Las palabras do y done indican el inicio y fin del bloque de instrucciones.

Existen múltiples formas de definir la lista de elementos como:

Números:

#!/bin/bash

for number in 1 2 3 4; do
  echo $number
done

También es posible usar {0..4} para representar la lista anterior.

Archivos en un directorio:

#!/bin/bash

for file in *; do
  echo $file
done

El asterisco (*) es un comodín que significa todos los archivos en el directorio actual.

Cadenas de caracteres:

#!/bin/bash

for string in "Hello" "World"; do
  echo $string
done

Salida de un comando:

#!/bin/bash

for directory in $(ls); do
  echo $directory
done

También es posible escribir el bucle for de la siguiente manera (de forma similar a otros lenguajes de programación):

#!/bin/bash

for (( number = 0 ; number <= 4; number++ )); do
  echo $directory
done

while

El siguiente es un ejemplo de while:

#!/bin/bash

while [ condition ]; do
  Do something
done

Como la condición se evalúa en cada iteración del bucle, si esta nunca se vuelve falsa, será un bucle infinito, para evitar esto es importante asegurarse de que la condición eventualmente se vuelva falsa o utilizar una instrucción break como se ve a continuación:

#!/bin/bash

counter=1
while true; do
  echo $counter
  if [ $counter -eq 10 ]
  then
    break
  fi
  counter=$((counter + 1))
done

En este ejemplo, el bucle "while" se ejecuta indefinidamente con la condición true. En cada iteración, se imprime el valor de counter y luego se incrementa en 1. Si el valor de counter es igual a 10, se ejecuta la instrucción break, lo que detiene el bucle.

La instrucción break es útil en los bucles para detenerlos en un momento específico si se cumple una determinada condición. Esto ayuda a evitar bucles infinitos y a mejorar la eficiencia y el control del código.

until

El siguiente es un ejemplo de until:

#!/bin/bash

until [ condition ]; do
  Do something
done

Pueden presentarse situaciones en las que sea necesario saltar una iteración específica y continuar con la siguiente, esto es posible usando la instrucción continue como se ve a continuación:

#!/bin/bash

counter=0
until [ $counter -eq 10 ]
do
    counter=$((counter + 1))
    if [ $((counter % 2)) -eq 0 ]
    then
        continue
    fi
    echo $counter
done

En este ejemplo, se define una variable de contador counter inicializada en 0. El bucle "until" continuará hasta que el valor de counter sea igual a 10. En cada iteración, se aumenta el valor de counter en 1. Luego, se evalúa si el resto de la división de counter entre 2 es igual a 0. Si se cumple esta condición, se ejecuta la instrucción continue, lo que salta la iteración actual y continúa con la siguiente. Si la condición no se cumple, se imprime el valor de counter.

Como resultado, este código imprimirá los números impares del 1 al 9.

La instrucción continue es útil en los bucles para saltar una iteración específica si se cumple una determinada condición, sin tener que salir del bucle completamente. Esto ayuda a mejorar la eficiencia y el control del código, y es una buena práctica de codificación para escribir código legible y mantenible.

Si te resultó útil, dale me gusta/comparte a este artículo para que llegue a otros y si eres nuevo en el blog, ¡te agradecería que me sigas! Trato de escribir artículos para mantener un registro de todo lo que he aprendido o que personalmente quiero leer y me encanta saber cómo lo hice u obtener ideas de los lectores.

¡Hasta la próxima!