Команда dirname является самой простой, она просто анализирует путь до имени файла вне $0 (имя скрипта) переменная:

dirname "$0"

Но, как указал matt b, возвращаемый путь различается в зависимости от того, как вызывается скрипт. pwd не выполняет эту работу, потому что он сообщает вам только текущий каталог, а не каталог, в котором находится скрипт. Кроме того, если выполняется символическая ссылка на скрипт, вы получите (возможно, относительный) путь туда, где находится ссылка, а не на сам скрипт.

Некоторые другие упоминали команду readlink, но в простейшем случае вы можете использовать:

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

readlink преобразует путь скрипта в абсолютный путь от корня файловой системы. Таким образом, любые пути, содержащие одинарные или двойные точки, тильды и / или символические ссылки, будут преобразованы в полный путь.

Вот сценарий, демонстрирующий каждый из них, 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))"

Запуск этого скрипта в моем домашнем каталоге с использованием относительного пути:

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

Опять же, но используя полный путь к скрипту:

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

Теперь меняем каталоги:

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

И, наконец, используя символическую ссылку для выполнения скрипта:

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

Работает для всех версий, включая

• при вызове через мягкую ссылку с несколькими глубинами,
• когда файл это
• когда сценарий вызывается командой source или оператором . (точка).
• когда arg $0 изменен из вызывающего абонента.
• "./script"
• "/full/path/to/script"
• "/some/path/../../another/path/script"
• "./some/folder/script"

В качестве альтернативы, если сам сценарий Bash является относительной символической ссылкой, вы хотите следовать по ней и возвращать полный путь связанного сценария:

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_PATH задается полным путем, как бы он ни назывался.

Просто убедитесь, что вы нашли это в начале скрипта.

Вы можете использовать $BASH_SOURCE:

#!/bin/bash

scriptdir=`dirname "$BASH_SOURCE"`

Обратите внимание, что вам нужно использовать #!/bin/bash, а не #!/bin/sh, поскольку это расширение Bash.

Короткий ответ:

`dirname $0`

или (желательно):

$(dirname "$0")

Это должно сделать это:

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

Это работает с символическими ссылками и пробелами в пути.

См. Справочные страницы для dirname и readlink.

Судя по дорожке комментариев, похоже, что это не работает с Mac OS. Понятия не имею, почему это так. Какие-либо предложения?

Вот простой для запоминания сценарий:

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

pwd можно использовать для поиска текущего рабочего каталога, а dirname - для поиска каталога определенного файла (запущенная команда - $0, поэтому dirname $0 должна предоставить вам каталог текущего сценария).

Однако dirname точно указывает часть имени файла, относящуюся к каталогу, которая, скорее всего, будет относиться к текущему рабочему каталогу. Если вашему сценарию по какой-то причине необходимо сменить каталог, то вывод dirname станет бессмысленным.

Предлагаю следующее:

#!/bin/bash

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

echo "Directory is $directory"

Таким образом, вы получите абсолютный, а не относительный каталог.

Поскольку скрипт будет запущен в отдельном экземпляре Bash, впоследствии нет необходимости восстанавливать рабочий каталог, но если вы по какой-то причине все же захотите вернуться в свой скрипт, вы можете легко присвоить значение pwd параметру перед сменой каталога для использования в будущем.

Хотя просто

cd `dirname $0`

решает конкретный сценарий в вопросе, я считаю, что абсолютный путь к более полезным в целом.

Я не думаю, что это так просто, как думали другие. pwd не работает, поскольку текущий каталог не обязательно является каталогом со сценарием. $0 тоже не всегда владеет информацией. Рассмотрим следующие три способа вызвать сценарий:

./script

/usr/bin/script

script

В первом и третьем способах $0 не имеет полной информации о пути. Во втором и третьем pwd не работает. Единственный способ получить каталог третьим способом - это просмотреть путь и найти файл с правильным соответствием. В основном код должен повторять то, что делает ОС.

Один из способов сделать то, что вы просите, - просто жестко закодировать данные в каталоге /usr/share и ссылаться на них по их полному пути. В любом случае данных не должно быть в каталоге /usr/bin, так что, вероятно, это то, что нужно сделать.

Это получает текущий рабочий каталог в Mac OS X v10.6.6 (Snow Leopard):

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

Это специфично для Linux, но вы можете использовать:

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

Вот однострочник, совместимый с POSIX:

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

# test
echo $SCRIPT_PATH

Самый короткий и элегантный способ сделать это:

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

Это будет работать на всех платформах и очень чисто.

Более подробную информацию можно найти в разделе «В каком каталоге находится этот сценарий bash?».

Я пробовал все это, и ни один из них не работал. Один был очень близок, но в нем был крошечный жучок, который его сильно сломал; они забыли заключить путь в кавычки.

Также многие люди предполагают, что вы запускаете скрипт из оболочки, поэтому они забывают, что когда вы открываете новый скрипт, он по умолчанию находится у вас дома.

Примерьте размер этого каталога:

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

Это правильно, независимо от того, как и где вы его запускаете:

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

Чтобы сделать его действительно полезным, вот как перейти в каталог запущенного скрипта:

cd "`dirname "$0"`"

Вот простой и правильный способ:

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

Объяснение:

• ${BASH_SOURCE[0]} - полный путь к скрипту. Значение этого будет правильным, даже если скрипт получен, например source <(echo 'echo $0') выводит bash, а при замене его на ${BASH_SOURCE[0]} выводится полный путь к сценарию. (Конечно, это предполагает, что вы согласны с зависимостью от Bash.)

• readlink -f - рекурсивно разрешает все символические ссылки в указанном пути. Это расширение GNU, которое недоступно (например) в системах BSD. Если вы используете Mac, вы можете использовать Homebrew для установки GNU coreutils и заменить его на greadlink -f.

• И, конечно же, dirname получает родительский каталог пути.

Это небольшая переработка решения e-satis и 3bcdnlklvc04a, указанного в их ответ:

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

Это должно работать во всех перечисленных случаях.

Это предотвратит popd после неудачного pushd. Спасибо консольбоксу.

Я бы использовал что-то вроде этого:

# 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

Для систем с GNU coreutils readlink (например, Linux):

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

Нет необходимости использовать BASH_SOURCE, если $0 содержит имя файла сценария.

$_ заслуживает упоминания в качестве альтернативы $0. Если вы запускаете скрипт из Bash, принятый ответ можно сократить до:

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

Обратите внимание, что это должен быть первый оператор в вашем скрипте.

Это короткие способы получить информацию о скрипте:

Папки и файлы:

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

Используя эти команды:

    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`

И я получил такой вывод:

     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

См. Также: https://pastebin.com/J8KjxrPF

Это работает в Bash 3.2:

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

Если у вас есть каталог ~/bin в вашем $PATH, у вас есть A внутри этого каталога. Он является источником сценария ~/bin/lib/B. Вы знаете, где находится включенный сценарий относительно исходного, в подкаталоге lib, но не знаете, где он находится относительно текущего каталога пользователя.

Это решается следующим образом (внутри A):

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

Неважно, где находится пользователь и как он вызывает сценарий. Это всегда будет работать.

Попробуйте использовать:

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

Я сравнил многие из полученных ответов и нашел несколько более компактных решений. Кажется, они справятся со всеми безумными крайними случаями, возникающими из вашей любимой комбинации:

• Абсолютные пути или относительные пути
• Программные ссылки файлов и каталогов
• Вызов как script, bash script, bash -c script, source script или . script
• Пробелы, табуляции, символы новой строки, Unicode и т. Д. В каталогах и / или имени файла
• Имена файлов, начинающиеся с дефиса

Если вы работаете из Linux, кажется, что использование дескриптора proc - лучшее решение для поиска полностью разрешенного источника текущего выполняемого скрипта (в интерактивном сеансе ссылка указывает на соответствующий /dev/pts/X):

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

Это немного некрасиво, но исправление компактно и легко для понимания. Мы не используем только примитивы bash, но меня это устраивает, потому что readlink значительно упрощает задачу. echo X добавляет X в конец строки переменной, чтобы любые конечные пробелы в имени файла не были съедены, а подстановка параметра ${VAR%X} в конце строки избавляет от X. Поскольку readlink добавляет собственную новую строку (которая обычно была бы съедена при подстановке команд, если бы не наш предыдущий обман), мы должны избавиться и от этого. Это проще всего сделать с помощью схемы $'' цитирования, которая позволяет нам использовать escape-последовательности, такие как \n, для представления новой строки (это также то, как вы можете легко создавать каталоги и файлы с хитрыми именами).

Вышеупомянутое должно охватывать ваши потребности в поиске запущенного в данный момент скрипта в Linux, но если в вашем распоряжении нет proc файловой системы или если вы пытаетесь найти полностью разрешенный путь к какому-то другому файлу, тогда, возможно, вы ' Вам будет полезен приведенный ниже код. Это всего лишь небольшая модификация по сравнению с приведенным выше однострочником. Если вы играете со странными каталогами / именами файлов, проверка вывода как с ls, так и с readlink будет информативной, поскольку ls будет выводить упрощенные пути, заменяя ? на такие вещи, как новые строки.

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"

Я считаю, что у меня есть этот. Я опаздываю на вечеринку, но я думаю, что некоторые будут благодарны за то, что я здесь, если они натолкнутся на эту тему. Комментарии должны объяснять:

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

Как получить полный путь к файлу, полный каталог и базовое имя файла для любого запускаемого скрипта

Во многих случаях все, что вам нужно получить, - это полный путь к только что вызванному сценарию. Это легко сделать с помощью realpath. Обратите внимание, что realpath является частью GNU coreutils. Если он у вас еще не установлен (по умолчанию в Ubuntu), вы можете установить его с помощью sudo apt update && sudo apt install coreutils.

get_script_path.sh:

#!/bin/bash

FULL_PATH_TO_SCRIPT="$(realpath "$0")"

# You can then also get the full path to the directory, and the base
# filename, like this:
SCRIPT_DIRECTORY="$(dirname "$FULL_PATH_TO_SCRIPT")"
SCRIPT_FILENAME="$(basename "$FULL_PATH_TO_SCRIPT")"

# Now print it all out
echo "FULL_PATH_TO_SCRIPT = \"$FULL_PATH_TO_SCRIPT\""
echo "SCRIPT_DIRECTORY    = \"$SCRIPT_DIRECTORY\""
echo "SCRIPT_FILENAME     = \"$SCRIPT_FILENAME\""

Пример вывода:

~/GS/dev/eRCaGuy_hello_world/bash$ ./get_script_path.sh 
FULL_PATH_TO_SCRIPT = "/home/gabriel/GS/dev/eRCaGuy_hello_world/bash/get_script_path.sh"
SCRIPT_DIRECTORY    = "/home/gabriel/GS/dev/eRCaGuy_hello_world/bash"
SCRIPT_FILENAME     = "get_script_path.sh"

Обратите внимание, что realpath также успешно переходит по символическим ссылкам, чтобы определять и указывать на их цели, а не указывать на символическую ссылку.

Приведенный выше код теперь является частью моего репозитория eRCaGuy_hello_world в этом файле здесь: bash / get_script_path.sh.

Использованная литература:

1. Как получить абсолютный путь, заданный относительным

Попробуйте следующее кросс-совместимое решение:

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

Поскольку такие команды, как realpath или readlink, могут быть недоступны (в зависимости от операционной системы).

Примечание. В Bash рекомендуется использовать ${BASH_SOURCE[0]} вместо $0, иначе путь может нарушиться при поиске файла (_6 _ / _ 7_).

В качестве альтернативы вы можете попробовать следующую функцию в Bash:

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

Эта функция принимает один аргумент. Если аргумент уже имеет абсолютный путь, выведите его как есть, иначе выведите $PWD переменную + аргумент имени файла (без префикса ./).

Связанный:

• Как установить текущий рабочий каталог в каталог сценария в Bash?
• Абсолютный путь сценария Bash в OS X
• Надежный способ для сценария Bash получить полный путь к самому себе

Хм, если в пути basename и _ 2_ просто не собираются его сокращать, и идти по пути сложно (что, если родительский элемент не экспортировал PATH ?!) .

Однако оболочка должна иметь открытый дескриптор своего скрипта, а в Bash дескриптор # 255.

SELF=`readlink /proc/$$/fd/255`

работает для меня.

На мой взгляд, лучшим компактным решением было бы:

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

Ни на что не полагайтесь, кроме Bash. Использование dirname, _ 3_ и basename в конечном итоге приведет к проблемам совместимости, поэтому их лучше избегать, если это вообще возможно.

Вы можете сделать это, просто объединив имя сценария ($0) с realpath и / или _ 3_. Это работает для Bash и Shell.

#!/usr/bin/env bash

RELATIVE_PATH="${0}"
RELATIVE_DIR_PATH="$(dirname "${0}")"
FULL_DIR_PATH="$(realpath "${0}" | xargs dirname)"
FULL_PATH="$(realpath "${0}")"

echo "RELATIVE_PATH->${RELATIVE_PATH}<-"
echo "RELATIVE_DIR_PATH->${RELATIVE_DIR_PATH}<-"
echo "FULL_DIR_PATH->${FULL_DIR_PATH}<-"
echo "FULL_PATH->${FULL_PATH}<-"

Результат будет примерно таким:

# RELATIVE_PATH->./bin/startup.sh<-
# RELATIVE_DIR_PATH->./bin<-
# FULL_DIR_PATH->/opt/my_app/bin<-
# FULL_PATH->/opt/my_app/bin/startup.sh<-

$ 0 - это имя самого скрипта

4.4. Специальные типы переменных

Пример: LozanoMatheus / get_script_paths.sh

Это сработало для меня, когда другие ответы здесь не работали:

thisScriptPath=`realpath $0`
thisDirPath=`dirname $thisScriptPath`
echo $thisDirPath

Ни один из этих других ответов не работал для сценария Bash, запущенного Finder в OS X. В итоге я использовал:

SCRIPT_LOC="`ps -p $$ | sed /PID/d | sed s:.*/Network/:/Network/: |
sed s:.*/Volumes/:/Volumes/:`"

Это некрасиво, но выполняет свою работу.

Используйте комбинацию ссылки для чтения, чтобы канонизировать имя (с бонусом в виде повторного перехода к его источник, если это символическая ссылка) и dirname для извлечения имени каталога:

script="`readlink -f "${BASH_SOURCE[0]}"`"
dir="`dirname "$script"`"

Я нашел единственный способ достоверно сказать:

SCRIPT_DIR=$(dirname $(cd "$(dirname "$BASH_SOURCE")"; pwd))

Обычно я использую:

dirname $(which $BASH_SOURCE)

Ни одно из текущих решений не работает, если в конце имени каталога есть символы новой строки - они будут удалены при подстановке команды. Чтобы обойти это, вы можете добавить символ, не являющийся новой строкой, внутри подстановки команды, а затем удалить только этот символ:

dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd && echo x)"
dir="${dir%x}"

Это защищает от двух очень распространенных ситуаций: несчастных случаев и саботажа. Сценарий не должен непредсказуемо давать сбой только потому, что кто-то где-то сделал mkdir $'\n'.

Верхний ответ работает не во всех случаях ...

Поскольку у меня были проблемы с BASH_SOURCE с включенным подходом cd на некоторых очень свежих, а также на менее свежих версиях Ubuntu 16.04 (Xenial Xerus) при вызове сценария оболочки с помощью sh my_script.sh я попробовал кое-что другое, что на данный момент, кажется, работает довольно гладко для моих целей. Подход немного более компактный в сценарии и, кроме того, вызывает гораздо меньшее загадочное ощущение.

В этом альтернативном подходе используются внешние приложения 'realpath' и 'dirname 'из пакета coreutils. (Хорошо, никому не нравятся накладные расходы, связанные с вызовом вторичных процессов, но при просмотре многострочного сценария для разрешения истинного объекта это будет не так уж плохо, если он будет решен за одно двоичное использование.)

Итак, давайте посмотрим на один пример альтернативного решения описанной задачи запроса истинного абсолютного пути к определенному файлу:

PATH_TO_SCRIPT=`realpath -s $0`
PATH_TO_SCRIPT_DIR=`dirname $PATH_TO_SCRIPT`

Но желательно использовать эту усовершенствованную версию, чтобы также поддерживать использование путей с пробелами (или, может быть, даже некоторых других специальных символов):

PATH_TO_SCRIPT=`realpath -s "$0"`
PATH_TO_SCRIPT_DIR=`dirname "$PATH_TO_SCRIPT"`

В самом деле, если вам не нужно значение переменной SCRIPT, вы можете объединить этот двухстрочный файл даже в одну строку. Но зачем вам тратить на это усилия?

$0 - ненадежный способ получить текущий путь к скрипту. Например, это мой .xprofile:

#!/bin/bash
echo "$0 $1 $2"
echo "${BASH_SOURCE[0]}"
# $dir/my_script.sh &

cd / tmp && ~ / .xprofile && source ~ / .xprofile

/home/puchuu/.xprofile
/home/puchuu/.xprofile
-bash
/home/puchuu/.xprofile

Поэтому используйте вместо этого BASH_SOURCE.

Следующее вернет текущий каталог скрипта

• работает, если он получен или не получен
• работает, если запускается в текущем или другом каталоге.
• работает, если используются относительные каталоги.
• работает с bash, не уверен в других оболочках.

/tmp/a/b/c $ . ./test.sh
/tmp/a/b/c

/tmp/a/b/c $ . /tmp/a/b/c/test.sh
/tmp/a/b/c

/tmp/a/b/c $ ./test.sh
/tmp/a/b/c

/tmp/a/b/c $ /tmp/a/b/c/test.sh
/tmp/a/b/c

/tmp/a/b/c $ cd

~ $ . /tmp/a/b/c/test.sh
/tmp/a/b/c

~ $ . ../../tmp/a/b/c/test.sh
/tmp/a/b/c

~ $ /tmp/a/b/c/test.sh
/tmp/a/b/c

~ $ ../../tmp/a/b/c/test.sh
/tmp/a/b/c

test.sh

#!/usr/bin/env bash

# snagged from: https://stackoverflow.com/a/51264222/26510
function toAbsPath {
    local target
    target="$1"

    if [ "$target" == "." ]; then
        echo "$(pwd)"
    elif [ "$target" == ".." ]; then
        echo "$(dirname "$(pwd)")"
    else
        echo "$(cd "$(dirname "$1")"; pwd)/$(basename "$1")"
    fi
}

function getScriptDir(){
  local SOURCED
  local RESULT
  (return 0 2>/dev/null) && SOURCED=1 || SOURCED=0

  if [ "$SOURCED" == "1" ]
  then
    RESULT=$(dirname "$1")
  else
    RESULT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
  fi
  toAbsPath "$RESULT"
}

SCRIPT_DIR=$(getScriptDir "$0")
echo "$SCRIPT_DIR"

Это решение применимо только к Bash. Обратите внимание, что обычно предоставляемый ответ ${BASH_SOURCE[0]} не будет работать, если вы попытаетесь найти путь из функции.

Я обнаружил, что эта строка работает всегда, независимо от того, был ли файл получен или запущен как сценарий.

dirname ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}

Если вы хотите следовать символическим ссылкам, используйте readlink по указанному выше пути, рекурсивно или без -рекурсивно.

Вот сценарий, чтобы опробовать его и сравнить с другими предлагаемыми решениями. Вызовите его как source test1/test2/test_script.sh или bash test1/test2/test_script.sh.

#
# Location: test1/test2/test_script.sh
#
echo $0
echo $_
echo ${BASH_SOURCE}
echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}

cur_file="${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}"
cur_dir="$(dirname "${cur_file}")"
source "${cur_dir}/func_def.sh"

function test_within_func_inside {
    echo ${BASH_SOURCE}
    echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}
}

echo "Testing within function inside"
test_within_func_inside

echo "Testing within function outside"
test_within_func_outside

#
# Location: test1/test2/func_def.sh
#
function test_within_func_outside {
    echo ${BASH_SOURCE}
    echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}
}

Причина, по которой работает однострочник, объясняется использованием переменной среды BASH_SOURCE и связанной с ней FUNCNAME.

BASH_SOURCE

Переменная массива, членами которой являются имена исходных файлов, в которых определены соответствующие имена функций оболочки в переменной массива FUNCNAME. Функция оболочки $ {FUNCNAME [$ i]} определена в файле $ {BASH_SOURCE [$ i]} и вызывается из $ {BASH_SOURCE [$ i + 1]}.

FUNCNAME

Переменная массива, содержащая имена всех функций оболочки, находящихся в настоящее время в стеке вызовов выполнения. Элемент с индексом 0 - это имя любой выполняющейся в данный момент функции оболочки. Самый нижний элемент (с наивысшим индексом) является основным. Эта переменная существует только при выполнении функции оболочки. Назначение FUNCNAME не имеет никакого эффекта и возвращает статус ошибки. Если FUNCNAME не задано, он теряет свои особые свойства, даже если впоследствии будет сброшен.

Эту переменную можно использовать с BASH_LINENO и BASH_SOURCE. Каждый элемент FUNCNAME имеет соответствующие элементы в BASH_LINENO и BASH_SOURCE для описания стека вызовов. Например, $ {FUNCNAME [$ i]} был вызван из файла $ {BASH_SOURCE [$ i + 1]} в строке номер $ {BASH_LINENO [$ i]}. Встроенная функция вызывающего абонента отображает текущий стек вызовов, используя эту информацию.

[Источник: руководство Bash]

Если ваш сценарий Bash является символической ссылкой, то это можно сделать следующим образом:

#!/usr/bin/env bash

dirn="$(dirname "$0")"
rl="$(readlink "$0")";
exec_dir="$(dirname $(dirname "$rl"))";
my_path="$dirn/$exec_dir";
X="$(cd $(dirname ${my_path}) && pwd)/$(basename ${my_path})"

X - это каталог, содержащий ваш сценарий Bash (исходный файл, а не символическую ссылку). Клянусь Богом, это работает, и это единственный способ сделать это правильно.

Вот команда, которая работает как в Bash, так и в zsh, независимо от того, выполняется она автономно или из источника:

[ -n "$ZSH_VERSION" ] && this_dir=$(dirname "${(%):-%x}") \
    || this_dir=$(dirname "${BASH_SOURCE[0]:-$0}")

Как это работает

Текущее расширение файла zsh: ${(%):-%x}

${(%):-%x} в zsh заменяется на путь к исполняемому в данный момент файлу.

Оператор резервной замены :-

Вы уже знаете, что ${...} заменяет переменные внутри строк. Вы могли не знать, что некоторые операции возможны (как в Bash, так и zsh) для переменных во время подстановки, например резервное раскрытие. оператор :-:

% x=ok
% echo "${x}"
ok

% echo "${x:-fallback}"
ok

% x=
% echo "${x:-fallback}"
fallback

% y=yvalue
% echo "${x:-$y}"
yvalue

Escape-код приглашения %x

Далее мы познакомим вас с кодами быстрого перехода, которые доступны только для zsh. В zsh %x будет расширяться до пути к файлу, но обычно это происходит только при расширении для строки приглашения. Чтобы включить эти коды в нашу замену, мы можем добавить флаг (%) перед именем переменной:

% cat apath/test.sh
fpath=%x
echo "${(%)fpath}"

% source apath/test.sh
apath/test.sh

% cd apath
% source test.sh
test.sh

Маловероятное совпадение: процент выхода и откат

То, что у нас есть, работает, но было бы проще избежать создания дополнительной переменной fpath. Вместо того, чтобы помещать %x в fpath, мы можем использовать :- и поместить %x в резервную строку:

% cat test.sh
echo "${(%):-%x}"

% source test.sh
test.sh

Обратите внимание, что обычно мы помещаем имя переменной между (%) и :-, но мы оставили его пустым. Переменная с пустым именем не может быть объявлена ​​или установлена, поэтому откат всегда срабатывает.

Завершение: как насчет print -P %x?

Теперь у нас почти есть каталог нашего скрипта. Мы могли бы использовать print -P %x, чтобы получить тот же путь к файлу с меньшим количеством взломов, но в нашем случае, когда нам нужно передать его в качестве аргумента для dirname, это потребовало бы накладных расходов на запуск новой подоболочки:

% cat apath/test.sh
dirname "$(print -P %x)"  # $(...) runs a command in a new process
dirname "${(%):-%x}"

% source apath/test.sh
apath
apath

Оказывается, хакерский способ одновременно более производительный и лаконичный.

Python упоминался несколько раз. Вот альтернатива JavaScript (т.е. Node.js):

baseDirRelative=$(dirname "$0")
baseDir=$(node -e "console.log(require('path').resolve('$baseDirRelative'))") # Get absolute path using Node.js

echo $baseDir

Я попробовал следующее с 3 разными исполнениями.

echo $(realpath $_)

. application         # /correct/path/to/dir or /path/to/temporary_dir
bash application      # /path/to/bash
/PATH/TO/application  # /correct/path/to/dir

echo $(realpath $(dirname $0))

. application         # failed with `realpath: missing operand`
bash application      # /correct/path/to/dir
/PATH/TO/application  # /correct/path/to/dir

echo $(realpath $BASH_SOURCE)

$BASH_SOURCE в основном то же самое с ${BASH_SOURCE[0]}.

. application         # /correct/path/to/dir
bash application      # /correct/path/to/dir
/PATH/TO/application  # /correct/path/to/dir

Только $(realpath $BASH_SOURCE) кажется надежным.

Одно из преимуществ этого метода заключается в том, что он не задействует ничего, кроме самого Bash, и не создает никакой подоболочки.

Во-первых, используйте подстановку шаблона, чтобы заменить все, что не начинается с / (т. Е. Относительный путь), на $PWD/. Поскольку мы используем подстановку, чтобы соответствовать первому символу $0, мы также должны добавить его обратно (${0:0:1} в подстановке).

Теперь у нас есть полный путь к скрипту; мы можем получить каталог, удалив последний / и все, что следует за ним (т.е. имя скрипта). Затем этот каталог можно использовать в cd или в качестве префикса для других путей относительно вашего скрипта.

#!/bin/bash

BIN=${0/#[!\/]/"$PWD/${0:0:1}"}
DIR=${BIN%/*}

cd "$DIR"

Если ваш сценарий может быть получен, а не выполнен, вы, конечно, можете заменить $0 на ${BASH_SOURCE[0]}, например:

BIN=${BASH_SOURCE[0]/#[!\/]/"$PWD/${BASH_SOURCE[0]:0:1}"}

Это также будет работать для исполняемых скриптов. Он длиннее, но более поливалентен.

Большинство ответов либо не обрабатывают файлы, которые связаны символическими ссылками через относительный путь, не являются однострочными, либо не обрабатывают BSD (Mac). Решение, которое делает все три:

HERE=$(cd "$(dirname "$BASH_SOURCE")"; cd -P "$(dirname "$(readlink "$BASH_SOURCE" || echo .)")"; pwd)

Во-первых, cd к концепции каталога сценария в bash. Затем прочтите ссылку на файл, чтобы увидеть, является ли это символической ссылкой (относительной или иной), и если да, перейдите в этот каталог. Если нет, перейдите в текущий каталог (необходимо, чтобы все было однострочным). Затем отобразите текущий каталог через pwd.

Вы можете добавить -- к аргументам cd и readlink, чтобы избежать проблем с каталогами, названными как options, но я не беспокоюсь для большинства целей.

Вы можете увидеть полное объяснение с иллюстрациями здесь:

https://www.binaryphile.com/bash/2020/01/12/determining-the-location-of-your-script-in-bash.html

Это, к сожалению, единственный однострочник, который я обнаружил, который работает как в Linux, так и в macOS, когда исполняемый скрипт представляет собой символическую ссылку:

SCRIPT_DIR=$(python -c "import os, sys; print(os.path.dirname(os.path.realpath('${BASH_SOURCE[0]}')))")

Протестировано на Linux и macOS и сравнивается с другими решениями в этом разделе: https://gist.github.com/ptc-mrucci/61772387878ed53a6c717d51a21d9371

Вот как я работаю над своими скриптами:

pathvar="$( cd "$( dirname $0 )" && pwd )"

Это сообщит вам, из какого каталога запускается программа запуска (текущий скрипт).

Я обычно делаю:

LIBDIR=$(dirname "$(readlink -f "$(type -P $0 || echo $0)")")
source $LIBDIR/lib.sh

Вот чистое решение Bash

$ cat a.sh
BASENAME=${BASH_SOURCE/*\/}
DIRNAME=${BASH_SOURCE%$BASENAME}.
echo $DIRNAME

$ a.sh
/usr/local/bin/.

$ ./a.sh
./.

$ . a.sh
/usr/local/bin/.

$ /usr/local/bin/a.sh
/usr/local/bin/.

Вот выдержка из моего ответа на сценарий оболочки: проверить имя каталога и преобразовать его в нижний регистр, в котором я демонстрирую не только то, как решить эту проблему с помощью очень простых утилит, указанных в POSIX, я также обращаюсь к , как очень просто сохранить результаты функции в возвращаемом переменная ...

... Как видите, с некоторой помощью я нашел довольно простое и очень мощное решение:

Я могу передать функции своего рода переменную мессенджера и разыменовать любое явное использование $1 имени результирующего аргумента функции с eval по мере необходимости, а по завершении подпрограммы функции я использую eval и трюк с цитированием с обратной косой чертой присвоить моей переменной-мессенджеру желаемое значение, даже не зная его имени.

С полным раскрытием, ... (я нашел в этом разделе переменную мессенджера) и на трюки Рича и я также привел выдержку из соответствующей части его страницы под выдержкой из моего собственного ответа.

... ВЫДЕРЖКА: ...

Хотя это еще не строго POSIX, realpath является основным приложением GNU с 2012 года. Полное раскрытие: никогда не слышал об этом, прежде чем заметил это в info coreutils TOC и сразу подумал о [связанном] вопросе, но использование следующей функции, как показано, должно надежно (скоро POSIXLY?) И, я надеюсь, эффективно предоставить ее вызывающему с абсолютно исходным $0:

% _abs_0() {
> o1="${1%%/*}"; ${o1:="${1}"}; ${o1:=`realpath -s "${1}"`}; eval "$1=\${o1}";
> }
% _abs_0 ${abs0:="${0}"} ; printf %s\\n "${abs0}"
/no/more/dots/in/your/path2.sh

Возможно, стоит отметить, что это решение использует расширение параметра POSIX. чтобы сначала проверить, действительно ли путь нуждается в расширении и разрешении, прежде чем пытаться это сделать. Это должно вернуть $0 с абсолютным источником $0 через переменную мессенджера (с заметным исключением, что он сохранит symlinks) так эффективно, насколько я мог себе представить. выполняется независимо от того, является ли путь уже абсолютным. ...

(незначительное изменение: прежде чем найти realpath в документации, я, по крайней мере, сократил свою версию (версию ниже), чтобы она не зависела от поля времени (как в первом ps command), но, честно говоря, после тестирования некоторых я менее убежден, что ps полностью надежен с точки зрения возможности расширения пути к команде)

С другой стороны, вы можете сделать это:

ps ww -fp $$ | grep -Eo '/[^:]*'"${0#*/}"

eval "abs0=${`ps ww -fp $$ | grep -Eo ' /'`#?}"

... И из трюков Рича: ...

Возврат строк из функции оболочки

Как видно из вышеупомянутой ловушки подстановки команд, стандартный вывод не является хорошим способом для функций оболочки возвращать строки вызывающей стороне, если только вывод не находится в формате, в котором завершающие символы новой строки не имеют значения. Конечно, такая практика неприемлема для функций, предназначенных для работы с произвольными строками. Так что можно сделать?

Попробуй это:

func () {
body here
eval "$1=\${foo}"
}

Конечно, ${foo} можно заменить любой заменой. Ключевой уловкой здесь является строка eval и использование экранирования. “$1” раскрывается, когда аргумент eval создается основным синтаксическим анализатором команд. Но “${foo}” на данном этапе не раскрывается, потому что “$” был процитирован. Вместо этого он расширяется, когда eval оценивает свой аргумент. Если непонятно, почему это важно, подумайте, чем может быть плохое следующее:

foo='hello ; rm -rf /'
dest=bar
eval "$dest=$foo"

Но, конечно, совершенно безопасна следующая версия:

foo='hello ; rm -rf /'
dest=bar
eval "$dest=\$foo"

Обратите внимание, что в исходном примере “$1” использовался, чтобы позволить вызывающей стороне передать имя целевой переменной в качестве аргумента функции. Если вашей функции необходимо использовать команду shift, например, для обработки оставшихся аргументов как “$@”, тогда может быть полезно сохранить значение “$1” во временной переменной в начале функции.

Я думаю, что самый простой ответ - это расширение параметров исходной переменной:

#!/usr/bin/env bash

DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
echo "opt1; original answer: $DIR"
echo ''

echo "opt2; simple answer  : ${BASH_SOURCE[0]%/*}"

Результат должен быть примерно таким:

$ /var/tmp/test.sh
opt1; original answer: /var/tmp

opt2; simple answer  : /var/tmp

Расширение переменных / параметров ${BASH_SOURCE[0]%/*}" кажется намного проще в обслуживании.

Ниже приведен путь к каталогу скрипта в переменной dir.

(Он также пытается поддерживать выполнение под Cygwin в Windows.)

И, наконец, он запускает исполняемый файл my-sample-app со всеми аргументами, переданными этому сценарию, используя "$@":

#!/usr/bin/env sh

dir=$(cd "${0%[/\\]*}" > /dev/null && pwd)

if [ -d /proc/cygdrive ]; then
    case "$(uname -s)" in
        CYGWIN*|MINGW32*|MSYS*|MINGW*)
            # We are under Windows, so translate path to Windows format.
            dir=$(cygpath -m "$dir");
            ;;
    esac
fi

# Runs the executable which is beside this script
"${dir}/my-sample-app" "$@"

Нет вилок (кроме подоболочки) и может обрабатывать "чужие" формы пути, подобные тем, которые содержат символы новой строки, как утверждают некоторые:

IFS= read -rd '' DIR < <([[ $BASH_SOURCE != */* ]] || cd "${BASH_SOURCE%/*}/" >&- && echo -n "$PWD")

Посмотрите на тест внизу со странными названиями каталогов.

Чтобы изменить рабочий каталог на тот, в котором находится сценарий Bash, вам следует попробовать это простое, протестированное и проверенное с помощью решения shellcheck:

#!/bin/bash --
cd "$(dirname "${0}")"/. || exit 2

Тест:

$ ls 
application
$ mkdir "$(printf "\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\40\41\42\43\44\45\46\47testdir" "")"
$ mv application *testdir
$ ln -s *testdir "$(printf "\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\40\41\42\43\44\45\46\47symlink" "")"
$ ls -lb
total 4
lrwxrwxrwx 1 jay stacko   46 Mar 30 20:44 \001\002\003\004\005\006\a\b\t\n\v\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\ !"#$%&'symlink -> \001\002\003\004\005\006\a\b\t\n\v\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\ !"#$%&'testdir
drwxr-xr-x 2 jay stacko 4096 Mar 30 20:44 \001\002\003\004\005\006\a\b\t\n\v\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\ !"#$%&'testdir
$ *testdir/application && printf "SUCCESS\n" ""
SUCCESS
$ *symlink/application && printf "SUCCESS\n" ""
SUCCESS

Обычно я включаю в начало своих скриптов следующее, что работает в большинстве случаев:

[ "$(dirname $0)" = '.' ] && SOURCE_DIR=$(pwd) || SOURCE_DIR=$(dirname $0);
ls -l $0 | grep -q ^l && SOURCE_DIR=$(ls -l $0 | awk '{print $NF}');

Первая строка назначает источник на основе значения pwd, если запускается с текущего пути или dirname если звонили из другого места.

Вторая строка проверяет путь, чтобы убедиться, что это символическая ссылка, и, если да, обновляет SOURCE_DIR в соответствии с местоположением самой ссылки.

Возможно, есть лучшие решения, но это самое чистое, что мне удалось придумать сам.

Попробуйте что-то вроде этого:

function get_realpath() {

if [[ -f "$1" ]]
then
    # The file *must* exist
    if cd "$(echo "${1%/*}")" &>/dev/null
    then
        # The file *may* not be local.
        # The exception is ./file.ext
        # tTry 'cd .; cd -;' *works!*
        local tmppwd="$PWD"
        cd - &>/dev/null
    else
        # file *must* be local
        local tmppwd="$PWD"
    fi
else
    # The file *cannot* exist
    return 1 # Failure
fi

# Reassemble realpath
echo "$tmppwd"/"${1##*/}"
return 0 # Success

}

function get_dirname(){

local realpath="$(get_realpath "$1")"
if (( $? )) # True when non-zero.
then
    return $? # Failure
fi
echo "${realpath%/*}"
return 0 # Success

}

# Then from the top level:
get_dirname './script.sh'

# Or within a script:
get_dirname "$0"

# Can even test the outcome!
if (( $? )) # True when non-zero.
then
    exit 1 # Failure
fi

Эти функции и связанные с ними инструменты являются частью нашего продукта, который был предоставлен сообществу бесплатно и может быть найден на GitHub как realpath-lib. Он простой, чистый и хорошо документированный (отлично подходит для обучения), чистый Bash и не имеет зависимостей. Также подходит для кроссплатформенного использования. Итак, для приведенного выше примера в сценарии вы можете просто:

source '/path/to/realpath-lib'

get_dirname "$0"

if (( $? )) # True when non-zero.
then
    exit 1 # Failure
fi

Ключевым моментом является то, что я уменьшаю масштаб проблемы: я запрещаю косвенное выполнение скрипта через путь (как в /bin/sh [script path relative to path component]).

Это можно обнаружить, потому что $0 будет относительным путем, который не разрешается ни в один файл относительно текущей папки. Я считаю, что прямое выполнение с использованием механизма #! всегда приводит к абсолютному $0, в том числе когда сценарий находится на пути.

Я также требую, чтобы имя пути и любые имена пути в цепочке символических ссылок содержали только разумное подмножество символов, в частности, не \n, >, * или ?. Это необходимо для логики синтаксического анализа.

Есть еще несколько неявных ожиданий, в которые я не буду вдаваться (см. этот ответ), и я не пытаюсь обрабатывать преднамеренный саботаж $0 (поэтому учитывайте любые последствия для безопасности). Я ожидаю, что это будет работать практически в любой Unix-подобной системе с Bourne-подобной /bin/sh.

#!/bin/sh
(
    path="${0}"
    while test -n "${path}"; do
        # Make sure we have at least one slash and no leading dash.
        expr "${path}" : / > /dev/null || path="./${path}"
        # Filter out bad characters in the path name.
        expr "${path}" : ".*[*?<>\\]" > /dev/null && exit 1
        # Catch embedded new-lines and non-existing (or path-relative) files.
        # $0 should always be absolute when scripts are invoked through "#!".
        test "`ls -l -d "${path}" 2> /dev/null | wc -l`" -eq 1 || exit 1
        # Change to the folder containing the file to resolve relative links.
        folder=`expr "${path}" : "\(.*/\)[^/][^/]*/*$"` || exit 1
        path=`expr "x\`ls -l -d "${path}"\`" : "[^>]* -> \(.*\)"`
        cd "${folder}"
        # If the last path was not a link then we are in the target folder.
        test -n "${path}" || pwd
    done
)

Не существует 100% переносимого и надежного способа запросить путь к текущему каталогу сценария. Особенно между разными серверными ВМ, такими как Cygwin, MinGW, MSYS, Linux и т. д. Эта проблема долгое время не решалась в Bash должным образом и полностью.

Например, это не может быть решено, если вы хотите запросить путь после команды source, чтобы сделать вложенное включение другого сценария Bash, который, в свою очередь, использует ту же команду source для включения другого сценария Bash и так далее.

В случае команды source я предлагаю заменить команду source на что-то вроде этого :

function include()
{
  if [[ -n "$CURRENT_SCRIPT_DIR" ]]; then
    local dir_path=... get directory from `CURRENT_SCRIPT_DIR/$1`, depends if $1 is absolute path or relative ...
    local include_file_path=...
  else
    local dir_path=... request the directory from the "$1" argument using one of answered here methods...
    local include_file_path=...
  fi
  ... push $CURRENT_SCRIPT_DIR in to stack ...
  export CURRENT_SCRIPT_DIR=... export current script directory using $dir_path ...
  source "$include_file_path"
  ... pop $CURRENT_SCRIPT_DIR from stack ...
}

С этого момента использование include(...) основано на предыдущем CURRENT_SCRIPT_DIR в вашем скрипте.

Это работает, только если вы можете заменить все команды source на команду include. Если вы не можете, то у вас нет выбора. По крайней мере, до тех пор, пока разработчики интерпретатора Bash не сделают явную команду для запроса текущего пути к каталогу запущенного скрипта.

Моя собственная ближайшая реализация к этому: https://sourceforge.net/p/tacklelib/tacklelib/HEAD/tree/trunk/bash/tacklelib/bash_entry

(ищите функцию tkl_include)

На основании этого ответа, я предлагаю уточненную версию, которая получает SCRIPT_HOME как содержащую папку любого запущенного в данный момент сценария Bash:

s=${BASH_SOURCE[0]} ; s=`dirname $s` ; SCRIPT_HOME=`cd $s ; pwd`
echo $SCRIPT_HOME

Я хочу прокомментировать предыдущий ответ там (Как я могу получить исходный каталог сценария Bash из самого сценария?), но у него нет достаточно репутации для этого.

Два года назад я нашел решение этой проблемы на сайте документации Apple: https://developer.apple.com/library/archive/documentation/OpenSource/Conceptual/ShellScripting/AdvancedTechniques/AdvancedTechniques.html. И впоследствии я придерживался этого метода. Он не может обрабатывать софт-ссылку, но в остальном работает для меня очень хорошо. Я размещаю его здесь для всех, кому это нужно, и как просьбу о комментариях.

#!/bin/sh

# Get an absolute path for the poem.txt file.
POEM="$PWD/../poem.txt"

# Get an absolute path for the script file.
SCRIPT="$(which $0)"
if [ "x$(echo $SCRIPT | grep '^\/')" = "x" ] ; then
    SCRIPT="$PWD/$SCRIPT"
fi

Как показано в коде, после того, как вы получите абсолютный путь к сценарию, вы можете использовать dirname , чтобы получить путь к каталогу.

Вот что я создавал на протяжении многих лет для использования в качестве заголовка в моих сценариях Bash:

## BASE BRAIN - Get where you're from and who you are.
MYPID=$$
ORIGINAL_DIR="$(pwd)" # This is not a hot air balloon ride..
fa="$0" # First Assumption
ta= # Temporary Assumption
wa= # Weighed Assumption
while true; do
    [ "${fa:0:1}" = "/" ] && wa=$0 && break
    [ "${fa:0:2}" = "./" ] && ta="${ORIGINAL_DIR}/${fa:2}" && [ -e "$ta" ] && wa="$ta" && break
    ta="${ORIGINAL_DIR}/${fa}" && [ -e "$ta" ] && wa="$ta" && break
done
SW="$wa"
SWDIR="$(dirname "$wa")"
SWBIN="$(basename "$wa")"
unset ta fa wa
( [ ! -e "$SWDIR/$SWBIN" ] || [ -z "$SW" ] ) && echo "I could not find my way around :( possible bug in the TOP script" && exit 1

На этом этапе ваши переменные SW, SWDIR и SWBIN содержат то, что вам нужно.

Я хочу убедиться, что скрипт запущен в своем каталоге. Так

cd $(dirname $(which $0) )

После этого, если вы действительно хотите знать, где вы работаете, выполните команду ниже.

DIR=$(/usr/bin/pwd)

Этот однострочный работает с Cygwin, даже если сценарий был вызывается из Windows с помощью bash -c <script>:

set mydir="$(cygpath "$(dirname "$0")")"

выбранный ответ работает очень хорошо. Я публикую свое решение для всех, кто ищет более короткие альтернативы, которые по-прежнему относятся к источникам, выполнению, полным путям, относительным путям и символическим ссылкам. Наконец, это будет работать с macOS, учитывая, что нельзя предположить, что версия GNU coreutils Доступна ссылка для чтения.

Проблема в том, что он не использует Bash, но его легко использовать в сценарии Bash. Хотя OP не накладывал никаких ограничений на язык решения, вероятно, лучше всего, чтобы большинство из них осталось в мире Bash. Это просто альтернатива, и, возможно, непопулярная.

PHP доступен в macOS по умолчанию и установлен на ряде других платформ, хотя и не обязательно по умолчанию. Я понимаю, что это недостаток, но в любом случае оставлю это здесь для всех, кто приходит из поисковых систем.

export SOURCE_DIRECTORY="$(php -r 'echo dirname(realpath($argv[1]));' -- "${BASH_SOURCE[0]}")"

Будь проще.

#!/usr/bin/env bash
sourceDir=`pwd`
echo $sourceDir

FOLDERNAME=${PWD##*/}

Это самый быстрый способ, который я знаю.