So lösen Sie symbolische Links in einem Shell-Skript

Gegeben, einen absoluten oder einen relativen Pfad (in einem Unix-artigen system), würde ich mag, um zu bestimmen, die den vollständigen Pfad der das Ziel nach Behebung einer zwischengeschalteten symlinks. Bonus-Punkte für die Lösung ~username notation zur gleichen Zeit.

Wenn das Ziel ein Verzeichnis ist, könnte es möglich sein, zu chdir() in das Verzeichnis und rufen Sie dann getcwd(), aber ich wirklich wollen, dies zu tun von einem shell-Skript eher als das schreiben einer C-Helfer. Leider Schalen haben eine Tendenz, zu versuchen zu verbergen die Existenz von symlinks von den Benutzer (dies ist die bash unter OS X):

$ ls -ld foo bar
drwxr-xr-x   2 greg  greg  68 Aug 11 22:36 bar
lrwxr-xr-x   1 greg  greg   3 Aug 11 22:36 foo -> bar
$ cd foo
$ pwd
/Users/greg/tmp/foo
$

Was ich will, ist eine Funktion resolve (), so dass, wenn Sie ausgeführt aus dem tmp-Verzeichnis in dem obigen Beispiel, resolve("foo") == "/Users/greg/tmp/bar".

InformationsquelleAutor der Frage Greg Hewgill | 2008-08-11

80

Gemäß den standards pwd -P sollte den Pfad mit aufgelösten symlinks.

C-Funktion char *getcwd(char *buf, size_t size) aus unistd.h sollten das gleiche Verhalten.

getcwd
pwd

InformationsquelleAutor der Antwort kauppi
341
```
readlink -f "$path"
```
^{Anmerkung der Redaktion: Die oben genannten Werke mit GNU readlink und FreeBSD/PC-BSD/OpenBSD readlinkaber nicht auf OS X ab 10.11.

GNU readlink bietet zusätzliche, spezifische Optionen, wie -m für die Lösung eines symlink, ob oder nicht das ultimative Ziel nicht existiert.}

Hinweis: da die GNU coreutils 8.15 (2012-01-06), es ist ein realpath Programm zur Verfügung haben, ist weniger stumpf und flexibler als die oben genannten. Es ist auch kompatibel mit dem FreeBSD-util mit dem gleichen Namen. Es enthält auch Funktionen zum generieren einer relativen Pfad zwischen zwei Dateien.
```
realpath $path
```
[Admin-Zugabe unterhalb von Kommentar von halloleo —danorton]

Für Mac OS X (bis mindestens 10.11.x), verwenden Sie readlink ohne die -f option:
```
readlink $path
```
^{Editor ' s Hinweis: Dies wird nicht beheben symlinks rekursiv und somit nicht Bericht der ultimate Ziel; z.B., gegeben symlink adie Punkte zu bdie wiederum auf c wird dieser Bericht b (und nicht gewährleisten, dass diese Ausgabe als eine absoluten Pfad).

Verwenden Sie die folgenden perl Befehl auf OS X, um die Lücke der fehlenden readlink -f Funktionalität:

perl -MCwd -le 'print Cwd::abs_path(shift)' "$path"}

InformationsquelleAutor der Antwort pixelbeat

"pwd -P" scheint zu funktionieren, wenn Sie wollen einfach nur das Verzeichnis, aber wenn aus irgendeinem Grund Sie möchten, dass die Namen der tatsächlichen ausführbaren Datei, die ich glaube nicht, dass das hilft. Hier ist meine Lösung:

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

InformationsquelleAutor der Antwort tlrobinson

Einer meiner Favoriten ist realpath foo

realpath - das kanonische absolute Pfadnamen 

realpath erweitert alle symbolischen links und löst Referenzen auf '/./', '/../' und extra '/' Zeichen in die null-terminierte Zeichenfolge mit dem Namen von Weg und 
speichert den kanonisierten absoluten Pfadnamen im Puffer der Größe PATH_MAX Namen von resolved_path. Der daraus resultierende Pfad wird keine symbolischen Links, '/./' oder 
'/../'- Komponenten.

InformationsquelleAutor der Antwort Gregory

9
```
readlink -e [filepath]
```
scheint zu sein, genau das, was Sie für Fragen
- es nimmt eine arbirary Weg, löst alle symbolischen Links, und gibt den "echten" Pfad
- und es ist "standard *nix", dass wahrscheinlich alle Systeme, die bereits

InformationsquelleAutor der Antwort Chuck Kollars
5

Setzen einige der gegebenen Lösungen zusammen, wohl wissend, dass readlink ist verfügbar auf den meisten Systemen, braucht aber verschiedene Argumente, das funktioniert gut für mich auf OSX und Debian. Ich bin mir nicht sicher über die BSD-Systeme. Vielleicht ist die Bedingung muss [[ $OSTYPE != darwin* ]] ausschließen -f von OSX nur.
```
#!/bin/bash
MY_DIR=$( cd $(dirname $(readlink `[[ $OSTYPE == linux* ]] && echo "-f"` $0)) ; pwd -P)
echo "$MY_DIR"
```
InformationsquelleAutor der Antwort hpvw

Einen anderen Weg:

# 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|"; }

InformationsquelleAutor der Antwort Keymon

2

^{Anmerkung: ich glaube, das ist eine Feste, tragbare, ready-made-Lösung, die ist immer langen aus diesem Grund.}

Unten ist eine vollständig POSIX-kompatibel Skript /Funktion , ist daher cross-Plattform (arbeitet auf macOS zu, deren readlink noch nicht unterstützt -f ab 10.12 (Sierra)) - es nutzt nur POSIX-shell-Sprache-Funktionen und nur POSIX-konforme utility-Aufrufe.

Es ist ein portable Implementierung des GNU readlink -e (die strengere version von readlink -f).

Können Sie laufen die Skript mit sh oder Quelle der Funktion in bashkshund zsh:

Beispielsweise innerhalb eines Skriptes können Sie es wie folgt vor, um die Ausführung das Skript " true Verzeichnis von origin, mit aufgelösten symlinks:
```
trueScriptDir=$(dirname -- "$(rreadlink "$0")")
```
rreadlink Skript /Funktion definition:

^{Der code wurde angepasst, mit Dankbarkeit von diese Antwort.

Ich habe auch eine bash-basierte stand-alone-Dienstprogramm-version hier, die Sie installieren können, mit

npm install rreadlink -gwenn Sie Node.js installiert.}
```
#!/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 "$@"
```
Eine Tangente an Sicherheit:

jarnoin Bezug auf die Funktion, sicherzustellen, dass builtin command ist nicht beschattet durch ein alias oder ein shell-Funktion mit dem gleichen Namen, fragt in einem Kommentar:

Was ist, wenn unalias oder unset und [ als Aliase oder shell-Funktionen?

Die motivation hinter rreadlink sicherzustellen, dass command hat seine ursprüngliche Bedeutung ist, es zu benutzen, um zu umgehen (benigne) Bequemlichkeit Aliase und Funktionen, die Häufig verwendet, um Schatten-standard-Befehle in interactive shells, wie die Neudefinition ls enthalten bevorzugten Optionen.

Ich denke, es ist sicher zu sagen, dass, wenn man sich mit nicht vertrauenswürdigen, schädliche Umwelt, sich Gedanken über unalias oder unset - oder, für diese Angelegenheit, die whiledo... - neu definiert, ist nicht von Belang.

Es ist etwasdass die Funktion muß sich auf seine ursprüngliche Bedeutung und Verhalten - es gibt keinen Weg darum herum.

Das POSIX-shells ermöglichen Neudefinition der gelieferten und auch die Sprache der keywords ist inhärent ein Sicherheitsrisiko (und schreiben paranoid code ist schwer im Allgemeinen).

Um Ihr Anliegen konkret:

Die Funktion beruht auf unalias und unset haben Ihre ursprüngliche Bedeutung. Dass Sie neu definiert als shell-Funktionen in einer Weise verändert, Ihr Verhalten wäre ein problem; Neudefinition als alias ist
nicht unbedingt ein Problem, da zitieren (Teil) der name des Befehls (z.B. \unalias) umgeht Aliase.

Jedoch, die Angabe ist nicht eine option für shell keywords (whileforifdo...) und während shell keywords zu tun haben Vorrang vor shell Funktionenin bash und zsh Aliase haben den höchsten Vorrang, also zum Schutz gegen shell-Stichwort neudefinitionen führen Sie unalias mit Ihrem Namen (obwohl in nicht-interaktive bash Schalen (wie z.B. Skripte) Aliase sind nicht standardmäßig erweitert - nur, wenn shopt -s expand_aliases ist explizit genannt).

Um sicherzustellen, dass unalias - als builtin - hat seine ursprüngliche Bedeutung, die Sie verwenden müssen \unset es erst einmal auf, was erfordert, dass unset haben Ihre ursprüngliche Bedeutung:

unset ist ein shell - builtinso, um sicherzustellen, dass es aufgerufen wird, die als solche würden Sie haben, um sicherzustellen, dass es sich nicht neu definiert als Funktion. Während Sie umgehen können, einen alias-Formular mit zu zitieren, die Sie nicht umgehen können ein shell-Funktion - catch-22.

So, es sei denn, Sie können sich darauf verlassen unset zu haben, seine ursprüngliche Bedeutung, von dem, was ich sagen kann, es gibt keine garantierten Weg, um zu verteidigen gegen alle bösartigen neudefinitionen.

InformationsquelleAutor der Antwort mklement0

Shell-Skripte haben oft zu finden, die Ihre "home" - Verzeichnis, auch wenn Sie aufgerufen werden, als symlink. Das Skript muss also feststellen, Ihre "Reale" position von nur $0.

cat `mvn`

auf meinem system druckt ein Skript, das folgende, das sollte ein guter Hinweis auf das, was Sie brauchen.

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`

InformationsquelleAutor der Antwort Hugo

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"))/..

InformationsquelleAutor der Antwort Dave

Versuchen Sie dies:

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

InformationsquelleAutor der Antwort diyism

Da ich habe dieses viele Male im Laufe der Jahre, und dieses mal brauchte ich ein reines bash-portable-version, die ich verwenden könnte, auf OSX und linux, ich ging voran und schrieb:

Wohn version hier lebt:

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

aber für den Willen ALSO, hier ist die aktuelle version (ich glaube, es ist gut getestet..aber ich bin offen für feedback!)

Könnte nicht schwer sein, damit es funktioniert für nur-bourne-shell (sh), aber ich nicht versuchen...ich mag $FUNCNAME zu viel. 🙂

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

hier ist ein klassisches Beispiel, Dank 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

verwenden Sie diese Funktion, und es erfolgt die Rückkehr-real - Pfad:

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

InformationsquelleAutor der Antwort keen

1

Arbeiten rund um den Mac Inkompatibilität, kam ich mit
```
echo `php -r "echo realpath('foo');"`
```
Nicht groß, aber auch cross-OS

InformationsquelleAutor der Antwort Clemens Tolboom
1

Ist Ihr Pfad ein Verzeichnis ist, oder könnte es eine Datei sein? Wenn es ein Verzeichnis ist, es ist ganz einfach:
```
(cd "$DIR"; pwd -P)
```
Jedoch, wenn es vielleicht eine Datei, dann funktioniert es nicht:
```
DIR=$(cd $(dirname "$FILE"); pwd -P); echo "${DIR}/$(readlink "$FILE")"
```
weil der symlink möglicherweise beheben, in einen relativen oder einen vollständigen Pfad.

Auf Skripte, die ich brauche zu finden, der eigentliche Weg, so dass ich möglicherweise auf die Konfiguration oder andere scripts installiert zusammen mit ihm, benutze ich dieses:
```
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
```
Konnten Sie SOURCE zu jeder Datei Weg. Im Grunde, solange der Pfad ist ein symlink ist, löst es, dass der symlink. Der trick ist in der letzten Zeile der Schleife. Wenn der symlink gelöst ist absolut, es wird als SOURCE. Jedoch, wenn es relativ ist, es wird voranstellen DIR für ihn, das war aufgelöst in einer realen Lage durch den einfachen trick, den ich zuerst beschrieben.

InformationsquelleAutor der Antwort Daniel C. Sobral

Ich glaube, dies ist die wahre und endgültige "Lösung " symlink" ob es ein Verzeichnis oder ein nicht-Verzeichnis, die Bash benutzen:

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

Beachten Sie, dass alle cd und set Sachen erfolgt in einer subshell.

InformationsquelleAutor der Antwort solidsnack

0

Hier ist, wie kann man den tatsächlichen Pfad zu der Datei im MacOS/Unix mit einem eingebetteten Perl-Skript:
```
FILE=$(perl -e "use Cwd qw(abs_path); print abs_path('$0')")
```
Ebenso, um das Verzeichnis eines symlinked-Datei:
```
DIR=$(perl -e "use Cwd qw(abs_path); use File::Basename; print dirname(abs_path('$0'))")
```
InformationsquelleAutor der Antwort Igor Afanasyev

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.