Bash betiğinin kaynak dizinini betiğin içinden alma

Bash betiğinin bulunduğu dizinin yolunu bu betiğin içine nasıl alırım ?

Bash betiğini başka bir uygulama için başlatıcı olarak kullanmak istiyorum. Bash betiğinin bulunduğu dizine çalışma dizinini değiştirmek istiyorum, böylece bu dizindeki dosyalar üzerinde çalışabilirim:

$ ./application

#!/bin/bash

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

nereden çağrılırsa kullanılsın size komut dosyasının tam dizin adını verecek kullanışlı bir tek satırlıktır.

Komut dosyasını bulmak için kullanılan yolun son bileşeni bir simge bağlantısı olmadığı sürece çalışır (dizin bağlantıları uygundur). Komut dosyasının kendisine olan bağlantıları da çözmek istiyorsanız, çok satırlı bir çözüme ihtiyacınız vardır:

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

Bu sonuncusu takma adları, herhangi bir kombinasyonu ile çalışacaktır source, bash -c, sembolik bağlar, vb

Dikkat: cdBu pasajı çalıştırmadan önce farklı bir dizine geçerseniz , sonuç yanlış olabilir!

Ayrıca, kullanıcı çıktıyı stderr'e yönlendirmek için akıllıca geçersiz $CDPATHkıldıysa gotchas ve stderr çıktı yan etkilerine dikkat edin ( update_terminal_cwd >&2Mac'te arama yaparken olduğu gibi kaçış dizileri dahil ). Komutunuzun >/dev/null 2>&1sonuna eklemek , cdher iki olasılığı da dikkate alacaktır.

Nasıl çalıştığını anlamak için bu daha ayrıntılı formu çalıştırmayı deneyin:

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

Ve şöyle bir şey basacaktır:

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'

Kullanım dirname "$0":

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

pwdbetiği içerdiği dizinden çalıştırmıyorsanız, yalnız kullanmak çalışmaz.

[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

dirnameKomut en temel, basit kapalı dosya yolunu yukarı ayrıştırma olduğu $0(script adı) değişken:

dirname "$0"

Ancak, matt b'nin işaret ettiği gibi , döndürülen yol komut dosyasının nasıl adlandırıldığına bağlı olarak farklıdır. pwdbu sadece geçerli dizinin ne olduğunu, komut dosyasının hangi dizinde bulunduğunu söylemediğinden işi yapmaz. Ayrıca, bir komut dosyasına sembolik bir bağlantı yürütülürse, bağlantının bulunduğu yer, gerçek komut dosyası değil.

Bazıları readlinkkomuttan bahsetti , ancak en basit haliyle şunları kullanabilirsiniz:

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

readlinkkomut dosyasının yolunu, dosya sisteminin kökünden mutlak bir yola çözümleyecektir. Böylece, tek veya çift nokta, tildes ve / veya sembolik bağlantılar içeren yollar tam bir yola çözülecektir.

İşte bunların her birini gösteren bir senaryo 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))"

Göreli bir yol kullanarak bu komut dosyasını ev dizinimde çalıştırma:

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

Yine de, betiğin tam yolunu kullanarak:

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

Şimdi dizinleri değiştirme:

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

Ve son olarak betiği çalıştırmak için sembolik bir bağlantı kullanarak:

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

Aşağıdakiler dahil tüm sürümler için çalışır:

• çok derinlikli yumuşak bağlantı ile çağrıldığında,
• dosya ne zaman
• komut " source" aka .(nokta) operatörü tarafından çağrıldığında .
• arg $0, arayandan değiştirildiğinde.
• "./script"
• "/full/path/to/script"
• "/some/path/../../another/path/script"
• "./some/folder/script"

Alternatif olarak, bash betiğinin kendisi göreceli bir sembolik bağlantıysa onu takip etmek ve bağlantılı komut dosyasının tam yolunu döndürmek istersiniz :

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_PATHnasıl adlandırılırsa adlandırılsın tam yol olarak verilir.
Bunu komut dosyasının başlangıcında bulduğunuzdan emin olun.

Bu yorum ve kod Copyleft, GPL2.0 veya üstü veya CC-SA 3.0 (CreativeCommons Paylaşımı) veya üstü altında seçilebilir lisans. (c) 2008. Tüm hakları saklıdır. Hiçbir garanti yok. Uyarıldın.
http://www.gnu.org/licenses/gpl-2.0.txt
http://creativecommons.org/licenses/by-sa/3.0/
18eedfe1c99df68dc94d4a94712a71aaa8e1e9e36cacf421b9463dd2bbaa02906d0d6656

Kısa cevap:

`dirname $0`

veya ( tercihen ):

$(dirname "$0")

Şunları kullanabilirsiniz $BASH_SOURCE:

#!/bin/bash

scriptdir=`dirname "$BASH_SOURCE"`

Bir Bash uzantısı olduğundan #!/bin/bashdeğil kullanmanız gerektiğini unutmayın #!/bin/sh.

Bunu yapmalı:

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

Bu, yoldaki semboller ve boşluklarla çalışır.

Man sayfalarına bakın dirnameve readlink.

Yorum parçasından Mac OS ile çalışmıyor gibi görünüyor. Bunun neden olduğu hakkında hiçbir fikrim yok. Herhangi bir öneri?

pwdgeçerli çalışma dizinini dirnamebulmak ve belirli bir dosyanın dizinini bulmak için kullanılabilir (çalıştırılan komut $0, yani dirname $0geçerli komut dosyasının dizinini vermelidir).

Ancak, dirnametam olarak geçerli çalışma dizinine göreceli olmayacak olan dosya adının dizin bölümünü verir. Komut dosyanızın herhangi bir nedenle dizini değiştirmesi gerekiyorsa, çıktısı dirnameanlamsız olur.

Aşağıdakileri öneririm:

#!/bin/bash

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

echo "Directory is $directory"

Bu şekilde, göreceli bir dizinden ziyade, mutlak bir dizin elde edersiniz.

Komut dosyası ayrı bir bash örneğinde çalışacağından, daha sonra çalışma dizinini geri yüklemeye gerek yoktur, ancak herhangi bir nedenle komut dosyanızda geri dönmek isterseniz, sizden pwdönce bir değişkenin değerini kolayca atayabilirsiniz. ileride kullanmak için dizini değiştirin.

Sadece

cd `dirname $0`

sorudaki belirli senaryoyu çözer, genel olarak daha yararlı olan mutlak yolu buluyorum.

Tek astarı kabul edilen cevapta kopyalamak için bu sayfaya tekrar tekrar gelmekten bıktım. Sorun şu ki, anlamak ve hatırlamak kolay değil.

İşte hatırlaması kolay bir komut dosyası:

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

Bunun diğerlerinin yaptığı kadar kolay olduğunu sanmıyorum. pwdgeçerli dizin komut dosyası içeren dizin olması gerekmediği için çalışmaz. $0her zaman bilgiye sahip değildir. Bir komut dosyasını çağırmanın aşağıdaki üç yolunu göz önünde bulundurun:

./script

/usr/bin/script

script

Birinci ve üçüncü yollarda $0tam yol bilgisi yoktur. İkinci ve üçüncü olarak pwdçalışmaz. Dizini üçüncü şekilde almanın tek yolu, yolu çalıştırmak ve doğru eşleşmeli dosyayı bulmak olacaktır. Temel olarak kod, işletim sisteminin yaptıklarını yeniden yapmak zorunda kalacaktır.

İstediğinizi yapmanın bir yolu, /usr/sharedizindeki verileri sabit olarak kodlamak ve tam yoluna başvurmaktır . Veriler /usr/binyine de dizinde olmamalı , bu yüzden muhtemelen yapılacak şey budur.

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

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

Bu, Mac OS X 10.6.6'daki geçerli çalışma dizinini alır:

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

Bu Linux'a özgüdür, ancak şunları kullanabilirsiniz:

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

İşte POSIX uyumlu bir astar:

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

# test
echo $SCRIPT_PATH

Bunların hepsini denedim ve hiçbiri işe yaramadı. Biri çok yakın ama kötü kırdı küçük bir hata vardı; yolu tırnak içine almayı unuttular.

Ayrıca birçok kişi, komut dosyasını bir kabuktan çalıştırdığınızı varsayar; böylece, varsayılan olarak evinize varsayılan yeni bir komut dosyası açtığınızda unuturlar.

Boyut için bu dizini deneyin:

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

Bu, nasıl veya nerede çalıştırdığınızdan bağımsız olarak doğru olur:

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

Yani gerçekten kullanışlı hale getirmek için çalışan komut dosyasının dizinine nasıl geçeceğiniz aşağıda açıklanmıştır:

cd "`dirname "$0"`"

İşte basit ve doğru yol:

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

Açıklama:

• ${BASH_SOURCE[0]}- komut dosyasının tam yolu. Bunun değeri, komut dosyası kaynaklanırken bile doğru olacaktır, örn. Bashsource <(echo 'echo $0') yazdırır , bununla değiştirilirken komut dosyasının tam yolu yazdırılır. (Tabii ki, bu Bash'e bağımlılık konusunda iyi olduğunuzu varsayar.)${BASH_SOURCE[0]}

• readlink -f- Belirtilen yoldaki sembol bağlantılarını yinelemeli olarak çözer. Bu bir GNU oluşumudur ve (örneğin) BSD sistemlerinde mevcut değildir. Mac çalıştırıyorsanız, GNU'yu yüklemek coreutilsve bunun yerine geçmek için Homebrew'u kullanabilirsiniz greadlink -f.

• Ve elbette dirnameyolun üst dizinini alır.

Bunu yapmanın en kısa ve en zarif yolu:

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

Bu, tüm platformlarda çalışır ve süper temizdir.

Daha fazla ayrıntı " Bu bash betiği hangi dizinde? " Bölümünde bulunabilir .

Ben böyle bir şey kullanabilirsiniz:

# 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

Bu işaret çözüm, e-satis ve 3bcdnlklvc04a hafif bir revizyon olduğunu verdikleri yanıta :

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

Bu, listelendikleri tüm durumlarda hala çalışmalıdır.

Bu, konsolebox sayesinde popdbaşarısız olduktan sonra pushdönleyecektir.

GNU coreutils'e sahip sistemler için readlink(örn. Linux):

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

Kullanmaya gerek yoktur BASH_SOURCEzaman $0komut dosyası dosya adını içerir.

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

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

scriptdir=`dirname "$PRG"`

$_bir alternatif olarak bahsetmeye değer $0. Bash'ten bir komut dosyası çalıştırıyorsanız, kabul edilen cevap kısaltılabilir:

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

Bunun kodunuzdaki ilk ifade olması gerektiğini unutmayın.

Verilen cevapların çoğunu karşılaştırdım ve daha kompakt çözümler ürettim. Bunlar, en sevdiğiniz kombinasyondan kaynaklanan tüm çılgın kenar vakalarını ele alıyor gibi görünüyor:

• Mutlak yollar veya göreli yollar
• Dosya ve dizin yazılım bağlantıları
• Çağırma olarak script, bash script, bash -c script, source script, ya da. script
• Dizinlerde ve / veya dosya adında boşluklar, sekmeler, yeni satırlar, unicode vb.
• Kısa çizgi ile başlayan dosya adları

Linux'tan çalışıyorsanız proc, şu anda çalışan komut dosyasının tam çözümlenmiş kaynağını bulmak için tanıtıcıyı kullanmanın en iyi çözüm olduğu görülmektedir (etkileşimli bir oturumda, bağlantı ilgili olanı işaret eder /dev/pts/X):

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

Bunun biraz çirkinliği var, ancak düzeltme kompakt ve anlaşılması kolay. Sadece bash ilkellerini kullanmıyoruz, ama bununla iyiyim çünkü readlinkgörevi önemli ölçüde basitleştiriyor. echo XBir ekleyen Xdosya herhangi izleyen boşluk yemiş almaz ve parametre ikamesi böylece değişken dizesinin sonuna ${VAR%X}satırın sonunda kurtulur X. Çünkü readlink(normalde değilse önceki oyununa gelen komut yerine yemiş olurdu) kendine ait bir yeni satır ekler, biz de o kurtulmak zorundayız. Bu, en kolay şekilde $'', aşağıdaki gibi kaçış dizilerini kullanmamızı sağlayan alıntı şeması kullanılarak gerçekleştirilir .\n yeni satırları temsil etmek için (bu aynı zamanda adsız dizinleri ve dosyaları kolayca nasıl oluşturabilirsiniz).

Yukarıdakiler, Linux'ta şu anda çalışan betiği bulma gereksinimlerinizi kapsamalıdır, ancak procdosya sisteminiz elinizde değilse veya başka bir dosyanın tamamen çözülmüş yolunu bulmaya çalışıyorsanız, belki aşağıdaki kodu yararlı bulabilirsiniz. Yukarıdaki tek astardan sadece küçük bir değişiklik. Garip dizin / dosya adları ile oynuyorsanız, çıktıyı her ikisiyle de kontrol edin lsve readlinkbilgilendirici, yeni satırlar gibi şeylerin lsyerine "basitleştirilmiş" yollar ?çıkarır.

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"

Kullanmayı deneyin:

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

Aşağıdaki çapraz uyumlu çözümü deneyin:

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

gibi realpathveya readlinkkullanılamıyor gibi komutlar (işletim sistemine bağlı olarak).

Not: Bash'te ${BASH_SOURCE[0]}bunun yerine kullanılması önerilir $0, aksi takdirde dosya ( source/ .) kaynaklanırken yol kesilebilir .

Alternatif olarak bash'da aşağıdaki işlevi deneyebilirsiniz:

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

Bu işlev 1 argüman alır. Bağımsız değişken zaten mutlak bir yola sahipse, olduğu gibi yazdırın, aksi takdirde $PWDdeğişken + dosya adı bağımsız değişkenini ( ./önek olmadan ) yazdırın .

İlişkili:

• Geçerli çalışma dizini komut dosyasının dizinine nasıl ayarlanır?
• OS X ile Bash komut dosyası mutlak yolu
• Bash betiğinin kendisine giden tam yolu almasının güvenilir yolu

Buna sahip olduğuma inanıyorum. Partiye geç kaldım, ama sanırım bazıları bu iş parçacığına rastlarsa burada olmayı takdir edecekler. Yorumlar açıklamalıdır:

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

Komut dosyası bilgilerini almanın kısa yolları şunlardır:

Klasörler ve dosyalar:

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

Bu komutları kullanarak:

    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`

Ve bu çıktıyı aldım:

     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

Ayrıca bakınız: https://pastebin.com/J8KjxrPF

Bu bash-3.2'de çalışır:

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

Eğer bir varsa ~/binGözlerinde farklı dizini $PATH, sahip Abu dizinin içinin. Komut dosyasını kaynakları ~/bin/lib/B. Eklenen komut dosyasının libalt dizindeki orijinal komut dosyasına göre nerede olduğunu, ancak kullanıcının geçerli dizinine göre nerede olduğunu bilmiyorsunuz.

Bu, aşağıdakilerle (içeride A) çözülür :

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

Kullanıcının nerede olduğu veya komut dosyasını nasıl aradığı önemli değil, bu her zaman işe yarayacaktır.

Benim görüşüme göre en kompakt çözüm:

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

Bash dışında hiçbir şeye güvenilmez. Kullanımı dirname, readlinkve basenamemümkünse eğer bu tip yerlerden kaçınılmalıdır böylece sonunda, uyumluluk sorunları yol açacaktır.