Come ottenere la directory di origine di uno script Bash dallo script stesso

Come posso ottenere il percorso della directory in cui si trova uno script Bash , all'interno di quello script?

Voglio usare uno script Bash come lanciatore per un'altra applicazione. Voglio cambiare la directory di lavoro in quella in cui si trova lo script Bash, così posso operare sui file in quella directory, in questo modo:

$ ./application

#!/bin/bash

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

è un one-liner utile che ti darà il nome di directory completo dello script indipendentemente da dove viene chiamato.

Funzionerà finché l'ultimo componente del percorso utilizzato per trovare lo script non è un collegamento simbolico (i collegamenti alla directory sono OK). Se si desidera risolvere anche eventuali collegamenti allo script stesso, è necessaria una soluzione multilinea:

#!/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 )"

Quest'ultimo funziona con qualsiasi combinazione di alias, source, bash -c, link simbolici, ecc

Attenzione: se ti trovi cdin una directory diversa prima di eseguire questo snippet, il risultato potrebbe essere errato!

Inoltre, fai attenzione ai $CDPATHgotcha e agli effetti collaterali dell'output di stderr se l'utente ha sovrascritto in modo intelligente cd per reindirizzare invece l'output su stderr (incluse le sequenze di escape, come quando chiama update_terminal_cwd >&2su Mac). L'aggiunta >/dev/null 2>&1alla fine del cdcomando si prenderà cura di entrambe le possibilità.

Per capire come funziona, prova a eseguire questo modulo più dettagliato:

#!/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 stamperà qualcosa del tipo:

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'

Utilizzare dirname "$0":

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

l'utilizzo da pwdsolo non funzionerà se non si esegue lo script dalla directory in cui è contenuto.

[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

Il dirnamecomando è il più semplice, analizzando semplicemente il percorso fino al nome del file fuori dalla $0variabile (nome dello script):

dirname "$0"

Ma, come ha sottolineato Matt B , il percorso restituito è diverso a seconda di come viene chiamato lo script. pwdnon fa il lavoro perché ti dice solo qual è la directory corrente, non in quale directory si trova lo script. Inoltre, se viene eseguito un collegamento simbolico a uno script, otterrai un percorso (probabilmente relativo) a dove risiede il collegamento, non lo script reale.

Alcuni altri hanno menzionato il readlinkcomando, ma nella sua forma più semplice è possibile utilizzare:

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

readlinkrisolverà il percorso dello script in un percorso assoluto dalla radice del filesystem. Pertanto, qualsiasi percorso contenente punti singoli o doppi, tilde e / o collegamenti simbolici verrà risolto in un percorso completo.

Ecco uno script che dimostra ciascuno di questi 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))"

Eseguendo questo script nella mia home directory, usando un percorso relativo:

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

Ancora una volta, ma usando l'intero percorso dello script:

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

Ora cambiare directory:

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

E infine usando un link simbolico per eseguire lo 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

Funziona con tutte le versioni, incluso

• quando chiamato tramite collegamento soft a profondità multipla,
• quando il file è
• quando lo script viene chiamato dal comando " source" aka .(punto) operatore.
• quando arg $0viene modificato dal chiamante.
• "./script"
• "/full/path/to/script"
• "/some/path/../../another/path/script"
• "./some/folder/script"

In alternativa, se lo script bash stesso è un collegamento simbolico relativo, si desidera seguirlo e restituire il percorso completo dello script collegato:

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_PATHviene dato nel percorso completo, indipendentemente da come viene chiamato.
Assicurati solo di individuarlo all'inizio dello script.

Questo commento e codice Copyleft, licenza selezionabile ai sensi della GPL 2.0 o successive o CC-SA 3.0 (CreativeCommons Condividi allo stesso modo) o successive. (c) 2008. Tutti i diritti riservati. Nessuna garanzia di alcun tipo. Sei stato avvertito.
http://www.gnu.org/licenses/gpl-2.0.txt
http://creativecommons.org/licenses/by-sa/3.0/
18eedfe1c99df68dc94d4a94712a71aaa8e1e9e36cacf421b9463dd2bbaa02906d0d6656

Risposta breve:

`dirname $0`

o ( preferibilmente ):

$(dirname "$0")

Puoi usare $BASH_SOURCE:

#!/bin/bash

scriptdir=`dirname "$BASH_SOURCE"`

Nota che devi usare #!/bin/bashe non #!/bin/shperché è un'estensione di Bash.

Questo dovrebbe farlo:

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

Funziona con collegamenti simbolici e spazi nel percorso.

Vedi le pagine man per dirnamee readlink.

Dalla traccia dei commenti sembra non funzionare con Mac OS. Non ho idea del perché. Eventuali suggerimenti?

pwdpuò essere usato per trovare la directory di lavoro corrente e dirnameper trovare la directory di un determinato file (il comando che è stato eseguito è $0, quindi dirname $0dovrebbe darti la directory dello script corrente).

Tuttavia, dirnamefornisce esattamente la parte della directory del nome file, che molto probabilmente sarà relativa alla directory di lavoro corrente. Se per qualche motivo lo script deve cambiare directory, l'output da dirnamediventa insignificante.

Suggerisco quanto segue:

#!/bin/bash

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

echo "Directory is $directory"

In questo modo, ottieni una directory assoluta, piuttosto che relativa.

Poiché lo script verrà eseguito in un'istanza bash separata, non è necessario ripristinare la directory di lavoro in seguito, ma se si desidera tornare allo script per qualche motivo, è possibile assegnare facilmente il valore di pwda una variabile prima di cambia directory, per uso futuro.

Anche se solo

cd `dirname $0`

risolve lo scenario specifico nella domanda, trovo che avere il percorso assoluto verso più più utile in generale.

Sono stanco di venire su questa pagina più e più volte per copiare e incollare la copertina nella risposta accettata. Il problema è che non è facile da capire e ricordare.

Ecco uno script facile da ricordare:

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

Non penso che sia così facile come altri hanno capito. pwdnon funziona, poiché la directory corrente non è necessariamente la directory con lo script. $0non sempre ha neanche le informazioni. Considera i seguenti tre modi per invocare uno script:

./script

/usr/bin/script

script

Nel primo e terzo modo $0non ha le informazioni sul percorso completo. Nel secondo e terzo, pwdnon funziona. L'unico modo per ottenere la directory nel terzo modo sarebbe quello di eseguire il percorso e trovare il file con la corrispondenza corretta. Fondamentalmente il codice dovrebbe rifare ciò che fa il sistema operativo.

Un modo per fare ciò che stai chiedendo sarebbe semplicemente codificare i dati nella /usr/sharedirectory e fare riferimento a loro per il suo percorso completo. I dati non dovrebbero comunque trovarsi nella /usr/bindirectory, quindi questa è probabilmente la cosa da fare.

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

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

Questo ottiene l'attuale directory di lavoro su Mac OS X 10.6.6:

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

Questo è specifico di Linux, ma è possibile utilizzare:

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

Ecco un one-liner conforme POSIX:

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

# test
echo $SCRIPT_PATH

Ho provato tutti questi e nessuno ha funzionato. Uno era molto vicino ma aveva un piccolo insetto che lo ha rotto gravemente; hanno dimenticato di avvolgere il percorso tra virgolette.

Inoltre, molte persone presumono che tu stia eseguendo lo script da una shell, quindi si dimenticano quando apri un nuovo script per impostazione predefinita a casa tua.

Prova questa directory per dimensioni:

/var/No one/Thought/About Spaces Being/In a Directory/Name/And Here's your file.text

Questo funziona bene indipendentemente da come o dove lo si esegue:

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

Quindi, per renderlo effettivamente utile, ecco come passare alla directory dello script in esecuzione:

cd "`dirname "$0"`"

Ecco il modo semplice e corretto:

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

Spiegazione:

• ${BASH_SOURCE[0]}- il percorso completo della sceneggiatura. Il valore di questo sarà corretto anche quando lo script è di provenienza, ad esempio source <(echo 'echo $0')stampa bash , mentre sostituendolo con ${BASH_SOURCE[0]}verrà stampato l'intero percorso dello script. (Naturalmente, questo presuppone che tu stia prendendo una dipendenza da Bash.)

• readlink -f- Risolve ricorsivamente eventuali collegamenti simbolici nel percorso specificato. Questa è un'estensione GNU e non disponibile su (ad esempio) sistemi BSD. Se stai usando un Mac, puoi usare Homebrew per installare GNU coreutilse sostituirlo con greadlink -f.

• E ovviamente dirnameottiene la directory principale del percorso.

Il modo più breve ed elegante per farlo è:

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

Funzionerebbe su tutte le piattaforme ed è super pulito.

Maggiori dettagli sono disponibili in "In quale directory si trova lo script bash? ".

Vorrei usare qualcosa del genere:

# 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

Questa è una leggera revisione della soluzione e-satis e 3bcdnlklvc04a ha sottolineato nella loro risposta :

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

Questo dovrebbe funzionare comunque in tutti i casi che hanno elencato.

Ciò impedirà popddopo un fallimento pushd, grazie a konsolebox.

Per i sistemi con coreutils GNU readlink(es. Linux):

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

Non è necessario utilizzare BASH_SOURCEquando $0contiene il nome file dello script.

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

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

scriptdir=`dirname "$PRG"`

$_vale la pena menzionare come alternativa a $0. Se stai eseguendo uno script da Bash, la risposta accettata può essere abbreviata in:

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

Nota che questa deve essere la prima affermazione nel tuo script.

Ho confrontato molte delle risposte fornite e ho trovato alcune soluzioni più compatte. Questi sembrano gestire tutti i casi pazzi che derivano dalla tua combinazione preferita di:

• Percorsi assoluti o percorsi relativi
• Collegamenti software per file e directory
• Invocazione come script, bash script, bash -c script,source script , o. script
• Spazi, schede, newline, unicode, ecc. Nelle directory e / o nel nome file
• Nomi di file che iniziano con un trattino

Se stai eseguendo da Linux, sembra che l'utilizzo procdell'handle sia la soluzione migliore per individuare l'origine completamente risolta dello script attualmente in esecuzione (in una sessione interattiva, il collegamento punta al rispettivo /dev/pts/X):

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

Questo ha un po 'di bruttezza, ma la correzione è compatta e facile da capire. Non stiamo usando solo primitivi bash, ma sto bene perché readlinksemplifica notevolmente l'attività. Il echo Xaggiunge un Xalla fine della stringa variabile in modo che lo spazio bianco finale nel nome del file non viene consumato, e il parametro di sostituzione ${VAR%X}alla fine della linea si libera del X. Perché per rappresentare newline (è anche così che puoi creare facilmente directory e file con nomi subdoli).readlink aggiunge una sua nuova riga (che normalmente verrebbe consumata nella sostituzione del comando se non fosse per il nostro inganno precedente), dobbiamo sbarazzarci anche di quello. Questo è più facile da realizzare usando lo $''schema di quotazione, che ci consente di usare sequenze di escape come\n

Quanto sopra dovrebbe coprire le tue esigenze per individuare lo script attualmente in esecuzione su Linux, ma se non hai il procfilesystem a tua disposizione, o se stai cercando di individuare il percorso completamente risolto di qualche altro file, forse potresti trova utile il codice qui sotto. È solo una leggera modifica rispetto al sopra uno strato. Se stai giocando con strani nomi / directory, controlla l'output con entrambi lsed readlinkè informativo, così come l' lsoutput di percorsi "semplificati", sostituendo ?cose come newline.

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"

Prova a usare:

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

Prova la seguente soluzione cross-compatibile:

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

come comandi come realpatho readlinkpotrebbero non essere disponibili (a seconda del sistema operativo).

Nota: in Bash, si consiglia di utilizzare ${BASH_SOURCE[0]}invece di $0, altrimenti il ​​percorso può interrompersi durante l'approvvigionamento del file ( source/ .).

In alternativa puoi provare la seguente funzione in bash:

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

Questa funzione accetta 1 argomento. Se l'argomento ha già un percorso assoluto, stampalo così com'è, altrimenti stampa l' $PWDargomento variabile + nomefile (senza ./prefisso).

Relazionato:

• Come impostare la directory di lavoro corrente sulla directory dello script?
• Percorso assoluto dello script Bash con OS X
• Modo affidabile per uno script Bash per ottenere il percorso completo a se stesso

Credo di avere questo. Sono in ritardo alla festa, ma penso che alcuni apprezzeranno il fatto di essere qui se si imbattono in questa discussione. I commenti dovrebbero spiegare:

#!/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

Questi sono modi brevi per ottenere informazioni sugli script:

Cartelle e file:

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

Utilizzando questi comandi:

    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`

E ho ottenuto questo risultato:

     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

Vedi anche: https://pastebin.com/J8KjxrPF

Funziona in bash-3.2:

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

Se hai una ~/bindirectory nella tua $PATH, hai Adentro questa directory. Fonte la sceneggiatura ~/bin/lib/B. Sai dove lo script incluso è relativo a quello originale, nella libsottodirectory, ma non dove è relativo alla directory corrente dell'utente.

Questo è risolto dal seguente (interno A):

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

Non importa dove si trovi l'utente o come chiama lo script, funzionerà sempre.

La migliore soluzione compatta a mio avviso sarebbe:

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

Non si fa affidamento su altro che Bash. L'uso di dirname, readlinke basenamealla fine porterà a problemi di compatibilità, quindi è meglio evitare, se possibile.