Obtenga el directorio fuente de un script Bash desde el propio script

https://stackoverflow.com/questions/59895

09-06-2019
|

Pregunta

¿Cómo obtengo la ruta del directorio en el que se encuentra un Intento se encuentra el guión, adentro ese guión?

Por ejemplo, digamos que quiero usar un script Bash como iniciador de otra aplicación.Quiero cambiar el directorio de trabajo al que está ubicado el script Bash, para poder operar con los archivos en ese directorio, así:

$ ./application

Solución

#!/bin/bash

DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"

es una frase útil que le proporcionará el nombre completo del directorio del script sin importar desde dónde se llame.

Funcionará siempre que el último componente de la ruta utilizada para encontrar el script no sea un enlace simbólico (los enlaces a directorios están bien).Si también desea resolver cualquier enlace al script en sí, necesita una solución de varias líneas:

#!/bin/bash

SOURCE="${BASH_SOURCE[0]}"
while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"
  SOURCE="$(readlink "$SOURCE")"
  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
done
DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"

Este último funcionará con cualquier combinación de alias, source, bash -c, enlaces simbólicos, etc.

Tener cuidado:si usted cd a un directorio diferente antes de ejecutar este fragmento, ¡el resultado puede ser incorrecto!

Además, tenga cuidado con $CDPATH trampas, y efectos secundarios de salida de stderr si el usuario ha anulado inteligentemente cd para redirigir la salida a stderr (incluidas secuencias de escape, como cuando se llama update_terminal_cwd >&2 en Mac).Añadiendo >/dev/null 2>&1 al final de tu cd El comando se encargará de ambas posibilidades.

Para entender cómo funciona, intente ejecutar esta forma más detallada:

#!/bin/bash

SOURCE="${BASH_SOURCE[0]}"
while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  TARGET="$(readlink "$SOURCE")"
  if [[ $TARGET == /* ]]; then
    echo "SOURCE '$SOURCE' is an absolute symlink to '$TARGET'"
    SOURCE="$TARGET"
  else
    DIR="$( dirname "$SOURCE" )"
    echo "SOURCE '$SOURCE' is a relative symlink to '$TARGET' (relative to '$DIR')"
    SOURCE="$DIR/$TARGET" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
  fi
done
echo "SOURCE is '$SOURCE'"
RDIR="$( dirname "$SOURCE" )"
DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"
if [ "$DIR" != "$RDIR" ]; then
  echo "DIR '$RDIR' resolves to '$DIR'"
fi
echo "DIR is '$DIR'"

Y imprimirá algo como:

SOURCE './scriptdir.sh' is a relative symlink to 'sym2/scriptdir.sh' (relative to '.')
SOURCE is './sym2/scriptdir.sh'
DIR './sym2' resolves to '/home/ubuntu/dotfiles/fo fo/real/real1/real2'
DIR is '/home/ubuntu/dotfiles/fo fo/real/real1/real2'

Otros consejos

Usar dirname "$0":

#!/bin/bash
echo "The script you are running has basename `basename "$0"`, dirname `dirname "$0"`"
echo "The present working directory is `pwd`"

usando pwd por sí solo no funcionará si no ejecuta el script desde el directorio en el que se encuentra.

[matt@server1 ~]$ pwd
/home/matt
[matt@server1 ~]$ ./test2.sh
The script you are running has basename test2.sh, dirname .
The present working directory is /home/matt
[matt@server1 ~]$ cd /tmp
[matt@server1 tmp]$ ~/test2.sh
The script you are running has basename test2.sh, dirname /home/matt
The present working directory is /tmp

El comando dirname es el más básico, simplemente analiza la ruta hasta el nombre del archivo de la variable $0 (nombre del script):

dirname "$0"

Pero como mate b Como se señaló, la ruta devuelta es diferente dependiendo de cómo se llame el script.pwd no hace el trabajo porque eso solo le dice cuál es el directorio actual, no en qué directorio reside el script.Además, si se ejecuta un enlace simbólico a un script, obtendrá una ruta (probablemente relativa) hacia donde reside el enlace, no el script real.

Algunos otros han mencionado la enlace de lectura comando, pero en su forma más simple, puedes usar:

dirname "$(readlink -f "$0")"

readlink resolverá la ruta del script a una ruta absoluta desde la raíz del sistema de archivos.Por lo tanto, cualquier ruta que contenga puntos simples o dobles, tildes y/o enlaces simbólicos se resolverá en una ruta completa.

Aquí hay un guión que demuestra cada uno de estos, whatdir.sh:

#!/bin/bash
echo "pwd: `pwd`"
echo "\$0: $0"
echo "basename: `basename $0`"
echo "dirname: `dirname $0`"
echo "dirname/readlink: $(dirname $(readlink -f $0))"

Ejecutando este script en mi directorio de inicio, usando una ruta relativa:

>>>$ ./whatdir.sh 
pwd: /Users/phatblat
$0: ./whatdir.sh
basename: whatdir.sh
dirname: .
dirname/readlink: /Users/phatblat

Nuevamente, pero usando la ruta completa al script:

>>>$ /Users/phatblat/whatdir.sh 
pwd: /Users/phatblat
$0: /Users/phatblat/whatdir.sh
basename: whatdir.sh
dirname: /Users/phatblat
dirname/readlink: /Users/phatblat

Ahora cambiando de directorio:

>>>$ cd /tmp
>>>$ ~/whatdir.sh 
pwd: /tmp
$0: /Users/phatblat/whatdir.sh
basename: whatdir.sh
dirname: /Users/phatblat
dirname/readlink: /Users/phatblat

Y finalmente usando un enlace simbólico para ejecutar el script:

>>>$ ln -s ~/whatdir.sh whatdirlink.sh
>>>$ ./whatdirlink.sh 
pwd: /tmp
$0: ./whatdirlink.sh
basename: whatdirlink.sh
dirname: .
dirname/readlink: /Users/phatblat

pushd . > /dev/null
SCRIPT_PATH="${BASH_SOURCE[0]}"
if ([ -h "${SCRIPT_PATH}" ]); then
  while([ -h "${SCRIPT_PATH}" ]); do cd `dirname "$SCRIPT_PATH"`; 
  SCRIPT_PATH=`readlink "${SCRIPT_PATH}"`; done
fi
cd `dirname ${SCRIPT_PATH}` > /dev/null
SCRIPT_PATH=`pwd`;
popd  > /dev/null

Funciona para todas las versiones, incluidas

cuando se llama a través de un enlace suave de múltiples profundidades,
cuando el archivo
cuando el script es llamado por comando "source" también conocido como . Operador (punto).
cuando arg $0 se modifica de la persona que llama.
"./script"
"/full/path/to/script"
"/some/path/../../another/path/script"
"./some/folder/script"

Alternativamente, si el script bash en sí es un enlace simbólico relativo tú desear para seguirlo y devolver la ruta completa del script vinculado:

pushd . > /dev/null
SCRIPT_PATH="${BASH_SOURCE[0]}";
if ([ -h "${SCRIPT_PATH}" ]) then
  while([ -h "${SCRIPT_PATH}" ]) do cd `dirname "$SCRIPT_PATH"`; SCRIPT_PATH=`readlink "${SCRIPT_PATH}"`; done
fi
cd `dirname ${SCRIPT_PATH}` > /dev/null
SCRIPT_PATH=`pwd`;
popd  > /dev/null

SCRIPT_PATH se da en su totalidad, sin importar cómo se llame.
Solo asegúrese de ubicarlo al comienzo del script.

Este comentario y código Copyleft, licencia seleccionable bajo GPL2.0 o posterior o CC-SA 3.0 (CreativeCommons Share Alike) o posterior.c) 2008.Reservados todos los derechos.Sin garantía de ningún tipo.Usted ha sido advertido.
http://www.gnu.org/licenses/gpl-2.0.txt
http://creativecommons.org/licenses/by-sa/3.0/
18eedfe1c99df68dc94d4a94712a71aaa8e1e9e36cacf421b9463dd2bbaa02906d0d6656

Respuesta corta:

`dirname $0`

o (preferiblemente):

$(dirname "$0")

Puedes usar $BASH_SOURCE

#!/bin/bash

scriptdir=`dirname "$BASH_SOURCE"`

Tenga en cuenta que necesita usar #!/bin/bash y no #!/bin/sh ya que es una extensión de bash

Esto debería hacerlo:

DIR=$(dirname "$(readlink -f "$0")")

Funciona con enlaces simbólicos y espacios en la ruta.Consulte las páginas de manual para nombre de directorio y enlace de lectura.

Editar:

Según la pista de comentarios, parece que no funciona con Mac OS.No tengo idea de por qué es eso.¿Alguna sugerencia?

pwd se puede utilizar para encontrar el directorio de trabajo actual y dirname para encontrar el directorio de un archivo en particular (el comando que se ejecutó, es $0, entonces dirname $0 debería darle el directorio del script actual).

Sin embargo, dirname proporciona precisamente la parte del directorio del nombre del archivo, que lo más probable es que sea relativa al directorio de trabajo actual.Si su secuencia de comandos necesita cambiar de directorio por algún motivo, entonces la salida de dirname pierde sentido.

Sugiero lo siguiente:

#!/bin/bash

reldir=`dirname $0`
cd $reldir
directory=`pwd`

echo "Directory is $directory"

De esta manera, obtendrá un directorio absoluto, en lugar de relativo.

Dado que el script se ejecutará en una instancia de bash separada, no es necesario restaurar el directorio de trabajo después, pero si desea volver a cambiar el script por algún motivo, puede asignar fácilmente el valor de pwd a una variable antes de cambiar de directorio, para uso futuro.

aunque solo

cd `dirname $0`

resuelve el escenario específico de la pregunta, encuentro que tener la ruta absoluta hacia más es más útil en general.

No creo que esto sea tan fácil como otros han dicho.pwd no funciona, ya que el directorio actual no es necesariamente el directorio con el script.$0 tampoco siempre tiene la información.Considere las siguientes tres formas de invocar un script.

./script

/usr/bin/script

script

En la primera y tercera forma, $0 no tiene la información de ruta completa.En el segundo y tercero, pwd no funciona.La única forma de obtener el directorio de la tercera manera sería recorrer la ruta y encontrar el archivo con la coincidencia correcta.Básicamente, el código tendría que rehacer lo que hace el sistema operativo.

Una forma de hacer lo que está pidiendo sería simplemente codificar los datos en el directorio /usr/share y hacer referencia a ellos por la ruta completa.Los datos no deberían estar en el directorio /usr/bin de todos modos, por lo que probablemente esto sea lo que hay que hacer.

SCRIPT_DIR=$( cd ${0%/*} && pwd -P )

Esto obtiene el directorio de trabajo actual en Mac OS X 10.6.6:

DIR=$(cd "$(dirname "$0")"; pwd)

$(dirname "$(readlink -f "$BASH_SOURCE")")

Estoy cansado de visitar esta página una y otra vez para copiar y pegar la frase breve en la respuesta aceptada.El problema con esto es que no es fácil de entender y recordar.

Aquí hay un guión fácil de recordar:

DIR=$(dirname "${BASH_SOURCE[0]}")  # get the directory name
DIR=$(realpath "${DIR}")    # resolve its full path if need be

Esto es específico de Linux, pero puedes usar:

SELF=$(readlink /proc/$$/fd/255)

Aquí hay una sola línea compatible con POSIX:

SCRIPT_PATH=`dirname "$0"`; SCRIPT_PATH=`eval "cd \"$SCRIPT_PATH\" && pwd"`

# test
echo $SCRIPT_PATH

Probé cada uno de estos y ninguno funcionó.Uno estaba muy cerca pero tenía un pequeño insecto que lo rompió gravemente;se olvidaron de poner el camino entre comillas.

Además, mucha gente asume que está ejecutando el script desde un shell, así que olvide que cuando abre un nuevo script, el valor predeterminado es su inicio.

Pruebe este directorio para ver el tamaño:

/var/Nadie/Pensamiento/Acerca de que los espacios están/En un directorio/Nombre/Y aquí está su archivo.text

Esto lo hace bien independientemente de cómo o dónde lo ejecute.

#!/bin/bash
echo "pwd: `pwd`"
echo "\$0: $0"
echo "basename: `basename "$0"`"
echo "dirname: `dirname "$0"`"

Entonces, para que sea realmente útil, aquí se explica cómo cambiar al directorio del script en ejecución:

cd "`dirname "$0"`"

Espero que ayude

Aquí está la forma sencilla y correcta:

actual_path=$(readlink -f "${BASH_SOURCE[0]}")
script_dir=$(dirname "$actual_path")

Explicación:

${BASH_SOURCE[0]} - la ruta completa al script.El valor de esto será correcto incluso cuando se obtenga el script, p. source <(echo 'echo $0') huellas dactilares intento, reemplazándolo por ${BASH_SOURCE[0]} imprimirá la ruta completa del script.(Por supuesto, esto supone que está bien depender de Bash).
readlink -f - Resuelve recursivamente cualquier enlace simbólico en la ruta especificada.Esta es una extensión GNU y no está disponible en (por ejemplo) sistemas BSD.Si estás ejecutando una Mac, puedes usar Homebrew para instalar GNU coreutils y reemplazar esto con greadlink -f.
Y por supuesto dirname Obtiene el directorio principal de la ruta.

Yo usaría algo como esto:

# retrieve the full pathname of the called script
scriptPath=$(which $0)

# check whether the path is a link or not
if [ -L $scriptPath ]; then

    # it is a link then retrieve the target path and get the directory name
    sourceDir=$(dirname $(readlink -f $scriptPath))

else

    # otherwise just get the directory name of the script path
    sourceDir=$(dirname $scriptPath)

fi

Una ligera revisión de la solución e-satis y 3bcdnlklvc04a señalada en su respuesta

SCRIPT_DIR=''
pushd "$(dirname "$(readlink -f "$BASH_SOURCE")")" > /dev/null && {
    SCRIPT_DIR="$PWD"
    popd > /dev/null
}

Esto debería seguir funcionando en todos los casos que enumeraron.

EDITAR:prevenir popd después de un pushd fallido, gracias a konsolebox

#!/bin/sh
PRG="$0"

# need this for relative symlinks
while [ -h "$PRG" ] ; do
   PRG=`readlink "$PRG"`
done

scriptdir=`dirname "$PRG"`

$_ Vale la pena mencionarlo como alternativa a $0.Si está ejecutando un script desde bash, la respuesta aceptada se puede acortar a:

DIR="$( dirname "$_" )"

Tenga en cuenta que esta tiene que ser la primera declaración en su guión.

He comparado muchas de las respuestas dadas y he encontrado algunas soluciones más compactas.Estos parecen manejar todos los casos extremos locos que surgen de su combinación favorita de:

Caminos absolutos o caminos relativos
Enlaces suaves de archivos y directorios
Invocación como script, bash script, bash -c script, source script, o . script
Espacios, tabulaciones, nuevas líneas, Unicode, etc.en directorios y/o nombre de archivo
Nombres de archivos que comienzan con un guión

Si estás ejecutando desde Linux, parece que usar el proc handle es la mejor solución para localizar la fuente completamente resuelta del script que se está ejecutando actualmente (en una sesión interactiva, el enlace apunta al respectivo /dev/pts/X):

resolved="$(readlink /proc/$$/fd/255 && echo X)" && resolved="${resolved%$'\nX'}"

Esto tiene un poco de fealdad, pero la solución es compacta y fácil de entender.No estamos usando primitivas de bash únicamente, pero estoy de acuerdo con eso porque readlink simplifica considerablemente la tarea.El echo X agrega un X hasta el final de la cadena variable para que no se consuma cualquier espacio en blanco al final del nombre del archivo, y la sustitución del parámetro ${VAR%X} al final de la línea se deshace del X.Porque readlink agrega una nueva línea propia (que normalmente se consumiría en la sustitución del comando si no fuera por nuestro truco anterior), también tenemos que deshacernos de eso.Esto se logra más fácilmente usando el $'' esquema de cotización, que nos permite utilizar secuencias de escape como \n para representar nuevas líneas (así es también como puedes crear fácilmente directorios y archivos con nombres tortuosos).

Lo anterior debería cubrir sus necesidades para localizar el script que se está ejecutando actualmente en Linux, pero si no tiene el proc sistema de archivos a su disposición, o si está intentando localizar la ruta completamente resuelta de algún otro archivo, entonces tal vez el siguiente código le resulte útil.Es solo una ligera modificación del comentario anterior.Si estás jugando con directorios/nombres de archivos extraños, verifica el resultado con ambos ls y readlink es informativo, ya que ls generará rutas "simplificadas", sustituyendo ? para cosas como nuevas líneas.

absolute_path=$(readlink -e -- "${BASH_SOURCE[0]}" && echo x) && absolute_path=${absolute_path%?x}
dir=$(dirname -- "$absolute_path" && echo x) && dir=${dir%?x}
file=$(basename -- "$absolute_path" && echo x) && file=${file%?x}

ls -l -- "$dir/$file"
printf '$absolute_path: "%s"\n' "$absolute_path"

Intenta usar:

real=$(realpath $(dirname $0))

Para sistemas que tienen readlink de GNU coreutils (por ejemplo.Linux):

$(readlink -f "$(dirname "$0")")

No es necesario utilizar BASH_SOURCE cuando $0 contiene el nombre del archivo del script.

Entonces...Creo que tengo este.Llegué tarde a la fiesta, pero creo que algunos apreciarán estar aquí si se topan con este hilo.Los comentarios deben explicar.

#!/bin/sh # dash bash ksh # !zsh (issues). G. Nixon, 12/2013. Public domain.

## 'linkread' or 'fullpath' or (you choose) is a little tool to recursively
## dereference symbolic links (ala 'readlink') until the originating file
## is found. This is effectively the same function provided in stdlib.h as
## 'realpath' and on the command line in GNU 'readlink -f'.

## Neither of these tools, however, are particularly accessible on the many
## systems that do not have the GNU implementation of readlink, nor ship
## with a system compiler (not to mention the requisite knowledge of C).

## This script is written with portability and (to the extent possible, speed)
## in mind, hence the use of printf for echo and case statements where they
## can be substituded for test, though I've had to scale back a bit on that.

## It is (to the best of my knowledge) written in standard POSIX shell, and
## has been tested with bash-as-bin-sh, dash, and ksh93. zsh seems to have
## issues with it, though I'm not sure why; so probably best to avoid for now.

## Particularly useful (in fact, the reason I wrote this) is the fact that
## it can be used within a shell script to find the path of the script itself.
## (I am sure the shell knows this already; but most likely for the sake of
## security it is not made readily available. The implementation of "$0"
## specificies that the $0 must be the location of **last** symbolic link in
## a chain, or wherever it resides in the path.) This can be used for some
## ...interesting things, like self-duplicating and self-modifiying scripts.

## Currently supported are three errors: whether the file specified exists
## (ala ENOENT), whether its target exists/is accessible; and the special
## case of when a sybolic link references itself "foo -> foo": a common error
## for beginners, since 'ln' does not produce an error if the order of link
## and target are reversed on the command line. (See POSIX signal ELOOP.)

## It would probably be rather simple to write to use this as a basis for
## a pure shell implementation of the 'symlinks' util included with Linux.

## As an aside, the amount of code below **completely** belies the amount
## effort it took to get this right -- but I guess that's coding for you.

##===-------------------------------------------------------------------===##

for argv; do :; done # Last parameter on command line, for options parsing.

## Error messages. Use functions so that we can sub in when the error occurs.

recurses(){ printf "Self-referential:\n\t$argv ->\n\t$argv\n" ;}
dangling(){ printf "Broken symlink:\n\t$argv ->\n\t"$(readlink "$argv")"\n" ;}
errnoent(){ printf "No such file: "$@"\n" ;} # Borrow a horrible signal name.

# Probably best not to install as 'pathfull', if you can avoid it.

pathfull(){ cd "$(dirname "$@")"; link="$(readlink "$(basename "$@")")"

## 'test and 'ls' report different status for bad symlinks, so we use this.

 if [ ! -e "$@" ]; then if $(ls -d "$@" 2>/dev/null) 2>/dev/null;  then
    errnoent 1>&2; exit 1; elif [ ! -e "$@" -a "$link" = "$@" ];   then
    recurses 1>&2; exit 1; elif [ ! -e "$@" ] && [ ! -z "$link" ]; then
    dangling 1>&2; exit 1; fi
 fi

## Not a link, but there might be one in the path, so 'cd' and 'pwd'.

 if [ -z "$link" ]; then if [ "$(dirname "$@" | cut -c1)" = '/' ]; then
   printf "$@\n"; exit 0; else printf "$(pwd)/$(basename "$@")\n"; fi; exit 0
 fi

## Walk the symlinks back to the origin. Calls itself recursivly as needed.

 while [ "$link" ]; do
   cd "$(dirname "$link")"; newlink="$(readlink "$(basename "$link")")"
   case "$newlink" in
    "$link") dangling 1>&2 && exit 1                                       ;;
         '') printf "$(pwd)/$(basename "$link")\n"; exit 0                 ;;
          *) link="$newlink" && pathfull "$link"                           ;;
   esac
 done
 printf "$(pwd)/$(basename "$newlink")\n"
}

## Demo. Install somewhere deep in the filesystem, then symlink somewhere 
## else, symlink again (maybe with a different name) elsewhere, and link
## back into the directory you started in (or something.) The absolute path
## of the script will always be reported in the usage, along with "$0".

if [ -z "$argv" ]; then scriptname="$(pathfull "$0")"

# Yay ANSI l33t codes! Fancy.
 printf "\n\033[3mfrom/as: \033[4m$0\033[0m\n\n\033[1mUSAGE:\033[0m   "
 printf "\033[4m$scriptname\033[24m [ link | file | dir ]\n\n         "
 printf "Recursive readlink for the authoritative file, symlink after "
 printf "symlink.\n\n\n         \033[4m$scriptname\033[24m\n\n        "
 printf " From within an invocation of a script, locate the script's "
 printf "own file\n         (no matter where it has been linked or "
 printf "from where it is being called).\n\n"

else pathfull "$@"
fi

Pruebe la siguiente solución de compatibilidad cruzada:

CWD="$(cd -P -- "$(dirname -- "$0")" && pwd -P)"

como realpath o readlink Los comandos no siempre están disponibles (dependiendo del sistema operativo) y ${BASH_SOURCE[0]} sólo está disponible en bash shell.

Alternativamente, puedes probar la siguiente función en bash:

realpath () {
  [[ $1 = /* ]] && echo "$1" || echo "$PWD/${1#./}"
}

Esta función toma 1 argumento.Si el argumento ya tiene una ruta absoluta, imprímalo como está; de lo contrario, imprima $PWD variable + argumento de nombre de archivo (sin ./ prefijo).

Relacionado:

Hmm, si en el camino Basename & Dirname simplemente no va a cortarlo y caminar por el camino es difícil (¡qué pasa si los padres no exportaron el camino!).Sin embargo, el caparazón tiene que tener un mango abierto a su script, y en Bash el mango es #255.

SELF=`readlink /proc/$$/fd/255`

funciona para mi.

Para resumir muchas respuestas:

    Script: "/tmp/src dir/test.sh"
    Calling folder: "/tmp/src dir/other"

Comandos usados

    echo Script-Dir : `dirname "$(realpath $0)"`
    echo Script-Dir : $( cd ${0%/*} && pwd -P )
    echo Script-Dir : $(dirname "$(readlink -f "$0")")
    echo
    echo Script-Name : `basename "$(realpath $0)"`
    echo Script-Name : `basename $0`
    echo
    echo Script-Dir-Relative : `dirname "$BASH_SOURCE"`
    echo Script-Dir-Relative : `dirname $0`
    echo
    echo Calling-Dir : `pwd`

La salida:

     Script-Dir : /tmp/src dir
     Script-Dir : /tmp/src dir
     Script-Dir : /tmp/src dir

     Script-Name : test.sh
     Script-Name : test.sh

     Script-Dir-Relative : ..
     Script-Dir-Relative : ..

     Calling-Dir : /tmp/src dir/other

Verhttps://pastebin.com/J8KjxrPF

Esto funciona en bash-3.2:

path="$( dirname "$( which "$0" )" )"

A continuación se muestra un ejemplo de su uso:

Di que tienes un ~/contenedor directorio, que está en su $RUTA.tienes guión A dentro de este directorio.Él fuenteguión ~/bin/lib/B.Sabes dónde está el script incluido en relación con el original (el subdirectorio biblioteca), pero no en relación con el directorio actual del usuario.

Esto se resuelve de la siguiente manera (dentro A):

source "$( dirname "$( which "$0" )" )/lib/B"

No importa dónde esté el usuario o cómo llame al script, esto siempre funcionará.

Ninguno de estos funcionó para un script bash iniciado por Finder en OS X; terminé usando:

SCRIPT_LOC="`ps -p $$ | sed /PID/d | sed s:.*/Network/:/Network/: |
sed s:.*/Volumes/:/Volumes/:`"

No es bonito, pero hace el trabajo.

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow