Cómo obtener el directorio de origen de un script Bash desde el propio script

¿Cómo obtengo la ruta del directorio en el que se encuentra un script Bash , dentro de ese script?

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

$ ./application

#!/bin/bash

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

es una línea útil que le dará el nombre completo del directorio de la secuencia de comandos sin importar de 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 de directorio 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 funciona con cualquier combinación de alias, source, bash -c, enlaces simbólicos, etc.

Cuidado: si va cda un directorio diferente antes de ejecutar este fragmento, ¡el resultado puede ser incorrecto!

Además, tenga cuidado con las $CDPATHtrampas y los efectos secundarios de salida de stderr si el usuario ha anulado de manera inteligente el cd para redirigir la salida a stderr en su lugar (incluidas las secuencias de escape, como cuando se llama update_terminal_cwd >&2en Mac). Agregar >/dev/null 2>&1al final de su cdcomando 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'"

E 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'

Uso dirname "$0":

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

usar pwdsolo no funcionará si no está ejecutando el script desde el directorio en el que está contenido.

[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 dirnamecomando es el más básico, simplemente analiza la ruta hasta el nombre de archivo fuera de la $0variable (nombre del script):

dirname "$0"

Pero, como señaló Matt B , el camino devuelto es diferente dependiendo de cómo se llame el script. pwdno 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) a donde reside el enlace, no el script real.

Algunos otros han mencionado el readlinkcomando, pero en su forma más simple, puede usar:

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

readlinkresolverá 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 script 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

De nuevo, 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 directorios:

>>>$ 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 profundidad múltiple,
• cuando el archivo
• cuando la secuencia de comandos se llama mediante el comando " source" .operador aka (punto).
• cuando arg $0se 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 , desea 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_PATHse da en ruta completa, no importa cómo se llame.
Solo asegúrate de localizar esto al comienzo del script.

Este comentario y código Copyleft, licencia seleccionable bajo la GPL2.0 o posterior o CC-SA 3.0 (CreativeCommons Share Alike) o posterior. (c) 2008. Todos los derechos reservados. 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 debe usar #!/bin/bashy no, #!/bin/shya que es una extensión Bash.

Esto debería hacerlo:

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

Esto funciona con enlaces simbólicos y espacios en la ruta.

Vea las páginas de manual para dirnamey readlink.

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

pwdse puede usar para encontrar el directorio de trabajo actual y dirnamepara encontrar el directorio de un archivo en particular (el comando que se ejecutó es $0, por dirname $0lo tanto, debería darle el directorio del script actual).

Sin embargo, dirnameproporciona con precisión la parte del directorio del nombre de archivo, que probablemente será relativa al directorio de trabajo actual. Si su script necesita cambiar de directorio por alguna razón, entonces la salida de no tiene dirnamesentido.

Sugiero lo siguiente:

#!/bin/bash

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

echo "Directory is $directory"

De esta manera, obtienes un directorio absoluto, más que 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 su script por alguna razón, puede asignar fácilmente el valor de pwduna variable antes de cambiar directorio, para uso futuro.

Aunque solo

cd `dirname $0`

resuelve el escenario específico en la pregunta, creo que tener el camino absoluto a más más generalmente útil.

Estoy cansado de ir a esta página una y otra vez para copiar y pegar la línea en la respuesta aceptada. El problema con eso es que no es fácil de entender y recordar.

Aquí hay un script fácil de recordar:

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

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

./script

/usr/bin/script

script

En la primera y tercera forma $0no tiene la información de ruta completa. En el segundo y tercero, pwdno funciona. La única forma de obtener el directorio de la tercera forma sería ejecutar 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 /usr/sharedirectorio y hacer referencia a ellos por su ruta completa. Los datos no deben estar en el /usr/bindirectorio de todos modos, por lo que probablemente sea lo que hay que hacer.

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

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

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

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

Esto es específico de Linux, pero podría usar:

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

Aquí hay un one-liner compatible con POSIX:

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

# test
echo $SCRIPT_PATH

Intenté todo esto y ninguno funcionó. Uno estaba muy cerca pero tenía un pequeño error que lo rompió gravemente; se olvidaron de envolver el camino entre comillas.

Además, muchas personas suponen que está ejecutando el script desde un shell, por lo que se olvidan que cuando abre un nuevo script, el valor predeterminado es su hogar.

Pruebe este directorio para ver el tamaño:

/var/No one/Thought/About Spaces Being/In a Directory/Name/And Here's your file.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í le mostramos cómo cambiar al directorio del script en ejecución:

cd "`dirname "$0"`"

Aquí está la forma simple y correcta:

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

Explicación:

• ${BASH_SOURCE[0]}- la ruta completa al guión. El valor de esto será correcto incluso cuando se está obteniendo el script, por ejemplo, source <(echo 'echo $0')imprime bash , mientras que si lo reemplaza ${BASH_SOURCE[0]}imprimirá la ruta completa del script. (Por supuesto, esto supone que estás bien tomando una dependencia 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á ejecutando una Mac, puede usar Homebrew para instalar GNU coreutilsy suplantar esto con greadlink -f.

• Y, por supuesto, dirnameobtiene el directorio principal de la ruta.

La forma más corta y elegante de hacer esto es:

#!/bin/bash
DIRECTORY=$(cd `dirname $0` && pwd)
echo $DIRECTORY

Esto funcionaría en todas las plataformas y es súper limpio.

Se pueden encontrar más detalles en " ¿En qué directorio está ese script bash? ".

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

Esta es una ligera revisión de la solución e-satis y 3bcdnlklvc04a señalaron en su respuesta :

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

Esto aún debería funcionar en todos los casos enumerados.

Esto evitará popddespués de un pushderror, gracias a konsolebox.

Para sistemas que tienen GNU coreutils readlink(por ejemplo, linux):

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

No hay necesidad de usar BASH_SOURCEcuando $0contiene el nombre de archivo del script.

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

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

scriptdir=`dirname "$PRG"`

$_Vale la pena mencionar como una alternativa a $0. Si está ejecutando un script desde Bash, la respuesta aceptada se puede acortar a:

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

Tenga en cuenta que esta debe ser la primera declaración en su secuencia de comandos.

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

• Rutas absolutas o rutas relativas
• Enlaces suaves de archivos y directorios
• Invocación como script, bash script, bash -c script, source script, o. script
• Espacios, pestañas, nuevas líneas, unicode, etc. en directorios y / o nombre de archivo
• Nombres de archivo que comienzan con un guión

Si está ejecutando desde Linux, parece que usar el procidentificador es la mejor solución para localizar la fuente totalmente 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 bash primitivos solamente, pero estoy de acuerdo con eso porque readlinksimplifica la tarea considerablemente. La echo Xsuma una Xal final de la cadena variable de modo que cualquier espacio en blanco final en el nombre del archivo no ser comido, y la sustitución de parámetros ${VAR%X}al final de la línea se deshace de la X. Debido a que readlinkagrega una nueva línea propia (que normalmente se comería en la sustitución de comandos 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 citas, que nos permite usar secuencias de escape como\n para representar nuevas líneas (esta es también la forma en que puede crear fácilmente directorios y archivos con nombres desviados)

Lo anterior debe cubrir sus necesidades para localizar el script que se está ejecutando actualmente en Linux, pero si no tiene el procsistema de archivos a su disposición, o si está tratando de localizar la ruta completamente resuelta de algún otro archivo, entonces tal vez encuentra útil el siguiente código. Es solo una ligera modificación de la línea anterior. Si está jugando con directorios / nombres de archivo extraños, verifica la salida con ambos lsy readlinkes informativo, ya que lsgenerará rutas "simplificadas", sustituyendo ?cosas como líneas nuevas.

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))

Pruebe la siguiente solución de compatibilidad cruzada:

CWD="$(cd -P -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"

ya que los comandos como realpatho readlinkpodrían no estar disponibles (dependiendo del sistema operativo).

Nota: en Bash, se recomienda usar en ${BASH_SOURCE[0]}lugar de $0, de lo contrario, la ruta puede romperse al obtener el archivo (source / .).

Alternativamente, puede 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ímala como está, de lo contrario imprima$PWD variable + argumento del nombre del archivo (sin ./prefijo)

Relacionado:

• ¿Cómo establecer el directorio de trabajo actual en el directorio del script?
• Bash script ruta absoluta con OS X
• Manera confiable de que un script Bash obtenga la ruta completa a sí mismo

Creo que tengo este. Llego tarde a la fiesta, pero creo que algunos apreciarán que esté aquí si se encuentran con este hilo. Los comentarios deberían 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

Estas son formas cortas de obtener información del script:

Carpetas y archivos:

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

Usando estos comandos:

    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`

Y obtuve esta 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

Ver también: https://pastebin.com/J8KjxrPF

Esto funciona en bash-3.2:

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

Si tiene un ~/bindirectorio en su $PATH, tiene Adentro de este directorio. Se origina el guión ~/bin/lib/B. Usted sabe dónde está el script incluido en relación con el original, en el libsubdirectorio, pero no dónde está en relación con el directorio actual del usuario.

Esto se resuelve con lo siguiente (dentro A):

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

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

La mejor solución compacta en mi opinión sería:

"$( cd "$( echo "${BASH_SOURCE[0]%/*}" )"; pwd )"

No hay confianza en nada más que Bash. El uso de dirname, readlinky basenameeventualmente conducirá a problemas de compatibilidad, por lo que es mejor evitarlos si es posible.