¿Por qué #! / Usr / bin / env bash es superior a #! / Bin / bash?

Lo he visto en varios lugares, incluidas las recomendaciones en este sitio ( ¿Cuál es el Bash shebang preferido? ), Para usar #!/usr/bin/env bashcon preferencia #!/bin/bash. Incluso he visto a una persona emprendedora sugerir que el uso #!/bin/bashera incorrecto y que la funcionalidad bash se perdería al hacerlo.

Dicho todo esto, uso bash en un entorno de prueba estrictamente controlado donde cada unidad en circulación es esencialmente un clon de una sola unidad maestra. Entiendo el argumento de la portabilidad, aunque no es necesariamente aplicable en mi caso. ¿Hay alguna otra razón para preferir #!/usr/bin/env basha las alternativas y, suponiendo que la portabilidad fuera una preocupación, hay alguna razón para usarla que podría romper la funcionalidad?

#!/usr/bin/envbúsquedas PATHpara bash, y bashno siempre está en /bin, sobre todo en los sistemas no Linux. Por ejemplo, en mi sistema OpenBSD, está dentro /usr/local/bin, ya que se instaló como un paquete opcional.

Si estás absolutamente seguro bash está /biny siempre lo estará, no hay ningún daño en ponerlo directamente en su shebang, pero lo recomendaría en contra porque los scripts y los programas tienen vidas más allá de lo que inicialmente creemos que tendrán.

La ubicación estándar de bash es /bin , y sospecho que eso es cierto en todos los sistemas. Sin embargo, ¿qué pasa si no te gusta esa versión de bash? Por ejemplo, quiero usar bash 4.2, pero el bash en mi Mac está en 3.2.5.

Podría intentar reinstalar bash /binpero eso puede ser una mala idea. Si actualizo mi sistema operativo, se sobrescribirá.

Sin embargo, podría instalar bash /usr/local/bin/bashy configurar mi RUTA para:

PATH="/usr/local/bin:/bin:/usr/bin:$HOME/bin"

Ahora, si lo especifico bash, no obtengo el viejo y sucio /bin/bash, sino el más nuevo y brillante /usr/local/bin. ¡Agradable!

Excepto que mis scripts de shell tienen ese !# /bin/bashshebang. Por lo tanto, cuando ejecuto mis scripts de shell, obtengo esa versión antigua y pésima de bash que ni siquiera tiene matrices asociativas.

Utilizando /usr/bin/env bash usará la versión de bash que se encuentra en mi RUTA. Si configuro mi RUTA, para que/usr/local/bin/bash se ejecute, esa es la bash que usarán mis scripts.

Es raro ver esto con bash, pero es mucho más común con Perl y Python:

• Ciertas versiones de Unix / Linux que se centran en la estabilidad veces están muy rezagadas con el lanzamiento de estos dos lenguajes de secuencias de comandos. No hace mucho tiempo, Perl de RHEL estaba en 5.8.8, ¡una versión de Perl de ocho años! Si alguien quería usar funciones más modernas, tenía que instalar su propia versión.
• Programas como Perlbrew y Pythonbrew le permiten instalar múltiples versiones de estos idiomas. Dependen de los scripts que manipulan su RUTA para obtener la versión que desea. Codificar el camino significa que no puedo ejecutar mi script en brew .
• No fue hace tanto tiempo (está bien, fue hace mucho tiempo) que Perl y Python no eran paquetes estándar incluidos en la mayoría de los sistemas Unix. Eso significaba que no sabías dónde estaban instalados estos dos programas. ¿Estaba debajo /bin? /usr/bin? /opt/bin? ¿Quién sabe? Usar #! /usr/bin/env perlsignificaba que no tenía que saberlo.

Y ahora por qué no deberías usar #! /usr/bin/env bash

Cuando el camino está codificado en el shebang, tengo que correr con ese intérprete. Por lo tanto, #! /bin/bashme obliga a usar la versión predeterminada instalada de bash. Dado que las características de bash son muy estables (intente ejecutar una versión 2.x de un script de Python en Python 3.x) es muy poco probable que mi script de BASH en particular no funcione, y dado que este script y otros sistemas probablemente utilicen mi script de bash , el uso de una versión no estándar de bash puede tener efectos no deseados. Es muy probable que quiera asegurarme de que la versión estándar estable de bash se use con mi script de shell. Por lo tanto, probablemente quiero codificar la ruta en mi shebang.

Para invocarlo bashes un poco exagerado. A menos que tengas múltiplesbash archivos binarios como el suyo en ~ / bin, pero eso también significa que su código depende de que $ PATH tenga las cosas correctas.

Sin pythonembargo, es útil para cosas como . Hay scripts de envoltura y entornos que conducen a alternativaspython utilización de binarios .

Pero no se pierde nada al usar la ruta exacta al binario siempre que esté seguro de que es el binario que realmente desea.

Hay muchos sistemas que no tienen Bash /bin, FreeBSD y OpenBSD solo por nombrar algunos. Si su script está destinado a ser portátil a muchos Unices diferentes, es posible que desee usar en #!/usr/bin/env bashlugar de#!/bin/bash .

Tenga en cuenta que esto no es cierto para sh; para scripts Bourne conformes I uso exclusivamente #!/bin/sh, ya que creo que casi todos los Unix en la existencia tiene shen /bin.

Preferiría envolver el programa principal en un script como el siguiente para verificar todos los bashdisponibles en el sistema. Es mejor tener más control sobre la versión que usa.

#! /usr/bin/env bash

# This script just chooses the appropriate bash
# installed in system and executes testcode.main

readonly DESIRED_VERSION="5"

declare all_bash_installed_on_this_system
declare bash

if [ "${BASH_VERSINFO}" -ne "${DESIRED_VERSION}" ]
then
    found=0

    all_bash_installed_on_this_system="$(\
        awk -F'/' '$NF == "bash"{print}' "/etc/shells"\
        )"

    for bash in $all_bash_installed_on_this_system
    do
        versinfo="$( $bash -c 'echo ${BASH_VERSINFO}' )"
        [ "${versinfo}" -eq "${DESIRED_VERSION}" ] && { found=1 ; break;}
    done
    if [ "${found}" -ne 1 ]
    then
        echo "${DESIRED_VERSION} not available"
        exit 1
    fi
fi

$bash main_program "$@"

 #!/usr/bin/env bash

definitivamente es mejor porque encuentra la ruta ejecutable bash de la variable de entorno del sistema.

Vaya a su shell de Linux y escriba

env

Imprimirá todas sus variables de entorno.

Vaya a su script de shell y escriba

echo $BASH

Imprimirá su ruta bash (de acuerdo con la lista de variables de entorno) que debe usar para construir su ruta shebang correcta en su script.