Wie normalisiert man einen Dateipfad in Bash?

Ich möchte zu transformieren /foo/bar/..zu/foo

Gibt es einen Bash-Befehl, der dies tut?

Bearbeiten: In meinem praktischen Fall existiert das Verzeichnis.

Wenn Sie einen Teil eines Dateinamens aus dem Pfad entfernen möchten, sind "dirname" und "basename" Ihre Freunde, und "realpath" ist ebenfalls praktisch.

dirname /foo/bar/baz 
# /foo/bar 
basename /foo/bar/baz
# baz
dirname $( dirname  /foo/bar/baz  ) 
# /foo 
realpath ../foo
# ../foo: No such file or directory
realpath /tmp/../tmp/../tmp
# /tmp

realpath Alternativen

Wenn realpathIhre Shell dies nicht unterstützt, können Sie es versuchen

readlink -f /path/here/.. 

Ebenfalls

readlink -m /path/there/../../ 

Funktioniert genauso wie

realpath -s /path/here/../../

, dass der Pfad nicht existieren muss, um normalisiert zu werden.

Ich weiß nicht, ob es einen direkten Bash-Befehl gibt, aber ich tue es normalerweise

normalDir="`cd "${dirToNormalize}";pwd`"
echo "${normalDir}"

und es funktioniert gut.

Versuchen Sie es realpath. Nachfolgend finden Sie die Quelle in ihrer Gesamtheit, die hiermit der Öffentlichkeit zugänglich gemacht wurde.

// realpath.c: display the absolute path to a file or directory.
// Adam Liss, August, 2007
// This program is provided "as-is" to the public domain, without express or
// implied warranty, for any non-profit use, provided this notice is maintained.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libgen.h>   
#include <limits.h>

static char *s_pMyName;
void usage(void);

int main(int argc, char *argv[])
{
    char
        sPath[PATH_MAX];


    s_pMyName = strdup(basename(argv[0]));

    if (argc < 2)
        usage();

    printf("%s\n", realpath(argv[1], sPath));
    return 0;
}    

void usage(void)
{
    fprintf(stderr, "usage: %s PATH\n", s_pMyName);
    exit(1);
}

Eine tragbare und zuverlässige Lösung ist die Verwendung von Python, das fast überall vorinstalliert ist (einschließlich Darwin). Sie haben zwei Möglichkeiten:

1. abspath Gibt einen absoluten Pfad zurück, löst jedoch keine Symlinks auf:

   python -c "import os,sys; print(os.path.abspath(sys.argv[1]))" path/to/file

2. realpath Gibt einen absoluten Pfad zurück und löst dabei Symlinks auf, wodurch ein kanonischer Pfad generiert wird:

   python -c "import os,sys; print(os.path.realpath(sys.argv[1]))" path/to/file

In jedem Fall path/to/filekann entweder ein relativer oder ein absoluter Pfad sein.

Verwenden Sie das Dienstprogramm readlink aus dem Paket coreutils.

MY_PATH=$(readlink -f "$0")

readlinkist der Bash-Standard zum Erhalten des absoluten Pfades. Es hat auch den Vorteil, leere Zeichenfolgen zurückzugeben, wenn Pfade oder ein Pfad nicht vorhanden sind (vorausgesetzt, die Flags dazu).

Verwenden Sie Folgendes, um den absoluten Pfad zu einem Verzeichnis zu erhalten, das möglicherweise vorhanden ist oder nicht, dessen Eltern jedoch vorhanden sind:

abspath=$(readlink -f $path)

So erhalten Sie den absoluten Pfad zu einem Verzeichnis, das zusammen mit allen Eltern vorhanden sein muss:

abspath=$(readlink -e $path)

Um den angegebenen Pfad zu kanonisieren und Symlinks zu folgen, falls vorhanden, aber ansonsten fehlende Verzeichnisse zu ignorieren und den Pfad trotzdem zurückzugeben, ist es:

abspath=$(readlink -m $path)

Der einzige Nachteil ist, dass Readlink Links folgt. Wenn Sie Links nicht folgen möchten, können Sie diese alternative Konvention verwenden:

abspath=$(cd ${path%/*} && echo $PWD/${path##*/})

Dadurch wird der Verzeichnisteil von $ path geändert und das aktuelle Verzeichnis zusammen mit dem Dateiteil von $ path gedruckt. Wenn chdir nicht funktioniert, erhalten Sie eine leere Zeichenfolge und einen Fehler auf stderr.

Alte Frage, aber es gibt einen viel einfacheren Weg, wenn Sie mit vollständigen Pfadnamen auf Shell-Ebene arbeiten:

   abspath = "$ (cd" $ path "&& pwd)"

Da die CD in einer Subshell ausgeführt wird, hat dies keine Auswirkungen auf das Hauptskript.

Angenommen, Ihre in die Shell integrierten Befehle akzeptieren -L und -P, sind zwei Varianten:

   abspath = "$ (cd -P" $ path "&& pwd -P)" #physischer Pfad mit aufgelösten Symlinks
   abspath = "$ (cd -L" $ path "&& pwd -L)" #logischer Pfad, der Symlinks beibehält

Persönlich brauche ich diesen späteren Ansatz nur selten, wenn ich aus irgendeinem Grund von symbolischen Links fasziniert bin.

Zu Ihrer Information: Variation beim Abrufen des Startverzeichnisses eines Skripts, die auch dann funktioniert, wenn das Skript später das aktuelle Verzeichnis ändert.

name0 = "$ (Basisname" $ ​​0 ")"; #Basisname des Skripts
dir0 = "$ (cd" $ (dirname "$ 0") "&& pwd)"; #absolute Startverzeichnis

Die Verwendung von CD stellt sicher, dass Sie immer das absolute Verzeichnis haben, auch wenn das Skript von Befehlen wie ./script.sh ausgeführt wird, die ohne cd / pwd oft nur ... Unnütz sind, wenn das Skript später eine CD erstellt.

Wie Adam Liss feststellte, realpathwird nicht mit jeder Distribution gebündelt. Was schade ist, denn es ist die beste Lösung. Der bereitgestellte Quellcode ist großartig und ich werde ihn wahrscheinlich jetzt verwenden. Folgendes habe ich bisher verwendet, das ich hier der Vollständigkeit halber teile:

get_abs_path() {
     local PARENT_DIR=$(dirname "$1")
     cd "$PARENT_DIR"
     local ABS_PATH="$(pwd)"/"$(basename "$1")"
     cd - >/dev/null
     echo "$ABS_PATH"
} 

Wenn Sie es zu lösen Symlinks möchten, ersetzen Sie einfach pwdmit pwd -P.

Meine jüngste Lösung war:

pushd foo/bar/..
dir=`pwd`
popd

Basierend auf der Antwort von Tim Whitcomb.

Nicht gerade eine Antwort, aber vielleicht eine Folgefrage (die ursprüngliche Frage war nicht explizit):

readlinkist in Ordnung, wenn Sie tatsächlich Symlinks folgen möchten. Es gibt aber auch einen Anwendungsfall für das bloße Normalisieren von ./und ../und //Sequenzen, der rein syntaktisch durchgeführt werden kann, ohne Symlinks zu kanonisieren. readlinkist nicht gut dafür und auch nicht realpath.

for f in $paths; do (cd $f; pwd); done

funktioniert für vorhandene Pfade, bricht aber für andere.

Ein sedSkript scheint eine gute Wahl zu sein, außer dass Sie Sequenzen ( /foo/bar/baz/../..-> /foo/bar/..-> /foo) nicht iterativ ersetzen können, ohne etwas wie Perl zu verwenden, das nicht auf allen Systemen sicher angenommen werden kann, oder eine hässliche Schleife zu verwenden, um die Ausgabe von sedto zu vergleichen seine Eingabe.

FWIW, ein Einzeiler mit Java (JDK 6+):

jrunscript -e 'for (var i = 0; i < arguments.length; i++) {println(new java.io.File(new java.io.File(arguments[i]).toURI().normalize()))}' $paths

Ich bin zu spät zur Party, aber dies ist die Lösung, die ich entwickelt habe, nachdem ich eine Reihe von Themen wie diese gelesen habe:

resolve_dir() {
        (builtin cd `dirname "${1/#~/$HOME}"`'/'`basename "${1/#~/$HOME}"` 2>/dev/null; if [ $? -eq 0 ]; then pwd; fi)
}

Dies wird den absoluten Pfad von $ 1 auflösen, gut mit ~ spielen, Symlinks in dem Pfad behalten, in dem sie sich befinden, und es wird nicht mit Ihrem Verzeichnisstapel in Konflikt geraten. Es gibt den vollständigen Pfad oder nichts zurück, wenn es nicht existiert. Es wird erwartet, dass 1 US-Dollar ein Verzeichnis ist, und es wird wahrscheinlich fehlschlagen, wenn dies nicht der Fall ist. Dies ist jedoch eine einfache Überprüfung, die Sie selbst durchführen können.

Gesprächige und etwas späte Antwort. Ich muss einen schreiben, da ich auf älterem RHEL4 / 5 stecke. Ich behandle absolute und relative Links und vereinfache //, /./ und somedir /../ Einträge.

test -x /usr/bin/readlink || readlink () {
        echo $(/bin/ls -l $1 | /bin/cut -d'>' -f 2)
    }


test -x /usr/bin/realpath || realpath () {
    local PATH=/bin:/usr/bin
    local inputpath=$1
    local changemade=1
    while [ $changemade -ne 0 ]
    do
        changemade=0
        local realpath=""
        local token=
        for token in ${inputpath//\// }
        do 
            case $token in
            ""|".") # noop
                ;;
            "..") # up one directory
                changemade=1
                realpath=$(dirname $realpath)
                ;;
            *)
                if [ -h $realpath/$token ] 
                then
                    changemade=1
                    target=`readlink $realpath/$token`
                    if [ "${target:0:1}" = '/' ]
                    then
                        realpath=$target
                    else
                        realpath="$realpath/$target"
                    fi
                else
                    realpath="$realpath/$token"
                fi
                ;;
            esac
        done
        inputpath=$realpath
    done
    echo $realpath
}

mkdir -p /tmp/bar
(cd /tmp ; ln -s /tmp/bar foo; ln -s ../.././usr /tmp/bar/link2usr)
echo `realpath /tmp/foo`

Testen Sie unser neues Bash-Bibliotheksprodukt realpath-lib , das wir kostenlos und unbeschwert auf GitHub eingestellt haben. Es ist gründlich dokumentiert und ein großartiges Lernwerkzeug.

Es löst lokale, relative und absolute Pfade auf und hat keine Abhängigkeiten außer Bash 4+. es sollte also fast überall funktionieren. Es ist kostenlos, sauber, einfach und lehrreich.

Du kannst tun:

get_realpath <absolute|relative|symlink|local file path>

Diese Funktion ist der Kern der Bibliothek:

function get_realpath() {

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

# reassemble realpath
echo "$tmppwd"/"${1##*/}"
return 0 # success

}

Es enthält auch Funktionen zu get_dirname, get_filename, get_ stemname und validate_path. Probieren Sie es plattformübergreifend aus und helfen Sie, es zu verbessern.

Das Problem dabei realpathist, dass es unter BSD (oder OSX) nicht verfügbar ist. Hier ist ein einfaches Rezept, das aus einem ziemlich alten Artikel (2009) aus dem Linux Journal extrahiert wurde und ziemlich portabel ist:

function normpath() {
  # Remove all /./ sequences.
  local path=${1//\/.\//\/}

  # Remove dir/.. sequences.
  while [[ $path =~ ([^/][^/]*/\.\./) ]]; do
    path=${path/${BASH_REMATCH[0]}/}
  done
  echo $path
}

Beachten Sie auch diese Variante nicht nicht den Pfad erfordern zu existieren.

Basierend auf der Antwort von @ Andre könnte ich eine etwas bessere Version haben, falls jemand nach einer schleifenfreien, vollständig auf String-Manipulation basierenden Lösung sucht. Es ist auch nützlich für diejenigen, die keine Symlinks dereferenzieren möchten, was der Nachteil der Verwendung von realpathoder ist readlink -f.

Es funktioniert mit Bash-Versionen 3.2.25 und höher.

shopt -s extglob

normalise_path() {
    local path="$1"
    # get rid of /../ example: /one/../two to /two
    path="${path//\/*([!\/])\/\.\./}"
    # get rid of /./ and //* example: /one/.///two to /one/two
    path="${path//@(\/\.\/|\/+(\/))//}"
    # remove the last '/.'
    echo "${path%%/.}"
}

$ normalise_path /home/codemedic/../codemedic////.config
/home/codemedic/.config

Basierend auf Loveborgs exzellentem Python-Snippet habe ich Folgendes geschrieben:

#!/bin/sh

# Version of readlink that follows links to the end; good for Mac OS X

for file in "$@"; do
  while [ -h "$file" ]; do
    l=`readlink $file`
    case "$l" in
      /*) file="$l";;
      *) file=`dirname "$file"`/"$l"
    esac
  done
  #echo $file
  python -c "import os,sys; print os.path.abspath(sys.argv[1])" "$file"
done

FILEPATH="file.txt"
echo $(realpath $(dirname $FILEPATH))/$(basename $FILEPATH)

Dies funktioniert auch dann, wenn die Datei nicht vorhanden ist. Das Verzeichnis, in dem sich die Datei befindet, muss vorhanden sein.

Ich brauchte eine Lösung, die alle drei Aufgaben erfüllt:

• Arbeiten Sie an einem Standard-Mac. realpathund readlink -fsind Addons
• Symlinks auflösen
• Fehlerbehandlung haben

Keine der Antworten hatte sowohl # 1 als auch # 2. Ich habe # 3 hinzugefügt, um anderen die weitere Yak-Rasur zu ersparen.

#!/bin/bash

P="${1?Specify a file path}"

[ -e "$P" ] || { echo "File does not exist: $P"; exit 1; }

while [ -h "$P" ] ; do
    ls="$(ls -ld "$P")"
    link="$(expr "$ls" : '.*-> \(.*\)$')"
    expr "$link" : '/.*' > /dev/null &&
        P="$link" ||
        P="$(dirname "$P")/$link"
done
echo "$(cd "$(dirname "$P")"; pwd)/$(basename "$P")"

Hier ist ein kurzer Testfall mit einigen verdrehten Leerzeichen in den Pfaden, um das Zitat vollständig auszuführen

mkdir -p "/tmp/test/ first path "
mkdir -p "/tmp/test/ second path "
echo "hello" > "/tmp/test/ first path / red .txt "
ln -s "/tmp/test/ first path / red .txt " "/tmp/test/ second path / green .txt "

cd  "/tmp/test/ second path "
fullpath " green .txt "
cat " green .txt "

Ich weiß, dass dies eine alte Frage ist. Ich biete immer noch eine Alternative an. Kürzlich bin ich auf dasselbe Problem gestoßen und habe keinen vorhandenen und portablen Befehl dafür gefunden. Also habe ich das folgende Shell-Skript geschrieben, das eine Funktion enthält, die den Trick ausführen kann.

#! /bin/sh                                                                                                                                                

function normalize {
  local rc=0
  local ret

  if [ $# -gt 0 ] ; then
    # invalid
    if [ "x`echo $1 | grep -E '^/\.\.'`" != "x" ] ; then
      echo $1
      return -1
    fi

    # convert to absolute path
    if [ "x`echo $1 | grep -E '^\/'`" == "x" ] ; then
      normalize "`pwd`/$1"
      return $?
    fi

    ret=`echo $1 | sed 's;/\.\($\|/\);/;g' | sed 's;/[^/]*[^/.]\+[^/]*/\.\.\($\|/\);/;g'`
  else
    read line
    normalize "$line"
    return $?
  fi

  if [ "x`echo $ret | grep -E '/\.\.?(/|$)'`" != "x" ] ; then
    ret=`normalize "$ret"`
    rc=$?
  fi

  echo "$ret"
  return $rc
}

https://gist.github.com/bestofsong/8830bdf3e5eb9461d27313c3c282868c

Ich habe eine integrierte Funktion entwickelt, um dies zu handhaben, wobei der Schwerpunkt auf der höchstmöglichen Leistung liegt (zum Spaß). Symlinks werden nicht aufgelöst, daher ist es im Grunde dasselbe wie realpath -sm.

## A bash-only mimic of `realpath -sm`. 
## Give it path[s] as argument[s] and it will convert them to clean absolute paths
abspath () { 
  ${*+false} && { >&2 echo $FUNCNAME: missing operand; return 1; };
  local c s p IFS='/';  ## path chunk, absolute path, input path, IFS for splitting paths into chunks
  local -i r=0;         ## return value

  for p in "$@"; do
    case "$p" in        ## Check for leading backslashes, identify relative/absolute path
    '') ((r|=1)); continue;;
    //[!/]*)  >&2 echo "paths =~ ^//[^/]* are impl-defined; not my problem"; ((r|=2)); continue;;
    /*) ;;
    *)  p="$PWD/$p";;   ## Prepend the current directory to form an absolute path
    esac

    s='';
    for c in $p; do     ## Let IFS split the path at '/'s
      case $c in        ### NOTE: IFS is '/'; so no quotes needed here
      ''|.) ;;          ## Skip duplicate '/'s and '/./'s
      ..) s="${s%/*}";; ## Trim the previous addition to the absolute path string
      *)  s+=/$c;;      ### NOTE: No quotes here intentionally. They make no difference, it seems
      esac;
    done;

    echo "${s:-/}";     ## If xpg_echo is set, use `echo -E` or `printf $'%s\n'` instead
  done
  return $r;
}

Hinweis: Diese Funktion verarbeitet keine Pfade, die mit beginnen //, da genau zwei doppelte Schrägstriche am Anfang eines Pfads ein implementierungsdefiniertes Verhalten sind. Es behandelt jedoch /,/// und so weiter gut.

Diese Funktion scheint alle Randfälle richtig zu behandeln, aber es gibt möglicherweise noch einige, mit denen ich mich nicht befasst habe.

Leistungshinweis: Wird beim Aufrufen mit Tausenden von Argumenten abspathetwa 10-mal langsamer ausgeführt als realpath -sm; Wenn es mit einem einzelnen Argument aufgerufen wird, abspathläuft es> 110x schneller als realpath -smauf meinem Computer, hauptsächlich weil nicht jedes Mal ein neues Programm ausgeführt werden muss.

Ich habe heute festgestellt, dass Sie den statBefehl zum Auflösen von Pfaden verwenden können.

Also für ein Verzeichnis wie "~ / Documents":

Sie können dies ausführen:

stat -f %N ~/Documents

So erhalten Sie den vollständigen Pfad:

/Users/me/Documents

Für Symlinks können Sie die Option% Y-Format verwenden:

stat -f %Y example_symlink

Welches könnte ein Ergebnis zurückgeben wie:

/usr/local/sbin/example_symlink

Die Formatierungsoptionen können in anderen Versionen von * NIX unterschiedlich sein, aber diese haben unter OSX für mich funktioniert.

Eine einfache Lösung mit node.js:

#!/usr/bin/env node
process.stdout.write(require('path').resolve(process.argv[2]));