Jak znormalizować ścieżkę do pliku w Bash?

Chcę przekształcić /foo/bar/..do/foo

Czy istnieje polecenie bash, które to robi?

Edycja: w moim praktycznym przypadku katalog istnieje.

jeśli chcesz odciąć część nazwy pliku ze ścieżki, „dirname” i „basename” są twoimi przyjaciółmi, a „realpath” jest również przydatny.

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 alternatywy

Jeśli realpathnie jest obsługiwany przez twoją powłokę, możesz spróbować

readlink -f /path/here/.. 

Również

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

Działa tak samo jak

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

ponieważ ścieżka nie musi istnieć, aby zostać znormalizowana.

Nie wiem, czy jest do tego polecenie bezpośredniego uderzenia, ale zwykle to robię

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

i działa dobrze.

Spróbować realpath. Poniżej znajduje się całe źródło, niniejszym przekazane na rzecz domeny publicznej.

// 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);
}

Przenośne i niezawodne rozwiązanie polega na użyciu Pythona, który jest zainstalowany niemal wszędzie (w tym Darwin). Masz dwie opcje:

1. abspath zwraca ścieżkę bezwzględną, ale nie rozpoznaje dowiązań symbolicznych:

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

2. realpath zwraca ścieżkę bezwzględną iw ten sposób rozwiązuje dowiązania symboliczne, generując ścieżkę kanoniczną:

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

W każdym przypadku path/to/filemoże to być ścieżka względna lub bezwzględna.

Użyj narzędzia readlink z pakietu coreutils.

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

readlinkjest standardem bash dla uzyskania absolutnej ścieżki. Ma również tę zaletę, że zwraca puste ciągi, jeśli ścieżki lub ścieżka nie istnieje (biorąc pod uwagę flagi).

Aby uzyskać bezwzględną ścieżkę do katalogu, który może istnieć, ale którego rodzice nie istnieją, użyj:

abspath=$(readlink -f $path)

Aby uzyskać bezwzględną ścieżkę do katalogu, który musi istnieć wraz ze wszystkimi rodzicami:

abspath=$(readlink -e $path)

Aby kanonizować podaną ścieżkę i podążać za dowiązaniami symbolicznymi, jeśli takowe istnieją, ale w przeciwnym razie zignoruj ​​brakujące katalogi i po prostu zwróć ścieżkę, to:

abspath=$(readlink -m $path)

Jedynym minusem jest to, że readlink będzie podążał za linkami. Jeśli nie chcesz podążać za linkami, możesz skorzystać z tej alternatywnej konwencji:

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

Spowoduje to przejście do części katalogu $ path i wydrukowanie bieżącego katalogu wraz z częścią pliku $ path. Jeśli nie uda się zmienić chdir, otrzymasz pusty ciąg i błąd na stderr.

Stare pytanie, ale jest o wiele prostszy sposób, jeśli masz do czynienia z pełnymi nazwami ścieżek na poziomie powłoki:

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

Ponieważ cd dzieje się w podpowłoce, nie ma to wpływu na główny skrypt.

Dwie odmiany, zakładając, że wbudowane polecenia powłoki akceptują -L i -P, to:

   abspath = "$ (cd -P" $ path "&& pwd -P)" # ścieżka fizyczna z rozwiązanymi dowiązaniami symbolicznymi
   abspath = "$ (cd -L" $ path "&& pwd -L)" #logiczna ścieżka zachowująca dowiązania symboliczne

Osobiście rzadko potrzebuję tego późniejszego podejścia, chyba że z jakiegoś powodu fascynują mnie dowiązania symboliczne.

FYI: wariant uzyskania katalogu początkowego skryptu, który działa, nawet jeśli skrypt zmieni później swój katalog bieżący.

name0 = "$ (basename" $ ​​0 ")"; # nazwa bazy skryptu
dir0 = "$ (cd" $ (nazwa katalogu "$ 0") "&& pwd)"; #absolute start reż

Korzystanie z CD zapewnia, że ​​zawsze masz katalog absolutny, nawet jeśli skrypt jest uruchamiany przez polecenia takie jak ./script.sh, które bez cd / pwd często dają po prostu ... Bezużyteczne, jeśli skrypt zrobi później płytę CD.

Jak zauważył Adam Liss, realpathnie jest on zawarty w każdej dystrybucji. Szkoda, bo to najlepsze rozwiązanie. Podany kod źródłowy jest świetny i prawdopodobnie zacznę go teraz używać. Oto, czego używałem do tej pory, które udostępniam tutaj tylko dla kompletności:

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

Jeśli chcesz go do dowiązania postanowienie, wystarczy wymienić pwdz pwd -P.

Moje ostatnie rozwiązanie to:

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

Na podstawie odpowiedzi Tima Whitcomba.

Nie do końca odpowiedź, ale być może pytanie uzupełniające (pierwotne pytanie nie było jednoznaczne):

readlinkjest w porządku, jeśli faktycznie chcesz podążać za dowiązaniami symbolicznymi. Ale jest też przypadek użycia jedynie dla normalizacji ./i ../i //sekwencje, które można zrobić czysto składniowo, bez canonicalizing dowiązania. readlinknie nadaje się do tego i nie jest realpath.

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

działa dla istniejących ścieżek, ale zrywa dla innych.

sedScenariusz wydaje się być dobry zakład, z wyjątkiem, że nie można iteracyjnie zastąpić sekwencje ( /foo/bar/baz/../..-> /foo/bar/..-> /foo) bez użycia coś jak Perl, których nie można bezpiecznie przyjąć na wszystkich systemach, lub przy użyciu pewnego brzydkiego pętlę porównać dane wyjściowe seddo jego wkład.

FWIW, jedno-liniowy przy użyciu 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

Jestem spóźniony na imprezę, ale oto rozwiązanie, które stworzyłem po przeczytaniu kilku takich wątków:

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

To rozwiąże bezwzględną ścieżkę 1 $, będziesz grać fajnie z ~, utrzymywać dowiązania symboliczne na ścieżce, na której się znajdują, i nie będzie bałaganu ze stosem katalogów. Zwraca pełną ścieżkę lub nic, jeśli nie istnieje. Oczekuje, że 1 USD będzie katalogiem i prawdopodobnie nie powiedzie się, jeśli tak nie jest, ale łatwo to zrobić samodzielnie.

Rozmowna i nieco spóźniona odpowiedź. Muszę napisać jeden, ponieważ utknąłem na starszym RHEL4 / 5. Obsługuję linki bezwzględne i względne oraz upraszczam //, /./ i somedir /../ wpisy.

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`

Wypróbuj nasz nowy produkt biblioteczny Bash realpath-lib , który umieściliśmy w GitHub do bezpłatnego i nieobciążonego użytku. Jest dokładnie udokumentowany i stanowi świetne narzędzie do nauki.

Rozwiązuje ścieżki lokalne, względne i bezwzględne i nie ma żadnych zależności oprócz Bash 4+; więc powinno działać prawie wszędzie. Jest bezpłatny, czysty, prosty i pouczający.

Możesz to zrobić:

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

Ta funkcja jest rdzeniem biblioteki:

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

}

Zawiera także funkcje do get_dirname, get_filename, get_ stemname i validate_path. Wypróbuj go na różnych platformach i pomóż go ulepszyć.

Problem realpathpolega na tym, że nie jest on dostępny w BSD (lub OSX, jeśli o to chodzi). Oto prosty przepis wyodrębniony z dość starego (2009) artykułu z Linux Journal , który jest dość przenośny:

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

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

Zauważ, że ten wariant również nie wymaga istnienia ścieżki.

W oparciu o odpowiedź @ Andre, mogę mieć nieco lepszą wersję, na wypadek, gdyby ktoś szukał rozwiązania bez pętli, całkowicie opartego na manipulowaniu ciągami. Jest także przydatny dla tych, którzy nie chcą rezygnować z żadnych dowiązań symbolicznych, co jest wadą używania realpathlub readlink -f.

Działa na wersjach bash 3.2.25 i wyższych.

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

Na podstawie doskonałego fragmentu python loveborga napisałem:

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

Działa to nawet wtedy, gdy plik nie istnieje. Wymaga istnienia katalogu zawierającego plik.

Potrzebowałem rozwiązania, które spełniłoby wszystkie trzy:

• Pracuj na standardowym komputerze Mac. realpathireadlink -f są dodatkami
• Rozwiąż dowiązania symboliczne
• Mieć obsługę błędów

Żadna z odpowiedzi nie miała zarówno # 1, jak i # 2. Dodałem # 3, aby uratować innych przed dalszym goleniem jaków.

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

Oto krótki przypadek testowy z zakrzywionymi spacjami na ścieżkach, aby w pełni wykonać cytowanie

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 "

Wiem, że to starożytne pytanie. Nadal oferuję alternatywę. Ostatnio spotkałem ten sam problem i nie znalazłem żadnego istniejącego i przenośnego polecenia, aby to zrobić. Napisałem więc następujący skrypt powłoki, który zawiera funkcję, która może załatwić sprawę.

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

Zrobiłem tylko wbudowaną funkcję, aby poradzić sobie z tym, koncentrując się na najwyższej możliwej wydajności (dla zabawy). Nie rozpoznaje dowiązań symbolicznych, więc jest w zasadzie taki sam jak 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;
}

Uwaga: Ta funkcja nie obsługuje ścieżek zaczynających się od //, ponieważ dokładnie dwa podwójne ukośniki na początku ścieżki są zachowaniem zdefiniowanym przez implementację. Jednakże, uchwyty /,/// i tak dalej dobrze.

Ta funkcja wydaje się poprawnie obsługiwać wszystkie przypadki krawędzi, ale może być jeszcze kilka takich, z którymi nie miałem do czynienia.

Uwaga dotycząca wydajności: wywołana z tysiącami argumentów abspathdziała około 10 razy wolniej niż realpath -sm; wywołany jednym argumentem abspathdziała> 110 razy szybciej niż realpath -smna moim komputerze, głównie z powodu braku konieczności uruchamiania nowego programu za każdym razem.

Odkryłem dzisiaj, że możesz użyć stat polecenia do rozpoznawania ścieżek.

W przypadku katalogu takiego jak „~ / Documents”:

Możesz uruchomić to:

stat -f %N ~/Documents

Aby uzyskać pełną ścieżkę:

/Users/me/Documents

W przypadku dowiązań symbolicznych możesz użyć opcji formatu% Y:

stat -f %Y example_symlink

Co może zwrócić wynik taki jak:

/usr/local/sbin/example_symlink

Opcje formatowania mogą się różnić w innych wersjach * NIX, ale te działały dla mnie w OSX.

Proste rozwiązanie wykorzystujące node.js:

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