Cara mendapatkan direktori sumber skrip Bash dari dalam skrip itu sendiri

Bagaimana cara mendapatkan lintasan direktori tempat skrip Bash berada, di dalam skrip itu?

Saya ingin menggunakan skrip Bash sebagai peluncur untuk aplikasi lain. Saya ingin mengubah direktori kerja ke direktori tempat skrip Bash berada, sehingga saya dapat beroperasi pada file di direktori itu, seperti:

$ ./application

#!/bin/bash

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

adalah satu-liner yang bermanfaat yang akan memberi Anda nama direktori lengkap dari skrip di mana pun ia dipanggil.

Ini akan berfungsi selama komponen terakhir dari jalur yang digunakan untuk menemukan skrip bukan symlink (tautan direktori OK). Jika Anda juga ingin menyelesaikan tautan apa pun ke skrip itu sendiri, Anda memerlukan solusi multisaluran:

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

Yang terakhir ini akan bekerja dengan kombinasi alias, source, bash -c, symlink, dll

Hati-hati: jika Anda cdke direktori yang berbeda sebelum menjalankan cuplikan ini, hasilnya mungkin salah!

Selain itu, perhatikan $CDPATHgotchas , dan efek samping keluaran stderr jika pengguna mengganti cd dengan cerdas untuk mengalihkan output ke stderr (termasuk urutan keluar, seperti saat memanggil update_terminal_cwd >&2Mac). Menambahkan >/dev/null 2>&1pada akhir cdperintah Anda akan menangani kedua kemungkinan.

Untuk memahami cara kerjanya, coba jalankan formulir yang lebih bertele-tele ini:

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

Dan itu akan mencetak sesuatu seperti:

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'

Gunakan dirname "$0":

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

menggunakan pwdsendiri tidak akan berfungsi jika Anda tidak menjalankan skrip dari direktori yang ada di dalamnya.

[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

The dirnameperintah yang paling dasar, hanya parsing jalan sampai ke nama file off dari $0variabel (nama script):

dirname "$0"

Tetapi, seperti ditunjukkan matt b , path yang dikembalikan berbeda tergantung pada bagaimana script dipanggil. pwdtidak melakukan pekerjaan karena itu hanya memberi tahu Anda apa direktori saat ini, bukan direktori tempat skrip berada. Selain itu, jika tautan simbolis ke skrip dijalankan, Anda akan mendapatkan jalur (mungkin relatif) untuk tempat tautan berada, bukan skrip yang sebenarnya.

Beberapa orang lain telah menyebutkan readlinkperintah, tetapi yang paling sederhana, Anda dapat menggunakan:

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

readlinkakan menyelesaikan jalur skrip ke jalur absolut dari root filesystem. Jadi, setiap jalur yang mengandung titik tunggal atau ganda, tilde dan / atau tautan simbolik akan diselesaikan ke jalur penuh.

Berikut adalah script menunjukkan masing-masing, 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))"

Menjalankan skrip ini di direktori home saya, menggunakan jalur relatif:

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

Sekali lagi, tetapi menggunakan path lengkap ke skrip:

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

Sekarang mengubah direktori:

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

Dan akhirnya menggunakan tautan simbolis untuk menjalankan skrip:

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

Bekerja untuk semua versi, termasuk

• ketika dipanggil melalui tautan lunak multple depth,
• ketika file itu
• ketika skrip dipanggil oleh perintah " source" alias .operator (titik).
• ketika arg $0dimodifikasi dari pemanggil.
• "./script"
• "/full/path/to/script"
• "/some/path/../../another/path/script"
• "./some/folder/script"

Atau, jika skrip bash itu sendiri adalah symlink relatif yang ingin Anda ikuti dan kembalikan path lengkap skrip ditautkan ke:

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_PATHdiberikan dalam jalur penuh, tidak peduli bagaimana itu disebut.
Pastikan Anda menemukan ini di awal skrip.

Ini komentar dan kode Copyleft, lisensi yang dipilih di bawah GPL2.0 atau lebih baru atau CC-SA 3.0 (CreativeCommons Share Alike) atau lebih baru. (c) 2008. Hak cipta dilindungi undang-undang. Tidak ada jaminan dalam bentuk apa pun. Anda telah diperingatkan.
http://www.gnu.org/licenses/gpl-2.0.txt
http://creativecommons.org/licenses/by-sa/3.0/
18eedfe1c99df68dc94d4a94712a71aaa8e1e9e36cacf421b9463dd2bbaa02906d0d6656

Jawaban singkat:

`dirname $0`

atau ( lebih disukai ):

$(dirname "$0")

Anda bisa menggunakan $BASH_SOURCE:

#!/bin/bash

scriptdir=`dirname "$BASH_SOURCE"`

Perhatikan bahwa Anda harus menggunakan #!/bin/bashdan bukan #!/bin/shkarena ini adalah ekstensi Bash.

Ini harus dilakukan:

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

Ini berfungsi dengan symlink dan spasi di jalur.

Lihat halaman manual untuk dirnamedan readlink.

Dari trek komentar sepertinya tidak berfungsi dengan Mac OS. Saya tidak tahu mengapa itu terjadi. Ada saran?

pwddapat digunakan untuk menemukan direktori kerja saat ini, dan dirnameuntuk menemukan direktori file tertentu (perintah yang dijalankan, adalah $0, jadi dirname $0harus memberi Anda direktori skrip saat ini).

Namun, dirnamememberikan dengan tepat bagian direktori dari nama file, yang lebih mungkin daripada relatif terhadap direktori kerja saat ini. Jika skrip Anda perlu mengubah direktori karena alasan tertentu, maka output dari dirnamemenjadi tidak berarti.

Saya menyarankan yang berikut ini:

#!/bin/bash

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

echo "Directory is $directory"

Dengan cara ini, Anda mendapatkan direktori absolut, bukan relatif.

Karena skrip akan dijalankan dalam instance bash yang terpisah, tidak perlu mengembalikan direktori kerja setelahnya, tetapi jika Anda ingin mengubah kembali skrip Anda karena suatu alasan, Anda dapat dengan mudah menetapkan nilai pwdke variabel sebelum Anda ubah direktori, untuk penggunaan di masa mendatang.

Meski baru saja

cd `dirname $0`

Memecahkan skenario spesifik dalam pertanyaan, saya menemukan memiliki jalur absolut untuk lebih bermanfaat secara umum.

Saya bosan datang ke halaman ini berulang-ulang untuk menyalin rekatkan satu baris dalam jawaban yang diterima. Masalah dengan itu adalah tidak mudah dipahami dan diingat.

Berikut ini skrip yang mudah diingat:

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

Saya tidak berpikir ini semudah yang lain. pwdtidak berfungsi, karena direktori saat ini belum tentu direktori dengan skrip. $0tidak selalu memiliki informasi juga. Pertimbangkan tiga cara berikut untuk menjalankan skrip:

./script

/usr/bin/script

script

Dalam cara pertama dan ketiga $0tidak memiliki informasi jalur lengkap. Di kedua dan ketiga, pwdtidak berfungsi. Satu-satunya cara untuk mendapatkan direktori dengan cara ketiga adalah menjalankan melalui jalur dan menemukan file dengan kecocokan yang benar. Pada dasarnya kode harus mengulang apa yang dilakukan OS.

Salah satu cara untuk melakukan apa yang Anda minta adalah dengan hanya meng-hardcode data dalam /usr/sharedirektori, dan merujuknya dengan path lengkapnya. Data tidak boleh ada di /usr/bindirektori, jadi ini mungkin yang harus dilakukan.

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

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

Ini mendapatkan direktori aktif saat ini di Mac OS X 10.6.6:

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

Ini khusus untuk Linux, tetapi Anda dapat menggunakan:

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

Berikut ini adalah one-liner yang sesuai dengan POSIX:

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

# test
echo $SCRIPT_PATH

Saya mencoba semua ini dan tidak ada yang berhasil. Satu sangat dekat tetapi memiliki bug kecil yang memecahkannya dengan buruk; mereka lupa membungkus jalan dalam tanda kutip.

Juga banyak orang beranggapan Anda menjalankan skrip dari shell sehingga mereka lupa ketika Anda membuka skrip baru, skrip ini default untuk rumah Anda.

Coba direktori ini untuk ukuran:

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

Ini membuatnya benar terlepas dari bagaimana atau di mana Anda menjalankannya:

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

Jadi untuk membuatnya benar-benar berguna, inilah cara mengubah ke direktori skrip yang sedang berjalan:

cd "`dirname "$0"`"

Inilah cara sederhana dan benar:

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

Penjelasan:

• ${BASH_SOURCE[0]}- jalur lengkap ke skrip. Nilai ini akan benar bahkan ketika skrip sedang bersumber, misalnya source <(echo 'echo $0')mencetak bash , sementara menggantinya dengan ${BASH_SOURCE[0]}akan mencetak path lengkap skrip. (Tentu saja, ini mengasumsikan Anda baik-baik saja bergantung pada Bash.)

• readlink -f- Secara rekursif menyelesaikan setiap symlink di jalur yang ditentukan. Ini adalah ekstensi GNU, dan tidak tersedia pada (misalnya) sistem BSD. Jika Anda menjalankan Mac, Anda dapat menggunakan Homebrew untuk menginstal GNU coreutilsdan menggantikannya dengan ini greadlink -f.

• Dan tentu saja dirnamemendapatkan direktori induk dari path.

Cara terpendek dan paling elegan untuk melakukan ini adalah:

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

Ini akan bekerja pada semua platform dan sangat bersih.

Rincian lebih lanjut dapat ditemukan di " Direktori tempat skrip bash itu berada? ".

Saya akan menggunakan sesuatu seperti ini:

# 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

Ini adalah sedikit revisi terhadap solusi yang ditunjukkan e-satis dan 3bcdnlklvc04a dalam jawaban mereka :

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

Ini harus tetap bekerja dalam semua kasus yang mereka daftarkan.

Ini akan mencegah popdsetelah gagal pushd, berkat konsolebox.

Untuk sistem yang memiliki GNU coreutils readlink(mis. Linux):

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

Tidak perlu digunakan BASH_SOURCEsaat $0berisi nama file skrip.

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

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

scriptdir=`dirname "$PRG"`

$_layak disebut sebagai alternatif $0. Jika Anda menjalankan skrip dari Bash, jawaban yang diterima dapat disingkat menjadi:

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

Perhatikan bahwa ini harus menjadi pernyataan pertama dalam skrip Anda.

Saya telah membandingkan banyak jawaban yang diberikan, dan menghasilkan beberapa solusi yang lebih ringkas. Ini tampaknya menangani semua kasus tepi gila yang muncul dari kombinasi favorit Anda:

• Jalur absolut atau jalur relatif
• File dan direktori soft link
• Doa sebagai script, bash script, bash -c script, source script, atau. script
• Spasi, tab, baris baru, unicode, dll dalam direktori dan / atau nama file
• Nama file dimulai dengan tanda hubung

Jika Anda menjalankan dari Linux, tampaknya menggunakan procgagang adalah solusi terbaik untuk menemukan sumber skrip yang saat ini sedang berjalan (dalam sesi interaktif, tautan menunjuk ke masing-masing /dev/pts/X):

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

Ini memiliki sedikit keburukan untuk itu, tetapi perbaikannya kompak dan mudah dimengerti. Kami tidak menggunakan primitif bash saja, tapi saya setuju dengan itu karena readlinkmenyederhanakan tugas. The echo Xmenambahkan Xke akhir string variabel sehingga setiap spasi membuntuti di nama file tidak dimakan, dan substitusi parameter ${VAR%X}pada akhir baris akan menyingkirkan X. Karena readlinkmenambahkan baris baru sendiri (yang biasanya akan dimakan dalam penggantian perintah jika bukan karena tipu daya kita sebelumnya), kita harus menyingkirkan itu juga. Ini paling mudah dilakukan dengan menggunakan $''skema penawaran, yang memungkinkan kita menggunakan urutan pelarian seperti\n untuk merepresentasikan baris baru (ini juga cara Anda dapat dengan mudah membuat direktori dan file yang dinamai secara licik)

Hal di atas harus mencakup kebutuhan Anda untuk menemukan skrip yang saat ini berjalan di Linux, tetapi jika Anda tidak memiliki sistem procfile yang Anda inginkan, atau jika Anda mencoba untuk menemukan jalur yang diselesaikan sepenuhnya dari beberapa file lain, maka mungkin Anda akan temukan kode di bawah ini bermanfaat. Ini hanya sedikit modifikasi dari liner satu di atas. Jika Anda bermain-main dengan direktori / nama file aneh, memeriksa output dengan keduanya lsdan readlinkinformatif, karena lsakan menampilkan jalur "disederhanakan", menggantikan ?hal-hal seperti baris baru.

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"

Coba gunakan:

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

Coba solusi lintas-kompatibel berikut:

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

karena perintah seperti realpathatau readlinkmungkin tidak tersedia (tergantung pada sistem operasi).

Catatan: Di Bash, disarankan untuk menggunakan ${BASH_SOURCE[0]}alih-alih $0, jika tidak jalur dapat rusak saat sumber file ( source/ .).

Atau Anda dapat mencoba fungsi berikut di bash:

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

Fungsi ini membutuhkan 1 argumen. Jika argumen sudah memiliki path absolut, cetaklah sebagaimana adanya, jika tidak, cetak $PWDargumen variabel + nama file (tanpa ./awalan).

Terkait:

• Bagaimana cara mengatur direktori kerja saat ini ke direktori skrip?
• Bash script absolute path dengan OS X
• Cara yang andal untuk skrip Bash untuk mendapatkan path lengkap ke skrip itu sendiri

Saya percaya saya punya yang ini. Saya terlambat ke pesta, tapi saya pikir beberapa akan menghargai itu ada di sini jika mereka menemukan utas ini. Komentar harus menjelaskan:

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

Ini adalah cara singkat untuk mendapatkan informasi skrip:

Folder dan file:

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

Menggunakan perintah ini:

    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`

Dan saya mendapat hasil ini:

     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

Lihat juga: https://pastebin.com/J8KjxrPF

Ini bekerja di bash-3.2:

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

Jika Anda memiliki ~/bindirektori di $PATH, Anda ada Adi dalam direktori ini. Sumber skrip ~/bin/lib/B. Anda tahu di mana skrip yang disertakan relatif terhadap yang asli, di libsubdirektori, tetapi tidak di mana itu relatif terhadap direktori pengguna saat ini.

Ini dipecahkan oleh yang berikut (di dalam A):

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

Tidak masalah di mana pengguna berada atau bagaimana ia memanggil skrip, ini akan selalu berfungsi.

Solusi ringkas terbaik menurut saya adalah:

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

Tidak ada ketergantungan pada apa pun selain Bash. Penggunaan dirname, readlinkdan basenamepada akhirnya akan mengarah pada masalah kompatibilitas, jadi sebaiknya dihindari jika keadaan memungkinkan.