Come si normalizza un percorso di file in Bash?

Voglio trasformarmi /foo/bar/.. in/foo

C'è un comando bash che lo fa?

Modifica: nel mio caso pratico, la directory esiste.

se vuoi separare parte del nome di un file dal percorso, "dirname" e "basename" sono i tuoi amici e anche "realpath" è utile.

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 alternative

Se realpathnon è supportato dalla tua shell, puoi provare

readlink -f /path/here/.. 

Anche

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

Funziona come

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

in quanto non è necessario che il percorso esista per essere normalizzato.

Non so se esiste un comando bash diretto per farlo, ma di solito lo faccio

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

e funziona bene.

Prova realpath. Di seguito la fonte nella sua interezza, con la presente donata al pubblico dominio.

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

Una soluzione portatile e affidabile è l'uso di Python, che è preinstallato praticamente ovunque (incluso Darwin). Hai due opzioni:

1. abspath restituisce un percorso assoluto ma non risolve i collegamenti simbolici:

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

2. realpath restituisce un percorso assoluto e in tal modo risolve i collegamenti simbolici, generando un percorso canonico:

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

In ogni caso, path/to/filepuò essere un percorso relativo o assoluto.

Utilizzare l'utilità readlink dal pacchetto coreutils.

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

readlinkè lo standard bash per ottenere il percorso assoluto. Ha anche il vantaggio di restituire stringhe vuote se non esistono percorsi o percorsi (dati i flag per farlo).

Per ottenere il percorso assoluto di una directory che può esistere o meno, ma che esistono i genitori, utilizzare:

abspath=$(readlink -f $path)

Per ottenere il percorso assoluto di una directory che deve esistere insieme a tutti i genitori:

abspath=$(readlink -e $path)

Per canonicalizzare il percorso specificato e seguire i collegamenti simbolici se esistono, ma altrimenti ignorare le directory mancanti e restituire comunque il percorso, è:

abspath=$(readlink -m $path)

L'unico aspetto negativo è che readlink seguirà i collegamenti. Se non si desidera seguire i collegamenti, è possibile utilizzare questa convenzione alternativa:

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

Verrà indirizzato alla parte della directory di $ path e stamperà la directory corrente insieme alla parte del file di $ path. Se non riesce a chdir, si ottiene una stringa vuota e un errore su stderr.

Vecchia domanda, ma c'è un modo molto più semplice se hai a che fare con nomi di percorsi completi a livello di shell:

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

Poiché il cd si presenta in una subshell non ha alcun impatto sullo script principale.

Due varianti, supponendo che i comandi incorporati della shell accettano -L e -P, sono:

   abspath = "$ (cd -P" $ percorso "&& pwd -P)" # percorso fisico con collegamenti simbolici risolti
   abspath = "$ (cd -L" $ path "&& pwd -L)" #percorso logico che preserva i collegamenti simbolici

Personalmente, raramente ho bisogno di questo approccio successivo a meno che non sia affascinato dai collegamenti simbolici per qualche motivo.

Cordiali saluti: variazione su come ottenere la directory iniziale di uno script che funziona anche se lo script cambia la directory corrente in un secondo momento.

name0 = "$ (basename" $ ​​0 ")"; #base name of script
dir0 = "$ (cd" $ (dirname "$ 0") "&& pwd)"; #absolute dir iniziale

L'uso del CD ti assicura di avere sempre la directory assoluta, anche se lo script è eseguito da comandi come ./script.sh che, senza cd / pwd, spesso dà solo .. Inutile se lo script fa un cd in seguito.

Come ha osservato Adam Liss, realpathnon è incluso in ogni distribuzione. È un peccato, perché è la soluzione migliore. Il codice sorgente fornito è eccezionale e probabilmente inizierò ad usarlo ora. Ecco quello che ho usato fino ad ora, che condivido qui solo per completezza:

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

Se vuoi che risolva i collegamenti simbolici, sostituiscili pwdcon pwd -P.

La mia recente soluzione è stata:

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

Basato sulla risposta di Tim Whitcomb.

Non esattamente una risposta ma forse una domanda di follow-up (la domanda originale non era esplicita):

readlinkva bene se vuoi davvero seguire i symlink. Ma v'è anche un caso d'uso per normalizzare meramente ./ed ../e //sequenze, che può essere fatto puramente sintatticamente, senza canonicalizing link simbolici. readlinknon va bene per questo, e nemmeno lo è realpath.

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

funziona per percorsi esistenti, ma si interrompe per gli altri.

Una sedsceneggiatura sembrerebbe essere una buona scommessa, se non che non è possibile sostituire iterativamente sequenze ( /foo/bar/baz/../..-> /foo/bar/..-> /foo) senza usare qualcosa di simile a Perl, che non è lecito ritenere su tutti i sistemi, o usando qualche brutto ciclo per confrontare l'output di seda il suo input.

FWIW, one-liner che utilizza 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

Sono in ritardo alla festa, ma questa è la soluzione che ho creato dopo aver letto un sacco di discussioni come questa:

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

Questo risolverà il percorso assoluto di $ 1, giocherà bene con ~, manterrà i collegamenti simbolici nel percorso in cui si trovano e non rovinerà il tuo stack di directory. Restituisce il percorso completo o nulla se non esiste. Si aspetta che $ 1 sia una directory e probabilmente fallirà se non lo è, ma è un controllo facile da fare da soli.

Loquace, e un po 'in ritardo risposta. Devo scriverne uno poiché sono bloccato su RHEL4 / 5 precedente. Gestisco collegamenti assoluti e relativi e semplifica le voci //, /./ e somedir /../.

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`

Prova il nostro nuovo prodotto della libreria Bash realpath-lib che abbiamo inserito su GitHub per un uso gratuito e senza restrizioni. È accuratamente documentato e costituisce un ottimo strumento di apprendimento.

Risolve percorsi locali, relativi e assoluti e non ha dipendenze tranne Bash 4+; quindi dovrebbe funzionare praticamente ovunque. È gratuito, pulito, semplice ed istruttivo.

Tu puoi fare:

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

Questa funzione è il nucleo della libreria:

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

}

Contiene anche funzioni per get_dirname, get_filename, get_ stemname e validate_path. Provalo su tutte le piattaforme e aiuta a migliorarlo.

Il problema realpathè che non è disponibile su BSD (o OSX per quella materia). Ecco una semplice ricetta estratta da un articolo piuttosto vecchio (2009) del Linux Journal , che è abbastanza portatile:

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

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

Si noti che questa variante non richiede che il percorso esista.

Sulla base della risposta di @ Andre, potrei avere una versione leggermente migliore, nel caso qualcuno stia cercando una soluzione completamente priva di loop, basata sulla manipolazione delle stringhe. È anche utile per coloro che non vogliono sottovalutare alcun collegamento simbolico, che è il rovescio della medaglia dell'uso di realpatho readlink -f.

Funziona su bash versioni 3.2.25 e successive.

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

Basato sull'eccellente frammento di pitone di loveborg, ho scritto questo:

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

Funziona anche se il file non esiste. Richiede l'esistenza della directory contenente il file.

Avevo bisogno di una soluzione che avrebbe fatto tutte e tre le cose:

• Lavora su un Mac di serie. realpathereadlink -f sono addon
• Risolvi i collegamenti simbolici
• Gestione degli errori

Nessuna delle risposte aveva sia il numero 1 che il numero 2. Ho aggiunto il n. 3 per salvare altri eventuali rasatura di yak.

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

Ecco un breve test case con alcuni spazi contorti nei percorsi per esercitare pienamente la quotazione

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 "

So che questa è una domanda antica. Sto ancora offrendo un'alternativa. Recentemente ho riscontrato lo stesso problema e non ho trovato alcun comando esistente e portatile per farlo. Quindi ho scritto il seguente script di shell che include una funzione che può fare il trucco.

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

Ho realizzato una funzione solo integrata per gestirlo con un focus sulle massime prestazioni possibili (per divertimento). Non risolve i collegamenti simbolici, quindi è sostanzialmente lo stesso di 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;
}

Nota: questa funzione non gestisce i percorsi che iniziano con //, poiché esattamente due doppie barre all'inizio di un percorso sono comportamenti definiti dall'implementazione. Tuttavia, gestisce /,/// e così via bene.

Questa funzione sembra gestire correttamente tutti i casi limite, ma potrebbero essercene ancora alcuni là fuori che non ho affrontato.

Nota sulle prestazioni: quando viene chiamato con migliaia di argomenti, abspathviene eseguito circa 10 volte più lentamente di realpath -sm; quando viene chiamato con un singolo argomento, abspathviene eseguito> 110 volte più veloce rispetto realpath -smalla mia macchina, principalmente a causa della non necessità di eseguire un nuovo programma ogni volta.

Oggi ho scoperto che puoi usare il statcomando per risolvere i percorsi.

Quindi per una directory come "~ / Documents":

Puoi eseguire questo:

stat -f %N ~/Documents

Per ottenere il percorso completo:

/Users/me/Documents

Per i collegamenti simbolici, puoi utilizzare l'opzione di formato% Y:

stat -f %Y example_symlink

Che potrebbe restituire un risultato come:

/usr/local/sbin/example_symlink

Le opzioni di formattazione potrebbero essere diverse su altre versioni di * NIX, ma queste hanno funzionato per me su OSX.

Una soluzione semplice che utilizza node.js:

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