Uso de declaraciones de casos en Bash

Al escribir scripts de Bash, es común comparar una cadena con una variable y luego hacer algo basado en lo que se especificó.

Considere el siguiente guión. Comprueba el primer argumento que especifica un usuario y hace diferentes cosas dependiendo de lo que se le haya dado:

#!/usr/bin/env bash
if [[ "${1}" == "" ]]; then
	echo "No shape was specified."

elif [[ "${1}" == "square" ]]; then
	echo "You specified 'square'."

elif [[ "${1}" == "circle" ]]; then
	echo "You specified 'circle'."

elif [[ "${1}" == "triangle" ]]; then
	"You specified 'triangle'." 
    
else
	echo "Unknown shape '${1}'."
    exit 1

fi

Esto demuestra, aunque sin funcionalidad, una tarea simple que puede repetir una forma conocida al usuario o, si la forma es desconocida, mostrar un mensaje de error.

Todo está bien y elegante en esto, y todo funciona como se esperaba. Pero mira cuántas líneas tomó. Vea cómo tiene que manejar cada una de las opciones que un usuario pasa a través de un elif declaración?

Ahora, la imagen de este programa tiene incluso más opciones, digamos 20. Con el enfoque actual, estará escribiendo un if declaración con 20 elif secciones en su interior.

Sí, probablemente podrás leerlo en su mayor parte. Pero es torpe, ocupa demasiado espacio y, lo que es más importante, hay una mejor alternativa.

Presentación de la declaración case en Bash

Aquí es donde entran las declaraciones de casos. Estas pueden reducir la cantidad de líneas de código que necesita para verificar las cosas por mucho en comparación con if declaraciones.

El mismo if la declaración que usó para verificar las opciones provistas podría reescribirse así dentro de un caso uno:

#!/usr/bin/env bash
case "${1}" in
	"")         echo "No option was specified."; exit 1 ;;
    square)     echo "You specified 'square'." ;;
    circle)     echo "You specified 'circle'." ;;
    triangle)   echo "You specified 'triangle'." ;;
    *)          echo "Unknown shape '${1}'."; exit 1 ;;
esac

Mira cuánto más simple y organizado se ve. Son 12 líneas de código en el if instrucción, y solo 7 en el case uno. Y cuantas más opciones permita, más drástica se vuelve la diferencia.

Y ahí es donde case brillan las declaraciones. Si bien ambos son completamente legibles, especialmente en cantidades pequeñas, case las declaraciones simplemente hacen que todo sea más limpio y fácil de mantener a largo plazo.

¿Cómo se crea una declaración de caso en Bash?

Las declaraciones de casos son bastante simples de entender con solo un poco de práctica. Con eso, esto es lo básico de lo que está pasando:

La primera línea que vio fue case ${1} in . El ${1} proporciona la cadena con la que se comprobará, siendo este el primer argumento que se pasa al script.

Por ejemplo, considere esta declaración de caso:

case linux in
    windows)    echo "windows" ;;
    macos)      echo "macos" ;;
    linux)      echo "linux" ;;
esac

En este ejemplo, siempre ejecutará echo "linux" . El case *string* in part simplemente especifica con qué cadena se verificará, y luego las opciones debajo ejecutarán los comandos cada vez que se encuentre una coincidencia.

A continuación, comience a especificar sus opciones. Recuerda, tenías "" , square , circle , triangle y * como opciones en su primer script.

Las declaraciones de casos se verifican de arriba hacia abajo y solo se ejecutan en la primera coincidencia. Considere el siguiente ejemplo:

case linux in
	linux)      echo "linux" ;;
    windows)    echo "windows" ;;
    linux)      echo "linux 2.0" ;;
esac

Aquí, el único comando que se ejecutaría sería echo "linux" . Entonces se omitiría la segunda coincidencia, ya que había una coincidencia que ya se había encontrado.

Cada línea en una declaración de caso también debe terminar en ;; . Esto significa el final de la lista de comandos para una opción y que no se deben procesar más comandos.

La lista de argumentos en una declaración de caso (el linux) y windows) las partes también admiten comodines. Por lo tanto, ingresando algo como linu*) coincidiría con ambos linux y linus .

Por último, finaliza la declaración del caso con esac . Esto le permite saber que ha enumerado todo lo que desea que procese, como done haría en un for o while bucle.

Para recordar la palabra clave para terminar una declaración de caso, solo recuerde que esac es case hacia atrás.

Declaraciones de casos en la práctica - verificaciones de argumentos

Un uso frecuente de las declaraciones de casos en mi propia programación es verificar una lista de argumentos.

Digamos que permite que se proporcionen las siguientes opciones a su programa:

• --vertical
• --add-txt
• --replace
• --verify

Para verificar esto en una declaración de caso, podría usar algo como esto:

while [[ "${1}" != "" ]]; do
	case "${1}" in
    	--vertical)    verticle="true" ;;
        --add-txt)     add_txt="true" ;;
        --replace)     replace="true" ;;
        --verify)      verify="true" ;;
    esac
    
    shift 1
done

Esto ejecuta un while bucle while ${1} (el primer argumento dado a un script) no está vacío. A continuación, comprueba una lista de argumentos y asigna variables cuando se establece la opción proporcionada.

Después de verificar la declaración del caso, ejecuta shift 1 , causando el valor de ${2} (el segundo argumento proporcionado a un script) para pasar al valor de ${1} , y repite esto contra el nuevo ${1} (que anteriormente era ${2} ) hasta ${1} no está configurado para nada.

¡Y ahí tienes! Eso es todo lo básico para usar declaraciones de casos.

Resumiendo

Las declaraciones de casos pueden ayudarlo a escribir código de manera más rápida y eficiente. También ayudan a que las cosas sean más legibles y fáciles de mantener a largo plazo.

Si es nuevo en Bash, puede aprender los conceptos básicos de Bash desde cero en nuestra Serie para principiantes de Bash.

¿Tienes alguna pregunta o algo no funciona del todo bien? Siéntase libre de dejar un comentario a continuación, ¡y haré todo lo posible para responderle!