¿Hay alguna manera para que un script de shell de origen descubra el camino hacia sí mismo? Me preocupa principalmente bash, aunque tengo algunos compañeros de trabajo que usan tcsh.

Supongo que es posible que no tenga mucha suerte aquí, ya que el abastecimiento hace que los comandos se ejecuten en el shell actual, por $0lo que sigue siendo la invocación del shell actual, no el script de origen. Mi mejor pensamiento actualmente es hacerlo source $script $script, para que el primer parámetro posicional contenga la información necesaria. Alguien tiene una mejor manera?

Para ser claros, estoy buscando el script, no ejecutándolo:

source foo.bash

En tcsh, $_al comienzo de la secuencia de comandos contendrá la ubicación si el archivo se obtuvo y lo $0contiene si se ejecutó.

#!/bin/tcsh
set sourced=($_)
if ("$sourced" != "") then
    echo "sourced $sourced[2]"
endif
if ("$0" != "tcsh") then
    echo "run $0"
endif

En Bash:

#!/bin/bash
[[ $0 != $BASH_SOURCE ]] && echo "Script is being sourced" || echo "Script is being run"

Creo que podrías usar $BASH_SOURCEvariable. Devuelve la ruta que se ejecutó:

pbm@tauri ~ $ /home/pbm/a.sh 
/home/pbm/a.sh
pbm@tauri ~ $ ./a.sh
./a.sh
pbm@tauri ~ $ source /home/pbm/a.sh 
/home/pbm/a.sh
pbm@tauri ~ $ source ./a.sh
./a.sh

Entonces, en el siguiente paso, debemos verificar si la ruta es relativa o no. Si no es relativo, todo está bien. Si es así, podríamos verificar la ruta con pwd, concatenar con /y $BASH_SOURCE.

Por rigor y por el bien de los buscadores, esto es lo que hacen ... Es un wiki de la comunidad, así que siéntase libre de agregar otros equivalentes de shell (obviamente, $ BASH_SOURCE será diferente).

test.sh:

#! /bin/sh
called=$_
echo $called
echo $_
echo $0
echo $BASH_SOURCE

test2.sh:

#! /bin/sh
source ./test.sh

Golpetazo:

$./test2.sh
./test2.sh
./test2.sh
./test2.sh
./test.sh
$ sh ./test2.sh
/bin/sh
/bin/sh
./test2.sh
./test.sh

Guión, correr precipitadamente, precipitarse, ir de prisa

$./test2.sh
./test2.sh
./test2.sh
./test2.sh

$/bin/sh ./test2.sh
/bin/sh
/bin/sh
./test2.sh

$

Zsh

$ ./test2.sh
./test.sh
./test.sh
./test.sh

$ zsh test.sh

echo
test.sh

$

Esta solución se aplica solo a bash y no a tcsh. Tenga en cuenta que la respuesta comúnmente proporcionada ${BASH_SOURCE[0]}no funcionará si intenta encontrar la ruta desde una función.

He encontrado que esta línea siempre funciona, independientemente de si el archivo se obtiene o se ejecuta como un script.

echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}

Si desea seguir el uso de enlaces simbólicos readlinken la ruta que obtiene arriba, recursivamente o no recursivamente.

Aquí hay un script para probarlo y compararlo con otras soluciones propuestas. Invocarlo como source test1/test2/test_script.sho bash test1/test2/test_script.sh.

#
# Location: test1/test2/test_script.sh
#
echo $0
echo $_
echo ${BASH_SOURCE}
echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}

cur_file="${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}"
cur_dir="$(dirname "${cur_file}")"
source "${cur_dir}/func_def.sh"

function test_within_func_inside {
    echo ${BASH_SOURCE}
    echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}
}

echo "Testing within function inside"
test_within_func_inside

echo "Testing within function outside"
test_within_func_outside

#
# Location: test1/test2/func_def.sh
#
function test_within_func_outside {
    echo ${BASH_SOURCE}
    echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}
}

La razón por la que funciona One-liner se explica por el uso de la BASH_SOURCEvariable de entorno y su asociado FUNCNAME.

BASH_SOURCE

Una variable de matriz cuyos miembros son los nombres de los archivos de origen donde se definen los nombres de función de shell correspondientes en la variable de matriz FUNCNAME. La función de shell $ {FUNCNAME [$ i]} se define en el archivo $ {BASH_SOURCE [$ i]} y se llama desde $ {BASH_SOURCE [$ i + 1]}.

FUNCNAME

Una variable de matriz que contiene los nombres de todas las funciones de shell actualmente en la pila de llamadas de ejecución. El elemento con índice 0 es el nombre de cualquier función de shell que se esté ejecutando actualmente. El elemento más inferior (el que tiene el índice más alto) es "principal". Esta variable existe solo cuando se ejecuta una función de shell. Las asignaciones a FUNCNAME no tienen efecto y devuelven un estado de error. Si FUNCNAME no está configurado, pierde sus propiedades especiales, incluso si posteriormente se restablece.

Esta variable se puede usar con BASH_LINENO y BASH_SOURCE. Cada elemento de FUNCNAME tiene elementos correspondientes en BASH_LINENO y BASH_SOURCE para describir la pila de llamadas. Por ejemplo, $ {FUNCNAME [$ i]} se llamó desde el archivo $ {BASH_SOURCE [$ i + 1]} en el número de línea $ {BASH_LINENO [$ i]}. La persona que llama muestra la pila de llamadas actual utilizando esta información.

[Fuente: manual de Bash]

Esto funcionó para mí en bash, dash, ksh y zsh:

if test -n "$BASH" ; then script=$BASH_SOURCE
elif test -n "$TMOUT"; then script=${.sh.file}
elif test -n "$ZSH_NAME" ; then script=${(%):-%x}
elif test ${0##*/} = dash; then x=$(lsof -p $$ -Fn0 | tail -1); script=${x#n}
else script=$0
fi

echo $script

Salida para estos proyectiles:

BASH source: ./myscript
ZSH source: ./myscript
KSH source: /home/pbrannan/git/theme/src/theme/web/myscript
DASH source: /home/pbrannan/git/theme/src/theme/web/myscript
BASH: ./myscript
ZSH: ./myscript
KSH: /home/pbrannan/git/theme/src/theme/web/myscript
DASH: ./myscript

Traté de hacerlo funcionar para csh / tcsh, pero es demasiado difícil; Me estoy quedando con POSIX.

Estaba un poco confundido por la respuesta wiki de la comunidad (de Shawn J. Goff), así que escribí un guión para resolver las cosas. Acerca de $_, encontré esto: Uso de _como una variable de entorno pasada a un comando . Es una variable de entorno, por lo que es fácil probar su valor incorrectamente.

A continuación se muestra el script, luego es salida. También están en esta esencia .

test-shell-default-variables.sh

#!/bin/bash

# test-shell-default-variables.sh

# Usage examples (you might want to `sudo apt install zsh ksh`):
#
#  ./test-shell-default-variables.sh dash bash
#  ./test-shell-default-variables.sh dash bash zsh ksh
#  ./test-shell-default-variables.sh dash bash zsh ksh | less -R

# `-R` in `less -R` to have less pass escape sequences directly to the terminal
# so we have colors.


# The "invoking with name `sh`" tests are commented because for every shell I
# tested (dash, bash, zsh and ksh), the output was the same as that of dash.

# The `test_expression` function also work with expansion changes. You can try
# lines like `test_expression '{BASH_SOURCE:-$0}'`.

echolor() {
    echo -e "\e[1;36m$@\e[0m"
}

tell_file() {
    echo File \`"$1"\` is:
    echo \`\`\`
    cat "$1"
    echo \`\`\`
    echo
}

SHELL_ARRAY=("$@")

test_command() {
    for shell in "${SHELL_ARRAY[@]}"
    do
        prepare "$shell"
        cmd="$(eval echo $1)"
        # echo "cmd: $cmd"
        printf '%-4s: ' "$shell"
        { env -i $cmd 2>&1 1>&3 | sed 's/^/[err]/'; } 3>&1
        teardown
    done
    echo
}

prepare () {
    shell="$1"
    PATH="$PWD/$shell/sh:$PATH"
}

teardown() {
    PATH="${PATH#*:}"
}


###
### prepare
###
for shell in "${SHELL_ARRAY[@]}"
do
    mkdir "$shell"
    ln -sT "/bin/$shell" "$shell/sh"
done

echo > printer.sh
echo '. ./printer.sh' > sourcer.sh
rm linked.sh &>/dev/null; ln -sT "printer.sh" "linked.sh"

tell_file sourcer.sh

###
### run
###
test_expression() {
    local expr="$1"

    # prepare
    echo "echo $expr" > printer.sh
    tell_file printer.sh

    # run
    cmd='$shell ./printer.sh'
    echolor "\`$cmd\` (simple invocation) ($expr):"
    test_command "$cmd"

    # cmd='sh ./printer.sh'
    # echolor "\`$cmd\` (when executable name is \`sh\`) ($expr):"
    # test_command "$cmd"

    cmd='$shell ./sourcer.sh'
    echolor "\`$cmd\` (via sourcing) ($expr):"
    test_command "$cmd"

    # cmd='sh ./sourcer.sh'
    # echolor "\`$cmd\` (via sourcing, when name is \`sh\`) ($expr):"
    # test_command "$cmd"

    cmd='$shell ./linked.sh'
    echolor "\`$cmd\` (via symlink) ($expr):"
    test_command "$cmd"

    # cmd='sh ./linked.sh'
    # echolor "\`$cmd\` (via symlink, when name is \`sh\`) ($expr):"
    # test_command "$cmd"

    echolor "------------------------------------------"
    echo
}

test_expression '$BASH_SOURCE'
test_expression '$0'
test_expression '$(/bin/true x y; true a b c; echo $_)' # Rq: true is a builtin
test_expression '$_'

###
### teardown
###
for shell in "${SHELL_ARRAY[@]}"
do
    rm "$shell/sh"
    rm -d "$shell"
done

rm sourcer.sh
rm linked.sh
rm printer.sh

Salida de ./test-shell-default-variables.sh {da,ba,z,k}sh

File `sourcer.sh` is:
```
. ./printer.sh
```

File `printer.sh` is:
```
echo $BASH_SOURCE
```

`$shell ./printer.sh` (simple invocation) ($BASH_SOURCE):
dash: 
bash: ./printer.sh
zsh : 
ksh : 

`$shell ./sourcer.sh` (via sourcing) ($BASH_SOURCE):
dash: 
bash: ./printer.sh
zsh : 
ksh : 

`$shell ./linked.sh` (via symlink) ($BASH_SOURCE):
dash: 
bash: ./linked.sh
zsh : 
ksh : 

------------------------------------------

File `printer.sh` is:
```
echo $0
```

`$shell ./printer.sh` (simple invocation) ($0):
dash: ./printer.sh
bash: ./printer.sh
zsh : ./printer.sh
ksh : ./printer.sh

`$shell ./sourcer.sh` (via sourcing) ($0):
dash: ./sourcer.sh
bash: ./sourcer.sh
zsh : ./printer.sh
ksh : ./sourcer.sh

`$shell ./linked.sh` (via symlink) ($0):
dash: ./linked.sh
bash: ./linked.sh
zsh : ./linked.sh
ksh : ./linked.sh

------------------------------------------

File `printer.sh` is:
```
echo $(/bin/true x y; true a b c; echo $_)
```

`$shell ./printer.sh` (simple invocation) ($(/bin/true x y; true a b c; echo $_)):
dash: 
bash: c
zsh : c
ksh : 

`$shell ./sourcer.sh` (via sourcing) ($(/bin/true x y; true a b c; echo $_)):
dash: 
bash: c
zsh : c
ksh : 

`$shell ./linked.sh` (via symlink) ($(/bin/true x y; true a b c; echo $_)):
dash: 
bash: c
zsh : c
ksh : 

------------------------------------------

File `printer.sh` is:
```
echo $_
```

`$shell ./printer.sh` (simple invocation) ($_):
dash: 
bash: bash
zsh : 
ksh : 

`$shell ./sourcer.sh` (via sourcing) ($_):
dash: 
bash: bash
zsh : ./printer.sh
ksh : 

`$shell ./linked.sh` (via symlink) ($_):
dash: 
bash: bash
zsh : 
ksh : 

------------------------------------------

Que aprendimos

$BASH_SOURCE

• $BASH_SOURCE funciona en bash y solo en bash.
• La única diferencia con $0es cuando el archivo actual fue originado por otro archivo. En ese caso, $BASH_PROFILEcontiene el nombre del archivo de origen, en lugar del nombre del archivo de origen.

$0

• En zsh, $0tiene el mismo valor que $BASH_SOURCEen bash.

$_

• $_ se deja sin tocar por guión y ksh.
• En bash y zsh, $_decae al último argumento de la última llamada.
• bash se inicializa $_a "bash".
• zsh deja $_sin tocar. (cuando se busca, es solo el resultado de la regla del "último argumento").

Enlaces simbólicos

• Cuando se llama a un script a través de un enlace simbólico, ninguna variable contiene ninguna referencia al destino del enlace, solo su nombre.

ksh

• Con respecto a esas pruebas, ksh se comporta como un guión.

sh

• Cuando se llama a bash o zsh a través de un enlace simbólico llamado sh, con respecto a esas pruebas, se comporta como un guión.

Para el bash shell, encontré la respuesta de @Dennis Williamson más útil, pero no funcionó en el caso de sudo. Esto hace:

if ( [[ $_ != $0 ]] && [[ $_ != $SHELL ]] ); then
    echo "I'm being sourced!"
    exit 1
fi

Para hacer que su script sea compatible con bash y zsh en lugar de usar sentencias if, simplemente puede escribir ${BASH_SOURCE[0]:-${(%):-%x}}. El valor resultante se tomará de BASH_SOURCE[0]cuando está definido y ${(%):-%x}}cuando BASH_SOURCE [0] no está definido.

tl; dr script=$(readlink -e -- "${BASH_SOURCE}") (para bash obviamente)

$BASH_SOURCE Casos de prueba

archivo dado /tmp/source1.sh

echo '$BASH_SOURCE '"(${BASH_SOURCE})"
echo 'readlink -e $BASH_SOURCE'\
     "($(readlink -e -- "${BASH_SOURCE}"))"

source el archivo de diferentes maneras

source de /tmp

$> cd /tmp

$> source source1.sh
$BASH_SOURCE (source1.sh)
readlink -e $BASH_SOURCE (/tmp/source1.sh)

$> source ./source1.sh
$BASH_SOURCE (./source1.sh)
readlink -e $BASH_SOURCE (/tmp/source1.sh)

$> source /tmp/source1.sh
$BASH_SOURCE (/tmp/source1.sh)
readlink -e $BASH_SOURCE (/tmp/source1.sh)

source de /

cd /
$> source /tmp/source1.sh
$0 (bash)
$BASH_SOURCE (/tmp/source1.sh)
readlink -e $BASH_SOURCE (/tmp/source1.sh)

sourcede diferentes caminos relativos /tmp/ay/var

$> cd /tmp/a

$> source ../source1.sh
$BASH_SOURCE (../source1.sh)
readlink -e $BASH_SOURCE (/tmp/source1.sh)

$> cd /var

$> source ../tmp/source1.sh
$BASH_SOURCE (../tmp/source1.sh)
readlink -e $BASH_SOURCE (/tmp/source1.sh)

respecto a $0

en todos los casos, si el script tenía el comando agregado

echo '$0 '"(${0})"

entonces sourceel guión siempre se imprime

$0 (bash)

sin embargo , si se ejecutó el script , por ej.

$> bash /tmp/source1.sh

entonces $0sería un valor de cadena /tmp/source1.sh.

$0 (/tmp/source1.sh)
$BASH_SOURCE (/tmp/source1.sh)
readlink -e $BASH_SOURCE (/tmp/source1.sh)

esta respuesta describe cómo lsofy un poco de magia grep es lo único que parece tener posibilidades de funcionar para archivos de origen anidados en tcsh:

/usr/sbin/lsof +p $$ | grep -oE /.\*source_me.tcsh

wdir="$PWD"; [ "$PWD" = "/" ] && wdir=""
case "$0" in
  /*) scriptdir="${0%/*}";;
  *) scriptdir="$wdir/${0#./}"; scriptdir="${scriptdir%/*}";;
esac
echo "$scriptdir"

Tal vez esto no funcione con enlaces simbólicos o archivos de origen, pero funcionará para archivos normales. Tomado como referencia para. @kenorb Sin nombre de directorio, enlace de lectura, BASH_SOURCE.

En realidad, "dirname $ 0" te dará la ruta al script, pero debes interpretarlo un poco:

$ cat bash0
#!/bin/bash
echo \$0=$0
dirname $0
$ bash0    # "." appears in PATH right now.
$0=./bash0
.
$ ./bash0
$0=./bash0
.
$ $PWD/bash0
$0=/home/00/bediger/src/ksh/bash0
/home/00/bediger/src/ksh
$ $PWD/../ksh/bash0
$0=/home/00/bediger/src/ksh/../ksh/bash0
/home/00/bediger/src/ksh/../ksh
$ ../ksh/bash0
$0=../ksh/bash0
../ksh

Tienes que prepararte para manejar "." como el nombre del directorio en algunas circunstancias comunes. Experimentaría un poco, ya que recuerdo el nombre de directorio incorporado en ksh haciendo las cosas de manera un poco diferente cuando "." aparece en RUTA.