Conceptos básicos de automatización de bash y secuencias de comandos (parte 2) – CloudSavvy IT

Shutterstock / Mopic

Bash es un lenguaje de codificación y shell ideal, que le permite crear scripts de automatización de alta gama. En esta segunda parte de la serie, veremos la densidad de codificación, los comentarios en línea y las comillas correctas de las variables utilizando comillas simples o dobles.

Conceptos básicos de automatización de bash y secuencias de comandos

Si aún no lo ha hecho, y recién está comenzando en Bash, lea nuestro artículo Bash Automation and Scripting Basics Part 1. Este es el segundo artículo de nuestra serie de tres partes sobre los conceptos básicos de automatización y scripting de Bash. En el artículo de hoy veremos, entre otros temas, la densidad de codificación Bash y su conexión con las preferencias del desarrollador. También veremos los comentarios en línea en relación con esto.

Una vez que comenzamos a crear pequeños scripts, exploramos variables y trabajamos con cadenas de texto, rápidamente nos damos cuenta de que puede haber una diferencia conceptual entre comillas simples y dobles. La hay, y en el segundo tema a continuación nos sumergiremos en esto.

Densidad y concisión de la codificación Bash

El lenguaje de codificación Bash puede ser muy denso y conciso, pero también puede ser espacioso y detallado. Depende en gran medida de la preferencia del desarrollador.

Por ejemplo, el siguiente código Bash:

true || echo 'untrue'

Que se puede leer como No haga nada y hágalo con éxito (código de salida 0), y si eso falla (puede leer el modismo Bash || como OR) genera el texto ‘falso’, también se puede escribir como:

if [ ! true ]; then
  echo 'untrue'
fi

Lo que hace que el código sea un poco diferente, pero básicamente hace lo mismo.

Esto a su vez puede leerse como Si verdadero no es (significado por el ! idiom) verdadero, luego muestra el texto ‘falso’.

Dos formas de codificar en Bash;  misma funcionalidad, código bastante diferente

Ambos mini-scripts dan como resultado la misma salida vacía, como cierto no es falso.

La multitud de comandos y herramientas disponibles (o instalables) desde y en la línea de comandos amplía aún más el posible desplazamiento entre scripts altamente legibles y código denso, conciso y difícil de entender.

Mientras que los ejemplos anteriores son cortos y relativamente fáciles de entender, cuando crea una línea larga (un término que se usa a menudo entre los desarrolladores de Bash para indicar un fragmento de código, que consta de múltiples comandos, escritos en una sola línea) empleando muchos de dichos comandos , frente a poner lo mismo en un guión más detallado, la diferencia se vuelve más clara. Considerar:

V="$(sleep 2 & fg; echo -n '1' | sed 's|[0-9]|a|')" && echo "${V}" | sed 's|[a-z]|2|g' || echo 'fail'

Un ejemplo complejo de un delineador

Este es un script típico de una sola línea de Bash que usa los comandos sleep, fg, echo, y sed así como varios modismos de Bash y expresiones regulares para dormir básicamente 2 segundos, generar algo de texto y transformar este texto usando expresiones regulares. El script también verifica regularmente las condiciones / resultados de los comandos anteriores utilizando los modismos Bash || (si no tiene éxito, haga lo siguiente) y && (si tiene éxito, haga lo siguiente)

Traduje esto, con una funcionalidad de coincidencia aproximada, a un script más completo, con algunas modificaciones. Por ejemplo, cambiamos nuestro fg (trae el sleep comando colocado en segundo plano de nuevo en primer plano, y espere a que termine como procesos normales sin segundo plano) para wait que esperará el PID del sueño (iniciado por eval y capturado usando el modismo Bash $!) para terminar.

#!/bin/bash

CMD="sleep 2"
eval ${CMD} &
wait $!
EXIT_CODE=${?}

V="$(echo -e "${CMD}n1" | sed 's|[0-9]|a|')"

if [ ${EXIT_CODE} -eq 0 ]; then
  echo "${V}" | sed 's|[a-z]|2|g'
  EXIT_CODE=${?}
  if [ ${EXIT_CODE} -ne 0 ]; then
    echo 'fail'
  fi
fi

En su lugar, el mismo complejo en línea en un script completo

¡Qué diferencia! Y esto es solo uno desarrollador escribiéndolo en su camino. El código bash escrito por otros tiende a ser algo difícil de leer, y esa dificultad aumenta rápidamente con la densidad y la concisión. Aún así, un desarrollador de nivel experto en Bash comprenderá rápidamente incluso el código muy denso y conciso escrito por otros, con algunas excepciones, por ejemplo, las expresiones regulares.

Para obtener más información sobre cómo escribir expresiones regulares, eche un vistazo a Cómo modificar texto usando expresiones regulares con sed Stream Editor.

A partir de estos ejemplos, queda claro que su kilometraje variará con el tiempo. Sin embargo, en general, se recomienda que los programadores sean amigables (escribiendo código altamente legible) siempre que comience a desarrollar scripts Bash.

Si tiene que crear un código denso y conciso, puede proporcionar muchos comentarios en línea. Una línea prefijada por un # se considera una línea de comentario / observación, y el símbolo # incluso se puede usar hacia el final de una línea después de cualquier comando ejecutable, para publicar un comentario de sufijo que explique el comando, la declaración condicional, etc. Por ejemplo:

# This code will sleep one second, twice
sleep 1  # First sleep
sleep 1  # Second sleep

¿Cotizaciones simples o cotizaciones dobles?

En Bash, texto entre comillas simples (') son tomados como texto literal por el intérprete de Bash, mientras que el texto entre comillas dobles (") es interpretado (analizado) por el intérprete de Bash. Mientras que la diferencia en cómo funcionan las cosas puede no ser clara de inmediato a partir de esta definición, el siguiente ejemplo nos muestra lo que sucede cuando intercambiamos ' por " y viceversa:

echo ' $(echo "Hello world") '
echo " $(echo 'Hello world') "

Comillas simples versus comillas dobles en Bash en un ejemplo de hola mundo

En el primer ejemplo, el texto $(echo "Hello world") se ve como texto literal, por lo que la salida es simplemente $(echo "Hello world") . Sin embargo, para el segundo ejemplo, la salida es Hello world .

El intérprete de Bash analizó el texto entre comillas dobles para ver si encontraba algún lenguaje de Bash especial sobre el que actuar. Uno de esos modismos se encontró en $( ... ) que básicamente inicia una subcapa y ejecuta lo que esté presente entre el ( ... ) modismos. Piense en ello como un shell dentro de un shell, un subshell, que ejecuta todo lo que le pasa como un comando completamente nuevo. La salida de cualquiera de estos comandos o comandos se pasa de nuevo al shell de nivel superior y se inserta en el lugar exacto donde se inició el subshell.

Por lo tanto, nuestra subcapa ejecutó echo 'Hello world' de los cuales la salida es Hello world. Una vez hecho esto, la subcapa terminaba y el texto Hello world fue insertado en lugar del $( ... ) invocación de subcapa (piense en ello como todos los $( ... ) el código está siendo reemplazado por cualquier salida generada por la subcapa.

El resultado, para el shell superior, es el siguiente comando: echo " Hello world ", de los cuales la salida es Hello world como vimos.

Tenga en cuenta que cambiamos las comillas dobles dentro de la subcapa a comillas simples. ¡Esto no es necesario! Uno esperaría ver un error de análisis cuando un comando toma la sintaxis de echo " ... " ... " ... ", en el sentido de que las segundas comillas dobles terminarían con la primera, seguidas de más pruebas, lo que provocaría un error. Sin embargo, este no es el caso.

Y esto no se debe a que Bash sea flexible con cadenas de comillas múltiples (acepta echo 'test'"More test"'test' felizmente, por ejemplo), sino porque la subcapa es una carcasa en sí misma y, por lo tanto, se pueden usar comillas dobles, nuevamente, dentro de la subcapa. Probemos esto con un ejemplo adicional:

echo "$(echo "$(echo "more double quotes")")"

Bash acepta fácilmente comillas dobles repetidas dentro de una subcapa

Esto funcionará bien y producirá la salida more double quotes. Las dos subcapas anidadas (que se ejecutan dentro del shell principal desde el que está ejecutando esto) aceptan, a su vez, comillas dobles y no se generan errores, incluso si se anidan varias comillas dobles en el comando general de una sola línea. Esto muestra parte del poder de programación de Bash.

En resumen

Habiendo explorado la densidad de codificación, nos damos cuenta del valor de escribir código altamente legible. No obstante, si tenemos que hacer un código denso y conciso, podemos agregar muchos comentarios en línea usando # para facilitar la legibilidad. Analizamos las comillas simples y dobles y cómo su funcionalidad difiere sustancialmente. También analizamos brevemente los comentarios en línea en los scripts, así como la funcionalidad de la subcapa cuando se ejecuta desde una cadena entre comillas dobles. Por último, vimos cómo una subcapa puede usar otro conjunto de comillas dobles sin afectar de ninguna manera las comillas dobles utilizadas en un nivel superior. ¡Estén atentos a la parte 3!

Deja un comentario

En esta web usamos cookies para personalizar tu experiencia de usuario.    Política de cookies
Privacidad