readlink -f "$path"

^{Примечание редактора: вышеописанное работает с GNU readlink и FreeBSD / PC-BSD / OpenBSD readlink , но не на OS X по состоянию на 10.11.
GNU readlink предлагает дополнительные связанные параметры, такие как -mразрешение символической ссылки, независимо от того, существует ли конечная цель.}

Обратите внимание, что начиная с GNU coreutils 8.15 (2012-01-06), существует программа realpath, которая менее тупая и более гибкая, чем описанная выше. Он также совместим с утилитой FreeBSD с тем же именем. Он также включает в себя функциональность для генерации относительного пути между двумя файлами.

realpath $path

[Дополнение администратора ниже от комментария от halloleo - danorton]

Для Mac OS X (не ниже 10.11.x) используйте readlinkбез -fопции:

readlink $path

^{Примечание редактора: это не приведет к рекурсивному разрешению символических ссылок и, следовательно, не сообщит о конечной цели; например, данная символическая ссылка, на aкоторую указывает ссылка b, которая, в свою очередь, указывает cтолько на отчет b(и не гарантирует, что он будет выводиться как абсолютный путь ).
Используйте следующую perlкоманду в OS X, чтобы заполнить пробел отсутствующей readlink -fфункциональности:
perl -MCwd -le 'print Cwd::abs_path(shift)' "$path"}

«pwd -P», кажется, работает, если вы просто хотите каталог, но если по какой-то причине вы хотите имя реального исполняемого файла, я не думаю, что это помогает. Вот мое решение:

#!/bin/bash

# get the absolute path of the executable
SELF_PATH=$(cd -P -- "$(dirname -- "$0")" && pwd -P) && SELF_PATH=$SELF_PATH/$(basename -- "$0")

# resolve symlinks
while [[ -h $SELF_PATH ]]; do
    # 1) cd to directory of the symlink
    # 2) cd to the directory of where the symlink points
    # 3) get the pwd
    # 4) append the basename
    DIR=$(dirname -- "$SELF_PATH")
    SYM=$(readlink "$SELF_PATH")
    SELF_PATH=$(cd "$DIR" && cd "$(dirname -- "$SYM")" && pwd)/$(basename -- "$SYM")
done

Один из моих любимых realpath foo

realpath - вернуть канонизированный абсолютный путь

realpath раскрывает все символические ссылки и разрешает ссылки на символы «/./», «/../» и дополнительные символы «/» в строке с нулевым символом в конце, названной path и
       хранит канонизированный абсолютный путь в буфере размером PATH_MAX, названном resolved_path. Полученный путь не будет иметь символической ссылки, «/ ./» или
       '/../' компоненты.

readlink -e [filepath]

кажется, что именно то, что вы просите - он принимает произвольный путь, разрешает все символические ссылки и возвращает «реальный» путь - и это «стандартный * nix», который, вероятно, уже есть во всех системах

По-другому:

# Gets the real path of a link, following all links
myreadlink() { [ ! -h "$1" ] && echo "$1" || (local link="$(expr "$(command ls -ld -- "$1")" : '.*-> \(.*\)$')"; cd $(dirname $1); myreadlink "$link" | sed "s|^\([^/].*\)\$|$(dirname $1)/\1|"); }

# Returns the absolute path to a command, maybe in $PATH (which) or not. If not found, returns the same
whereis() { echo $1 | sed "s|^\([^/].*/.*\)|$(pwd)/\1|;s|^\([^/]*\)$|$(which -- $1)|;s|^$|$1|"; } 

# Returns the realpath of a called command.
whereis_realpath() { local SCRIPT_PATH=$(whereis $1); myreadlink ${SCRIPT_PATH} | sed "s|^\([^/].*\)\$|$(dirname ${SCRIPT_PATH})/\1|"; } 

Собирая вместе некоторые из приведенных решений, зная, что readlink доступна в большинстве систем, но требует разных аргументов, это хорошо работает для меня в OSX и Debian. Я не уверен насчет систем BSD. Возможно условие должно быть [[ $OSTYPE != darwin* ]]исключено -fтолько из OSX.

#!/bin/bash
MY_DIR=$( cd $(dirname $(readlink `[[ $OSTYPE == linux* ]] && echo "-f"` $0)) ; pwd -P)
echo "$MY_DIR"

^{Примечание: Я считаю , что это быть твердым, портативный, готовое решение, которое неизменно длительный по той же причине.}

Ниже приведен полностью POSIX-совместимый скрипт / функция, который, следовательно, является кроссплатформенным (работает также и в MacOS, чья readlinkподдержка не поддерживается -fна 10.12 (Sierra)) - он использует только функции языка оболочки POSIX и только POSIX-совместимые вызовы утилит ,

Это переносимая реализация GNUreadlink -e (более строгая версия readlink -f).

Вы можете запустить скрипт сsh или подключите функцию в bash, kshиzsh :

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

trueScriptDir=$(dirname -- "$(rreadlink "$0")")

rreadlink определение скрипта / функции:

^{Код был адаптирован с благодарностью от этого ответа .
Я также создал здесьbash версию автономной утилиты на основе , которую вы можете установить , если у вас установлен Node.js.
npm install rreadlink -g}

#!/bin/sh

# SYNOPSIS
#   rreadlink <fileOrDirPath>
# DESCRIPTION
#   Resolves <fileOrDirPath> to its ultimate target, if it is a symlink, and
#   prints its canonical path. If it is not a symlink, its own canonical path
#   is printed.
#   A broken symlink causes an error that reports the non-existent target.
# LIMITATIONS
#   - Won't work with filenames with embedded newlines or filenames containing 
#     the string ' -> '.
# COMPATIBILITY
#   This is a fully POSIX-compliant implementation of what GNU readlink's
#    -e option does.
# EXAMPLE
#   In a shell script, use the following to get that script's true directory of origin:
#     trueScriptDir=$(dirname -- "$(rreadlink "$0")")
rreadlink() ( # Execute the function in a *subshell* to localize variables and the effect of `cd`.

  target=$1 fname= targetDir= CDPATH=

  # Try to make the execution environment as predictable as possible:
  # All commands below are invoked via `command`, so we must make sure that
  # `command` itself is not redefined as an alias or shell function.
  # (Note that command is too inconsistent across shells, so we don't use it.)
  # `command` is a *builtin* in bash, dash, ksh, zsh, and some platforms do not 
  # even have an external utility version of it (e.g, Ubuntu).
  # `command` bypasses aliases and shell functions and also finds builtins 
  # in bash, dash, and ksh. In zsh, option POSIX_BUILTINS must be turned on for
  # that to happen.
  { \unalias command; \unset -f command; } >/dev/null 2>&1
  [ -n "$ZSH_VERSION" ] && options[POSIX_BUILTINS]=on # make zsh find *builtins* with `command` too.

  while :; do # Resolve potential symlinks until the ultimate target is found.
      [ -L "$target" ] || [ -e "$target" ] || { command printf '%s\n' "ERROR: '$target' does not exist." >&2; return 1; }
      command cd "$(command dirname -- "$target")" # Change to target dir; necessary for correct resolution of target path.
      fname=$(command basename -- "$target") # Extract filename.
      [ "$fname" = '/' ] && fname='' # !! curiously, `basename /` returns '/'
      if [ -L "$fname" ]; then
        # Extract [next] target path, which may be defined
        # *relative* to the symlink's own directory.
        # Note: We parse `ls -l` output to find the symlink target
        #       which is the only POSIX-compliant, albeit somewhat fragile, way.
        target=$(command ls -l "$fname")
        target=${target#* -> }
        continue # Resolve [next] symlink target.
      fi
      break # Ultimate target reached.
  done
  targetDir=$(command pwd -P) # Get canonical dir. path
  # Output the ultimate target's canonical path.
  # Note that we manually resolve paths ending in /. and /.. to make sure we have a normalized path.
  if [ "$fname" = '.' ]; then
    command printf '%s\n' "${targetDir%/}"
  elif  [ "$fname" = '..' ]; then
    # Caveat: something like /var/.. will resolve to /private (assuming /var@ -> /private/var), i.e. the '..' is applied
    # AFTER canonicalization.
    command printf '%s\n' "$(command dirname -- "${targetDir}")"
  else
    command printf '%s\n' "${targetDir%/}/$fname"
  fi
)

rreadlink "$@"

Касательная к безопасности:

jarno , ссылаясь на функцию, гарантирующую, что встроенная функция commandне скрывается псевдонимом или функцией оболочки с тем же именем, спрашивает в комментарии:

Что если unaliasили unsetи [установлены как псевдонимы или функции оболочки?

Мотивация rreadlinkобеспечения того, чтобы он commandимел первоначальное значение, состоит в том, чтобы использовать его для обхода (мягких) вспомогательных псевдонимов и функций, часто используемых для теневого копирования стандартных команд в интерактивных оболочках, таких как переопределение lsдля включения избранных параметров.

Я думаю , что можно с уверенностью сказать , что если вы имеете дело с ненадежной, злонамеренной средой, заботясь о том unaliasили unset- или, если на то пошли, while, do, ... - пересматриваются не является проблемой.

Есть нечто , на что функция должна полагаться, чтобы иметь свое первоначальное значение и поведение - нет никакого способа обойти это.
То, что POSIX-подобные оболочки позволяют переопределять встроенные и даже языковые ключевые слова, по своей сути является угрозой безопасности (и вообще, писать параноидальный код сложно).

Чтобы конкретно решить ваши проблемы:

Функция опирается unaliasи unsetимеет свое первоначальное значение. Было бы проблемой переопределить их как функции оболочки таким образом, чтобы это изменило их поведение; переопределение в качестве псевдонима не обязательно является проблемой, потому что цитирование (часть) имени команды (например, \unalias) обходит псевдонимы.

Однако, ссылаясь на это не вариант для оболочки ключевых слов ( while, for, if, do, ...) , и в то время как ключевые слова оболочки делают имеют приоритет над оболочками функций , в bashи zshпсевдонимами имеют наивысший приоритет, поэтому для защиты от снарядов, ключевое слово переопределениях вы должны работать unaliasс их имена (хотя в неинтерактивных bash оболочках (таких как сценарии) псевдонимы по умолчанию не раскрываются - только если shopt -s expand_aliasesявно вызывается первым).

Чтобы гарантировать, что unalias- как встроенный - имеет первоначальное значение, вы должны \unsetсначала использовать его, что требует, чтобы оно unsetимело первоначальное значение:

unsetэто встроенная оболочка , поэтому для того, чтобы она вызывалась как таковая, вам необходимо убедиться, что она сама по себе не переопределена как функция . Хотя вы можете обойти форму псевдонима с кавычками, вы не можете обойти форму функции оболочки - поймать 22.

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

Обычные сценарии оболочки часто должны находить свой «домашний» каталог, даже если они вызываются как символическая ссылка. Таким образом, скрипт должен найти свою «реальную» позицию всего за $ 0.

cat `mvn`

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

if [ -z "$M2_HOME" ] ; then
  ## resolve links - $0 may be a link to maven's home
  PRG="$0"

  # need this for relative symlinks
  while [ -h "$PRG" ] ; do
    ls=`ls -ld "$PRG"`
    link=`expr "$ls" : '.*-> \(.*\)$'`
    if expr "$link" : '/.*' > /dev/null; then
      PRG="$link"
    else
      PRG="`dirname "$PRG"`/$link"
    fi
  done

  saveddir=`pwd`

  M2_HOME=`dirname "$PRG"`/..

  # make it fully qualified
  M2_HOME=`cd "$M2_HOME" && pwd`

function realpath {
    local r=$1; local t=$(readlink $r)
    while [ $t ]; do
        r=$(cd $(dirname $r) && cd $(dirname $t) && pwd -P)/$(basename $t)
        t=$(readlink $r)
    done
    echo $r
}

#example usage
SCRIPT_PARENT_DIR=$(dirname $(realpath "$0"))/..

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

cd $(dirname $([ -L $0 ] && readlink -f $0 || echo $0))

Так как я сталкивался с этим много раз на протяжении многих лет, и в этот раз мне понадобилась чисто переносимая версия bash, которую я мог бы использовать для OSX и Linux, я решил написать одну:

Живая версия живет здесь:

https://github.com/keen99/shell-functions/tree/master/resolve_path

но ради SO, вот текущая версия (я чувствую, что это хорошо проверено .. но я открыт для обратной связи!)

Может быть нетрудно заставить его работать на простой оболочке bourne (sh), но я не пробовал ... Мне слишком нравится $ FUNCNAME. :)

#!/bin/bash

resolve_path() {
    #I'm bash only, please!
    # usage:  resolve_path <a file or directory> 
    # follows symlinks and relative paths, returns a full real path
    #
    local owd="$PWD"
    #echo "$FUNCNAME for $1" >&2
    local opath="$1"
    local npath=""
    local obase=$(basename "$opath")
    local odir=$(dirname "$opath")
    if [[ -L "$opath" ]]
    then
    #it's a link.
    #file or directory, we want to cd into it's dir
        cd $odir
    #then extract where the link points.
        npath=$(readlink "$obase")
        #have to -L BEFORE we -f, because -f includes -L :(
        if [[ -L $npath ]]
         then
        #the link points to another symlink, so go follow that.
            resolve_path "$npath"
            #and finish out early, we're done.
            return $?
            #done
        elif [[ -f $npath ]]
        #the link points to a file.
         then
            #get the dir for the new file
            nbase=$(basename $npath)
            npath=$(dirname $npath)
            cd "$npath"
            ndir=$(pwd -P)
            retval=0
            #done
        elif [[ -d $npath ]]
         then
        #the link points to a directory.
            cd "$npath"
            ndir=$(pwd -P)
            retval=0
            #done
        else
            echo "$FUNCNAME: ERROR: unknown condition inside link!!" >&2
            echo "opath [[ $opath ]]" >&2
            echo "npath [[ $npath ]]" >&2
            return 1
        fi
    else
        if ! [[ -e "$opath" ]]
         then
            echo "$FUNCNAME: $opath: No such file or directory" >&2
            return 1
            #and break early
        elif [[ -d "$opath" ]]
         then 
            cd "$opath"
            ndir=$(pwd -P)
            retval=0
            #done
        elif [[ -f "$opath" ]]
         then
            cd $odir
            ndir=$(pwd -P)
            nbase=$(basename "$opath")
            retval=0
            #done
        else
            echo "$FUNCNAME: ERROR: unknown condition outside link!!" >&2
            echo "opath [[ $opath ]]" >&2
            return 1
        fi
    fi
    #now assemble our output
    echo -n "$ndir"
    if [[ "x${nbase:=}" != "x" ]]
     then
        echo "/$nbase"
    else 
        echo
    fi
    #now return to where we were
    cd "$owd"
    return $retval
}

вот классический пример, благодаря Brew:

%% ls -l `which mvn`
lrwxr-xr-x  1 draistrick  502  29 Dec 17 10:50 /usr/local/bin/mvn@ -> ../Cellar/maven/3.2.3/bin/mvn

используйте эту функцию, и она вернет -real- путь:

%% cat test.sh
#!/bin/bash
. resolve_path.inc
echo
echo "relative symlinked path:"
which mvn
echo
echo "and the real path:"
resolve_path `which mvn`


%% test.sh

relative symlinked path:
/usr/local/bin/mvn

and the real path:
/usr/local/Cellar/maven/3.2.3/libexec/bin/mvn 

Чтобы обойти несовместимость Mac, я придумал

echo `php -r "echo realpath('foo');"`

Не отлично, но кросс-ОС

Вот как можно получить фактический путь к файлу в MacOS / Unix, используя встроенный скрипт Perl:

FILE=$(perl -e "use Cwd qw(abs_path); print abs_path('$0')")

Аналогично, чтобы получить каталог с символьным файлом:

DIR=$(perl -e "use Cwd qw(abs_path); use File::Basename; print dirname(abs_path('$0'))")

Ваш путь - это каталог, или это может быть файл? Если это каталог, все просто:

(cd "$DIR"; pwd -P)

Однако, если это может быть файл, то это не сработает:

DIR=$(cd $(dirname "$FILE"); pwd -P); echo "${DIR}/$(readlink "$FILE")"

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

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

SOURCE="${BASH_SOURCE[0]}"
while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  DIR="$( cd -P "$( dirname "$SOURCE" )" && 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

Вы можете установить SOURCEлюбой путь к файлу. По сути, пока путь является символической ссылкой, он разрешает эту символическую ссылку. Хитрость в последней строке цикла. Если разрешенная символическая ссылка является абсолютной, она будет использовать это как SOURCE. Однако, если он является относительным, он будет предшествовать DIRдля него, который был преобразован в реальное местоположение с помощью простого трюка, который я впервые описал.

Я считаю, что это истинный и окончательный «способ разрешения символической ссылки», будь то каталог или не каталог, используя Bash:

function readlinks {(
  set -o errexit -o nounset
  declare n=0 limit=1024 link="$1"

  # If it's a directory, just skip all this.
  if cd "$link" 2>/dev/null
  then
    pwd -P "$link"
    return 0
  fi

  # Resolve until we are out of links (or recurse too deep).
  while [[ -L $link ]] && [[ $n -lt $limit ]]
  do
    cd "$(dirname -- "$link")"
    n=$((n + 1))
    link="$(readlink -- "${link##*/}")"
  done
  cd "$(dirname -- "$link")"

  if [[ $n -ge $limit ]]
  then
    echo "Recursion limit ($limit) exceeded." >&2
    return 2
  fi

  printf '%s/%s\n' "$(pwd -P)" "${link##*/}"
)}

Обратите внимание, что все cdи setвсе происходит в подоболочке.

Здесь я представляю то, что я считаю кроссплатформенным (по крайней мере, Linux и macOS) решением для ответа, который в настоящее время хорошо работает для меня.

crosspath()
{
    local ref="$1"
    if [ -x "$(which realpath)" ]; then
        path="$(realpath "$ref")"
    else
        path="$(readlink -f "$ref" 2> /dev/null)"
        if [ $? -gt 0 ]; then
            if [ -x "$(which readlink)" ]; then
                if [ ! -z "$(readlink "$ref")" ]; then
                    ref="$(readlink "$ref")"
                fi
            else
                echo "realpath and readlink not available. The following may not be the final path." 1>&2
            fi
            if [ -d "$ref" ]; then
                path="$(cd "$ref"; pwd -P)"
            else
                path="$(cd $(dirname "$ref"); pwd -P)/$(basename "$ref")"
            fi
        fi
    fi
    echo "$path"
}

Вот решение для MacOS (только?). Возможно, лучше подходит для первоначального вопроса.

mac_realpath()
{
    local ref="$1"
    if [[ ! -z "$(readlink "$ref")" ]]; then
        ref="$(readlink "$1")"
    fi
    if [[ -d "$ref" ]]; then
        echo "$(cd "$ref"; pwd -P)"
    else
        echo "$(cd $(dirname "$ref"); pwd -P)/$(basename "$ref")"
    fi
}

Мой ответ здесь Bash: как получить реальный путь символической ссылки?

но вкратце очень удобно в скриптах:

script_home=$( dirname $(realpath "$0") )
echo Original script home: $script_home

Они являются частью GNU coreutils и подходят для использования в системах Linux.

Чтобы проверить все, мы помещаем символическую ссылку в / home / test2 /, исправляем некоторые дополнительные вещи и запускаем / вызываем ее из корневого каталога:

/$ /home/test2/symlink
/home/test
Original script home: /home/test

куда

Original script is: /home/test/realscript.sh
Called script is: /home/test2/symlink