Los scripts de Bash son poderosos, pero el poder conlleva una gran responsabilidad. Es muy manejable que un código descuidado o mal planificado cause un daño auténtico, por lo que es una buena idea tener cuidado y practicar la programación defensiva.

Felizmente, Bash tiene varios mecanismos integrados para ayudar a protegerte. Muchos de ellos implican actualizaciones de sintaxis que han reemplazado métodos más antiguos y problemáticos. Puede utilizar estas sugerencias para someter la posibilidad de errores, depurar sus programas y manejar casos extremos.

Utilice una buena carrera Shebang

La primera carrera de su script de shell siempre debe ser un comentario específico, conocido como shebang o hashbang, que declara qué intérprete debe ejecutar el script. Puede ser el nombre de un shell, un lengua de programación o, en teoría, cualquier otro comando. Puede arreglárselas sin un artificio, pero para que su asunto sea independiente y haga que anuncie el idioma en el que fue escrito, un artificio es esencial.

Hay dos escuelas de pensamiento principales sobre cómo se debe instrumentar su negocio. El primero es más tradicional y tiene este aspecto:

        #!/bin/bash
echo "Hello, world"

    

Esta carrera shebang le dice a cualquier shell que ejecute el script que debe pasarlo a un software que reside en /bin/bash. Si aceptablemente este enfoque está aceptablemente y debería funcionar casi todo el tiempo, algunas personas prefieren lo sucesivo:

        #!/usr/bin/env bash
echo "Hello, world"

    

Con solo un argumento, el comando env simplemente lo ejecuta, es proponer, este shebang hará que env ejecute bash y le pase el script. La gran diferencia aquí es que env usa un nombre de comando en circunstancia de una ruta completa a un ejecutable. Es el mismo tipo de diferencia que obtienes en la carrera de comando cuando ejecutas un software:

        ls -l *.md
/bin/ls -l *.md

    

Un nombre de comando simple, sin ruta, ejecutará la traducción de ese comando que tenga más sentido en contexto. Podría ser una función de shell, un seudónimo o un archivo de software enclavado en algún circunstancia de su RUTA. Es importante destacar que si tiene versiones en, por ejemplo, /bin, /usr/circunscrito/bin y ~/.circunscrito/bin, env normalmente ejecutará la “más circunscrito”, que normalmente es lo que usted desearía.

El enfoque env tiene la superioridad de que no importa si su software bash está en /bin, /circunscrito/bin, ~/bin o en cualquier otro circunstancia, siempre que esté en su RUTA. Esta es la opción más portátil: funcionará en sistemas más diversos, que pueden no estar configurados exactamente igual que el suyo.

Mientras tanto, la traducción /bin/bash garantizará que el software en una ubicación específica se ejecutará, incluso si se instala uno diferente en otro circunstancia. Esta puede ser una opción más segura, ya que otra traducción de bash no puede secuestrar el script.

Ningún enfoque es más correcto que el otro; son simplemente diferentes. Lo importante es comprender las diferencias y designar el enfoque correcto para su situación. Si sólo estás escribiendo scripts para tu propio uso, no debería importar demasiado de ninguna guisa.

Cotiza siempre tus variables

Pocas cosas han causado más problemas en Linux que su enfoque de los espacios en blanco, que separa los comandos de sus argumentos y cada argumento de los demás. Si no tienes cuidado, es manejable que los espacios causen problemas, especialmente cuando empiezas a trabajar con variables.

Tome este ejemplo:

        #!/bin/bash
FILENAME="docs/Letter to bank.doc"
ls $FILENAME

    

Cuando Bash expande una variable, lo hace fielmente; la carrera final terminará como el equivalente de:

        ls docs/Letter to bank.doc

    

Conveniente a que los espacios separan los argumentos, Bash interpretará esto como una emplazamiento a ls con tres argumentos: “docs/Letter”, “to” y “bank.doc:”.

Para evitar este problema, asegúrese de citar siempre las variables cuando las utilice, como esta:

        ls "$FILENAME"

    

Es posible que haya manido scripts que igualmente incluyen nombres de variables entre llaves, como este:

        ls "${FILENAME}"

    

Esa es otra buena idea, aunque no es necesaria en este ejemplo específico. Encerrar el nombre de una variable entre llaves hace que sea más manejable seguirlo con otro texto fiel, como:

        echo "_${FILENAME}_ is one of my favourite files"

    

Sin las llaves, Bash intentaría encontrar una variable emplazamiento FILENAME_ y fallaría.

Detenga su secuencia de comandos en caso de error

Pocas cosas son tan riesgosas como el fracaso sin control. En un script de shell, es posible que esté llamando a muchos comandos diferentes, con la esperanza de que tengan éxito. Deberías comprobarlo con atención, pero aquí tienes una red de seguridad útil que te ayudará a protegerte de todos modos:

        set -e

    

El manual de Bash describe la función de esta configuración como:

Salga inmediatamente si una canalización, que puede cifrar en un único comando simple, una registro o un comando compuesto, devuelve un estado dispar de cero.

En términos simples, su secuencia de comandos se detendrá si poco sale mal y aún no lo ha solucionado. Tome este ejemplo:

        #!/bin/bash
touch /file
echo "Now do something with that file..."

    

El asunto aquí supone que el contacto tendrá éxito, pero esa suposición es peligrosa:

Añadir una emplazamiento a conjunto -e hará que el script se detenga tan pronto como falle el comando táctil:

El comando set puede cambiar varias opciones que controlan cómo funciona el shell. Consulte igualmente, por ejemplo, la configuración de pipefail:

        set -o pipefail

    

Esto garantiza que una tubería saldrá con un estado dispar de cero, para indicar una falta, si alguno de sus componentes falta. De forma predeterminada, una falta que ocurre al principio de una tubería puede fácilmente producirse desapercibida.

Pague alrededor de delante: Deténgase en presencia de el fracaso

Resolver por error es un tema importante, pero igualmente debe tratar de manejar fallas específicas y tomar las medidas adecuadas. Una forma sencilla de comprobar si hay errores es comprobar el estado de salida de un comando.

Puede comprobar el estado de salida de un comando inspeccionando el símbolo $? variable luego de haberla ejecutado:

        cd "$DIR"
if ( $? -ne 0 ); then
exit
fi

    

A modo abreviado, igualmente puedes utilizar operadores lógicos Bash:

        cd "$DIR" || (echo "bad"; exit)

    

Depurar cada comando

Otra opción de shell muy valiosa es xtrace:

        set -o xtrace

    

Esta opción hace que el shell imprima comandos antaño de ejecutarlos, lo cual es muy útil al depurar:

El shell ahora imprime cada comando a medida que se ejecuta, incluidos sus argumentos.

Hay muchas otras opciones que pueden ayudarte a controlar el comportamiento del shell usando set. Recomiendo insistentemente estudiar sobre el conjunto incorporado en el manual de Bash.

Utilice parámetros largos al nombrar a otros comandos

Los comandos de Linux pueden resultar confusos porque tienden a utilizar opciones de una sola signo:

        rm -rf filename

    

Con los comandos de uso global, esto es un problema pequeño, pero hay tantos comandos y opciones que seguramente te encontrarás con poco desconocido eventualmente. Las buenas prácticas de programación deben avalar que su script sea fácil, ya sea para otro miembro de su equipo, determinado con quien nunca se haya comunicado o usted mismo en algún momento en el futuro.

Aquí hay un equivalente mucho más fácil del comando susodicho:

        rm --recursive --force filename

    

Muchos comandos modernos, o versiones modernas de los establecidos desde hace mucho tiempo, admiten opciones largas como esta, que comienzan con “–” y son palabras completas en circunstancia de humanidades individuales. No puedes combinarlas como opciones de una sola signo, pero son mucho más legibles.

No debería tener que escribir estas opciones completas cada vez que use un comando si puede rememorar la alternativa más corta. Pero en sus propios scripts de shell, especialmente aquellos que puede compartir con otros, el uso de opciones largas es una forma de código autodocumentado a la que siempre debe aspirar.

Utilice la notación moderna para la sustitución de comandos

En los scripts Bash, hay dos formas de ejecutar un comando y capturar su salida adentro de una variable:

        VAR=$(ls)
VAR2=`ls`

    

Verás uno y otro en uso, entonces, ¿cuál es mejor?

En sinceridad, el enfoque de acento dificultoso está en desuso; es un poco más incómodo por varias razones, como el hecho de que no admite muy aceptablemente el anidamiento. Por lo tanto, prefiera siempre la forma moderna, usando paréntesis.

Fallar títulos predeterminados

Otra parte útil de sintaxis avanzadilla, esta le permite especificar títulos de variables predeterminados sin escribir código adicional para comprobar si hay una esclavitud vacía:

        CMD=${PAGER:-more}

    

En este ejemplo, el valía de $CMD será el valía de la variable de entorno PAGER, si está configurada, y “más” en caso contrario.

Incluso puedes morar títulos predeterminados. Esto le permite convenir un argumento de carrera de comandos, con alternativas para una variable de entorno y luego un valía predeterminado, por ejemplo:

        DIR=${1:-${HOME:-/Users/bobby/home}}
    

Sea manifiesto acerca de las opciones con doble asunto

Así como los espacios en los nombres de archivos pueden ser problemáticos, igualmente lo pueden ser muchos otros caracteres. Un ejemplo clásico es el caso de un archivo con un “-:” al principio.

        echo "nothing much" > -a-silly-filename

    

Puede confirmar la existencia de este archivo enumerando su directorio:

Pero interactuar directamente con el archivo, usando su nombre, causará problemas:

Como la mayoría de los comandos, ls paciencia que un argumento que comience con “-” sea una opción, de ahí el error de “opción no reconocida”. Esto puede parecer un problema trivial, pero empeora mucho si consideras un comando como este:

        rm *

    

Si tiene un archivo en su directorio llamado “-rf”, ¡esto podría provocar un desastre!

Puedes evitar muchos problemas manteniendo los nombres de archivos simples: los nombres az en minúscula sin ningún otro carácter nunca deberían causar un problema. Sin bloqueo, siempre debes programar de guisa defensiva en tus propios scripts y programas para evitar problemas.

La mejor protección contra este tipo de problemas es la sintaxis de “doble asunto”, que se ve así:

        rm -- *.md

    

El doble asunto declara explícitamente que “todo lo que sigue a esto es un argumento”, lo que significa que rm no interpretará ningún nombre de archivo extraño como si fueran opciones.

Utilice variables locales en funciones

Es posible que haya aurícula que las variables globales no son seguras o no se recomiendan. Si aceptablemente la verdad tiene más matices, a menudo es una buena idea evitar las variables globales a menos que efectivamente sepas lo que estás haciendo.

En un script de shell, las variables son globales de forma predeterminada, incluso adentro de funciones:

        #!/bin/bash
function run {
    DIR=`pwd`
    echo "doing something..."
}
DIR="/usr/circunscrito/bin"
run
echo $DIR

    

Es manejable reutilizar accidentalmente el nombre de una variable y olvidar que está cambiando su valía en todo el script, no solo adentro de la función que se está ejecutando. Sin bloqueo, la alternativa es simple: simplemente declararla como una variable circunscrito:

        function run {
    circunscrito DIR=`pwd`
}