Jak uzyskać katalog źródłowy skryptu Bash z poziomu samego skryptu

Jak uzyskać ścieżkę do katalogu, w którym znajduje się skrypt Bash , wewnątrz tego skryptu?

Chcę użyć skryptu Bash jako programu uruchamiającego dla innej aplikacji. Chcę zmienić katalog roboczy na katalog, w którym znajduje się skrypt Bash, aby móc operować na plikach w tym katalogu, w następujący sposób:

$ ./application

#!/bin/bash

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

jest użytecznym jednowierszowym, który daje pełną nazwę katalogu skryptu, bez względu na to, skąd jest wywoływany.

Będzie działał tak długo, jak ostatni komponent ścieżki użytej do znalezienia skryptu nie będzie dowiązaniem symbolicznym (łącza do katalogów są OK). Jeśli chcesz również rozwiązać jakiekolwiek łącza do samego skryptu, potrzebujesz rozwiązania wieloliniowego:

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

Ten ostatni będzie współpracować z dowolną kombinacją pseudonimy, source, bash -c, dowiązania symboliczne, itd.

Uwaga: jeśli cdprzejdziesz do innego katalogu przed uruchomieniem tego fragmentu kodu, wynik może być niepoprawny!

Uważaj również na $CDPATHgotchas i efekty uboczne wyjścia stderr, jeśli użytkownik inteligentnie przesłonił cd, aby zamiast tego przekierować wyjście do stderr (w tym sekwencje specjalne, na przykład podczas wywoływania update_terminal_cwd >&2na komputerze Mac). Dodanie >/dev/null 2>&1na końcu twojego cdpolecenia zadba o obie możliwości.

Aby zrozumieć, jak to działa, spróbuj uruchomić ten bardziej szczegółowy formularz:

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

I wydrukuje coś takiego:

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'

Użyj dirname "$0":

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

użycie pwdsamego nie będzie działać, jeśli nie uruchamiasz skryptu z katalogu, w którym się on znajduje.

[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

dirnameKomenda jest najbardziej podstawowym, po prostu parsowania ścieżkę do pliku off z $0zmienna (nazwa skryptu):

dirname "$0"

Ale, jak zauważył Matt B , zwrócona ścieżka różni się w zależności od sposobu wywołania skryptu. pwdnie wykonuje zadania, ponieważ mówi tylko o tym, jaki jest bieżący katalog, a nie katalog, w którym znajduje się skrypt. Ponadto, jeśli zostanie wykonane dowiązanie symboliczne do skryptu, otrzymasz ścieżkę (prawdopodobnie względną) do gdzie znajduje się link, a nie rzeczywisty skrypt.

Inni wspomnieli o readlinkpoleceniu, ale najprościej możesz użyć:

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

readlinkrozwiąże ścieżkę skryptu do ścieżki bezwzględnej z katalogu głównego systemu plików. Zatem wszelkie ścieżki zawierające pojedyncze lub podwójne kropki, tyldy i / lub dowiązania symboliczne zostaną przekształcone w pełną ścieżkę.

Oto skrypt demonstrujący każdy z nich 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))"

Uruchomienie tego skryptu w moim katalogu domowym przy użyciu ścieżki względnej:

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

Ponownie, ale używając pełnej ścieżki do skryptu:

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

Teraz zmieniamy katalogi:

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

I na koniec używając linku symbolicznego do wykonania skryptu:

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

Działa dla wszystkich wersji, w tym

• wywołany przez miękki link o wielu głębokościach,
• kiedy plik to
• gdy skrypt wywoływany przez polecenie „ source” aka .(kropka) operator.
• kiedy arg $0jest modyfikowany z dzwoniącego.
• "./script"
• "/full/path/to/script"
• "/some/path/../../another/path/script"
• "./some/folder/script"

Alternatywnie, jeśli sam skrypt bash jest względnym dowiązaniem symbolicznym , chcesz go podążać i zwrócić pełną ścieżkę skryptu połączonego z:

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_PATHjest podane pełną ścieżką, bez względu na to, jak się nazywa.
Tylko upewnij się, że znajdziesz to na początku skryptu.

Ten komentarz i kod Copyleft, licencja do wyboru na licencji GPL2.0 lub nowszej lub CC-SA 3.0 (CreativeCommons Share Alike) lub nowszej. (c) 2008. Wszelkie prawa zastrzeżone. Żadnej gwarancji. Zostałeś ostrzeżony.
http://www.gnu.org/licenses/gpl-2.0.txt
http://creativecommons.org/licenses/by-sa/3.0/
18eedfe1c99df68dc94d4a94712a71aaa8e1e9e36cacf421b9463dd2bbaa02906d0d6656

Krótka odpowiedź:

`dirname $0`

lub ( najlepiej ):

$(dirname "$0")

Możesz użyć $BASH_SOURCE:

#!/bin/bash

scriptdir=`dirname "$BASH_SOURCE"`

Pamiętaj, że musisz go używać, #!/bin/basha nie, #!/bin/shponieważ jest to rozszerzenie Bash.

To powinno to zrobić:

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

Działa to z dowiązaniami symbolicznymi i spacjami na ścieżce.

Zobacz strony podręcznika dla dirnamei readlink.

Ze ścieżki komentarzy wydaje się, że nie działa w systemie Mac OS. Nie mam pojęcia, dlaczego tak jest. Jakieś sugestie?

pwdmożna użyć do znalezienia bieżącego katalogu roboczego i dirnamedo znalezienia katalogu określonego pliku (polecenie, które zostało uruchomione, jest $0, więc dirname $0powinno dać ci katalog bieżącego skryptu).

Jednak dirnamedaje właśnie część katalogów nazwy pliku, który nie jest bardziej prawdopodobne niż będzie względem bieżącego katalogu roboczego. Jeśli twój skrypt musi z jakiegoś powodu zmienić katalog, wynik z dirnamestaje się bez znaczenia.

Proponuję następujące:

#!/bin/bash

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

echo "Directory is $directory"

W ten sposób otrzymujesz katalog absolutny, a nie względny.

Ponieważ skrypt zostanie uruchomiony w osobnej instancji bash, nie ma potrzeby późniejszego przywracania katalogu roboczego, ale jeśli z jakiegoś powodu chcesz z powrotem zmienić skrypt, możesz łatwo przypisać wartość pwdzmiennej przed zmień katalog, do wykorzystania w przyszłości.

Chociaż tylko

cd `dirname $0`

rozwiązuje konkretny scenariusz w pytaniu, uważam, że ścieżka bezwzględna jest bardziej użyteczna ogólnie.

Mam dość ciągłego odwiedzania tej strony w celu skopiowania wklejania jednej linijki w zaakceptowanej odpowiedzi. Problem w tym, że niełatwo to zrozumieć i zapamiętać.

Oto łatwy do zapamiętania skrypt:

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

Nie sądzę, że jest to tak łatwe, jak inni się na to wydawali. pwdnie działa, ponieważ bieżący katalog niekoniecznie jest katalogiem ze skryptem. $0nie zawsze ma te informacje. Rozważ następujące trzy sposoby wywołania skryptu:

./script

/usr/bin/script

script

W pierwszy i trzeci sposób $0nie ma pełnej informacji o ścieżce. W drugim i trzecim pwdnie działa. Jedynym sposobem na uzyskanie katalogu w trzeci sposób byłoby uruchomienie ścieżki i znalezienie pliku z poprawnym dopasowaniem. Zasadniczo kod musiałby powtórzyć to, co robi system operacyjny.

Jednym ze sposobów zrobienia tego, o co prosisz, byłoby po prostu zakodować dane w /usr/sharekatalogu i odwołać się do nich pełną ścieżką. Dane i tak nie powinny znajdować się w /usr/binkatalogu, więc prawdopodobnie tak należy zrobić.

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

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

Spowoduje to pobranie bieżącego katalogu roboczego w systemie Mac OS X 10.6.6:

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

Jest to specyficzne dla Linuksa, ale możesz użyć:

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

Oto jednolinijka zgodna z POSIX:

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

# test
echo $SCRIPT_PATH

Próbowałem tych wszystkich i nic nie działało. Jeden był bardzo blisko, ale miał drobny błąd, który bardzo go zepsuł; zapomnieli zawinąć ścieżkę w cudzysłów.

Również wiele osób zakłada, że ​​uruchamiasz skrypt z powłoki, więc zapominają, że po otwarciu nowego skryptu domyślnie jest to dom.

Wypróbuj ten katalog dla rozmiaru:

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

To dobrze, bez względu na to, jak i gdzie go uruchomisz:

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

Aby więc było to naprawdę przydatne, przejdź do katalogu uruchomionego skryptu:

cd "`dirname "$0"`"

Oto prosty, poprawny sposób:

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

Wyjaśnienie:

• ${BASH_SOURCE[0]}- pełna ścieżka do skryptu. Wartość tego będzie poprawna nawet podczas pozyskiwania skryptu, np. source <(echo 'echo $0')Wypisuje bash , a zastąpienie go ${BASH_SOURCE[0]}wypisuje pełną ścieżkę skryptu. (Oczywiście zakłada to, że nie masz nic przeciwko Bashowi.)

• readlink -f- Rekurencyjnie rozwiązuje wszelkie dowiązania symboliczne na określonej ścieżce. Jest to rozszerzenie GNU i nie jest dostępne (na przykład) w systemach BSD. Jeśli używasz komputera Mac, możesz użyć Homebrew, aby zainstalować GNU coreutilsi zastąpić to greadlink -f.

• I oczywiście dirnamepobiera katalog macierzysty ścieżki.

Najkrótszym i najbardziej eleganckim sposobem na to jest:

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

To działałoby na wszystkich platformach i jest super czyste.

Więcej informacji można znaleźć w „W którym katalogu znajduje się ten skrypt bash? ”.

Użyłbym czegoś takiego:

# 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

Jest to niewielka zmiana rozwiązania e-satis i 3bcdnlklvc04a wskazane w odpowiedzi :

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

Powinno to nadal działać we wszystkich wymienionych przypadkach.

Zapobiegnie to popdpo awarii pushd, dzięki konsolebox.

W systemach z rdzeniami GNU readlink(np. Linux):

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

Nie ma potrzeby używania, BASH_SOURCEgdy $0zawiera nazwę skryptu.

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

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

scriptdir=`dirname "$PRG"`

$_warto wspomnieć jako alternatywę dla $0. Jeśli uruchamiasz skrypt z Bash, zaakceptowaną odpowiedź można skrócić do:

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

Pamiętaj, że musi to być pierwsza instrukcja w twoim skrypcie.

Porównałem wiele udzielonych odpowiedzi i opracowałem bardziej kompaktowe rozwiązania. Wydaje się, że radzą sobie ze wszystkimi szalonymi przypadkami, które wynikają z twojej ulubionej kombinacji:

• Ścieżki bezwzględne lub ścieżki względne
• Miękkie linki do plików i katalogów
• Inwokacja jako script, bash script, bash -c script, source script, lub. script
• Spacje, tabulatory, znaki nowej linii, Unicode itp. W katalogach i / lub nazwie pliku
• Nazwy plików zaczynające się od łącznika

Jeśli korzystasz z Linuksa, wydaje się, że użycie procuchwytu jest najlepszym rozwiązaniem do zlokalizowania w pełni rozwiązanego źródła aktualnie uruchomionego skryptu (w sesji interaktywnej link wskazuje na odpowiedni /dev/pts/X):

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

Ma to trochę brzydoty, ale poprawka jest zwarta i łatwa do zrozumienia. Nie używamy tylko prymitywów bash, ale nie mam nic readlinkprzeciwko , ponieważ znacznie upraszcza to zadanie. echo XDodaje Xna końcu łańcucha zmiennego tak, że wszystkie spacje spływu w nazwie pliku nie zjedzony, a podstawienie parametr ${VAR%X}na końcu linii pozbywa się X. Ponieważ readlinkdodaje nowy wiersz (który normalnie zostałby zjedzony podczas zastępowania poleceń, gdyby nie nasza poprzednia sztuczka), musimy się go również pozbyć. Najłatwiej to osiągnąć za pomocą $''schematu cytowania, który pozwala nam używać sekwencji specjalnych, takich jak\n reprezentować nowe wiersze (w ten sposób możesz łatwo tworzyć podstępnie nazwane katalogi i pliki).

Powyższe powinno zaspokoić twoje potrzeby zlokalizowania aktualnie działającego skryptu w systemie Linux, ale jeśli nie masz do procdyspozycji systemu plików lub próbujesz znaleźć w pełni rozwiązaną ścieżkę innego pliku, być może poniższy kod jest pomocny. To tylko niewielka modyfikacja powyższego jednowarstwowego. Jeśli grasz wokół dziwnych nazwach plików / katalogów, sprawdzając wyjście z obu lsi readlinkma charakter informacyjny, a lswyjście będzie „uproszczonej” ścieżki, zastępując ?na takie rzeczy jak nowej linii.

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"

Spróbuj użyć:

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

Wypróbuj następujące rozwiązanie kompatybilne krzyżowo:

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

ponieważ polecenia takie jak realpathlub readlinkmogą być niedostępne (w zależności od systemu operacyjnego).

Uwaga: W Bash zaleca się stosowanie ${BASH_SOURCE[0]}zamiast $0, w przeciwnym razie ścieżka może się popsuć podczas pobierania pliku ( source/ .).

Alternatywnie możesz wypróbować następującą funkcję w bash:

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

Ta funkcja przyjmuje 1 argument. Jeśli argument ma już ścieżkę bezwzględną, wypisz ją taką, jaka jest, w przeciwnym razie wypisz $PWDargument zmienna + nazwa pliku (bez ./prefiksu).

Związane z:

• Jak ustawić bieżący katalog roboczy na katalog skryptu?
• Bezwzględna ścieżka skryptu Bash w systemie OS X
• Niezawodny sposób, aby skrypt Bash uzyskał pełną ścieżkę do siebie

Myślę, że mam to. Spóźniam się na przyjęcie, ale myślę, że niektórzy docenią to, że będą tutaj, jeśli natkną się na ten wątek. Komentarze powinny wyjaśniać:

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

Oto krótkie sposoby na uzyskanie informacji o skrypcie:

Foldery i pliki:

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

Za pomocą tych poleceń:

    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`

I mam ten wynik:

     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

Zobacz także: https://pastebin.com/J8KjxrPF

Działa to w bash-3.2:

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

Jeśli masz ~/binkatalog w swoim katalogu $PATH, znajdziesz go Aw tym katalogu. Źródła skryptu ~/bin/lib/B. Wiesz, gdzie dołączony skrypt jest względny w stosunku do oryginalnego, w libpodkatalogu, ale nie w którym jest odniesiony do bieżącego katalogu użytkownika.

Rozwiązuje to następujące (wewnątrz A):

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

Nie ma znaczenia, gdzie jest użytkownik ani jak wywołuje skrypt, to zawsze zadziała.

Moim zdaniem najlepszym kompaktowym rozwiązaniem byłoby:

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

Nie można polegać na niczym innym niż Bash. Zastosowanie dirname, readlinka basenamew konsekwencji doprowadzi do problemów z kompatybilnością, więc są one najlepiej unikać, jeśli to w ogóle możliwe.