Domanda: esiste un semplice comando sh / bash / zsh / fish / ... per stampare il percorso assoluto di qualunque file lo alimento?

Caso di utilizzo: Sono in directory /a/be mi piacerebbe stampare il percorso completo del file csulla riga di comando in modo che possa facilmente incollarlo in un altro programma: /a/b/c. Semplice, ma un piccolo programma per farlo potrebbe probabilmente farmi risparmiare circa 5 secondi quando si tratta di gestire percorsi lunghi, che alla fine si sommano. Quindi mi sorprende il fatto che non riesco a trovare un'utilità standard per fare questo - c'è davvero nessuno?

Ecco un'implementazione di esempio, abspath.py:

#!/usr/bin/python
# Author: Diggory Hardy <diggory.hardy@gmail.com>
# Licence: public domain
# Purpose: print the absolute path of all input paths

import sys
import os.path
if len(sys.argv)>1:
    for i in range(1,len(sys.argv)):
        print os.path.abspath( sys.argv[i] )
    sys.exit(0)
else:
    print >> sys.stderr, "Usage: ",sys.argv[0]," PATH."
    sys.exit(1)

Prova realpath.

$ realpath example.txt
/home/username/example.txt

Prova readlinkche risolverà i collegamenti simbolici:

readlink -e /foo/bar/baz

#! /bin/sh
echo "$(cd "$(dirname "$1")"; pwd -P)/$(basename "$1")"

Dimentica readlinke realpathquali potrebbero essere o meno installati sul tuo sistema.

Espandendo la risposta di dogbane qui sopra viene espressa come una funzione:

#!/bin/bash
get_abs_filename() {
  # $1 : relative filename
  echo "$(cd "$(dirname "$1")" && pwd)/$(basename "$1")"
}

puoi quindi usarlo in questo modo:

myabsfile=$(get_abs_filename "../../foo/bar/file.txt")

Come e perché funziona?

La soluzione sfrutta il fatto che il pwdcomando integrato di Bash stamperà il percorso assoluto della directory corrente quando viene richiamato senza argomenti.

Perché mi piace questa soluzione?

È portatile e non richiede nessuno dei due readlinko realpathche spesso non esiste su un'installazione predefinita di una determinata distribuzione Linux / Unix.

E se dir non esiste?

Come indicato sopra, la funzione fallirà e verrà stampata su stderr se il percorso della directory indicato non esiste. Questo potrebbe non essere quello che vuoi. È possibile espandere la funzione per gestire quella situazione:

#!/bin/bash
get_abs_filename() {
  # $1 : relative filename
  if [ -d "$(dirname "$1")" ]; then
    echo "$(cd "$(dirname "$1")" && pwd)/$(basename "$1")"
  fi
}

Ora restituirà una stringa vuota se non esiste una directory principale.

Come gestisci il trailing '..' o '.' in input?

Bene, in questo caso fornisce un percorso assoluto, ma non minimo. Sembrerà che:

/Users/bob/Documents/..

Se vuoi risolvere il ".." dovrai creare lo script come:

get_abs_filename() {
  # $1 : relative filename
  filename=$1
  parentdir=$(dirname "${filename}")

  if [ -d "${filename}" ]; then
      echo "$(cd "${filename}" && pwd)"
  elif [ -d "${parentdir}" ]; then
    echo "$(cd "${parentdir}" && pwd)/$(basename "${filename}")"
  fi
}

$ readlink -m FILE
/path/to/FILE

Questo è meglio di readlink -e FILEo realpath, perché funziona anche se il file non esiste.

Questo percorso relativo alla funzione shell del convertitore di percorso assoluto

• non richiede utilità (solo cde pwd)
• funziona per directory e file
• maniglie ..e.
• gestisce gli spazi in dir o nomi di file
• richiede che il file o la directory esistano
• non restituisce nulla se non esiste nulla nel percorso specificato
• gestisce i percorsi assoluti come input (li attraversa essenzialmente)

Codice:

function abspath() {
    # generate absolute path from relative path
    # $1     : relative filename
    # return : absolute path
    if [ -d "$1" ]; then
        # dir
        (cd "$1"; pwd)
    elif [ -f "$1" ]; then
        # file
        if [[ $1 = /* ]]; then
            echo "$1"
        elif [[ $1 == */* ]]; then
            echo "$(cd "${1%/*}"; pwd)/${1##*/}"
        else
            echo "$(pwd)/$1"
        fi
    fi
}

Campione:

# assume inside /parent/cur
abspath file.txt        => /parent/cur/file.txt
abspath .               => /parent/cur
abspath ..              => /parent
abspath ../dir/file.txt => /parent/dir/file.txt
abspath ../dir/../dir   => /parent/dir          # anything cd can handle
abspath doesnotexist    =>                      # empty result if file/dir does not exist
abspath /file.txt       => /file.txt            # handle absolute path input

Nota: si basa sulle risposte di nolan6000 e bsingh , ma risolve il caso del file.

Comprendo anche che la domanda originale riguardava un'utilità della riga di comando esistente. Ma dal momento che questa sembra essere LA domanda su stackoverflow per quello che include script di shell che vogliono avere dipendenze minime, ho messo questa soluzione di script qui, così posso trovarla in seguito :)

Il findcomando può aiutare

find $PWD -name ex*
find $PWD -name example.log

Elenca tutti i file all'interno o al di sotto della directory corrente con nomi corrispondenti al modello. Puoi semplificarlo se otterrai solo alcuni risultati (es. Directory vicino alla parte inferiore dell'albero contenente pochi file), giusto

find $PWD

Lo uso su Solaris 10, che non ha menzionato le altre utility.

Se non si dispone di utility readlink o realpath di quelle che è possibile utilizzare la seguente funzione che funziona in bash e zsh (non sono sicuro del resto).

abspath () { case "$1" in /*)printf "%s\n" "$1";; *)printf "%s\n" "$PWD/$1";; esac; }

Questo funziona anche con file inesistenti (come la funzione python os.path.abspath).

Sfortunatamente abspath ./../somefilenon si sbarazza dei punti.

Ecco una funzione solo zsh che mi piace per la sua compattezza. Usa il modificatore di espansione 'A' - vedi zshexpn (1).

realpath() { for f in "$@"; do echo ${f}(:A); done }

Non v'è generalmente una cosa come il absolute path un file (questa affermazione significa che ci possono essere più di uno, in generale, da qui l'uso dell'articolo determinativo il non è appropriato). Un absolute pathè qualsiasi percorso che parte dalla radice "/" e designa un file senza ambiguità indipendentemente dalla directory di lavoro (vedi ad esempio Wikipedia ).

A relative pathè un percorso che deve essere interpretato a partire da un'altra directory. Potrebbe essere la directory di lavoro se viene relative pathmanipolata da un'applicazione (anche se non necessariamente). Quando si trova in un collegamento simbolico in una directory, è generalmente inteso per essere relativo a quella directory (sebbene l'utente possa avere in mente altri usi).

Quindi un percorso assoluto è solo un percorso relativo alla directory principale.

Un percorso (assoluto o relativo) può contenere o meno collegamenti simbolici. In caso contrario, è anche in qualche modo impermeabile ai cambiamenti nella struttura di collegamento, ma ciò non è necessariamente richiesto o addirittura desiderabile. Alcune persone chiamano canonical path(o canonical file nameo resolved path) un punto absolute pathin cui tutti i collegamenti simbolici sono stati risolti, ovvero sono stati sostituiti da un percorso a chiunque si colleghino. I comandi realpathed readlinkentrambi cercano un percorso canonico, ma realpathha solo un'opzione per ottenere un percorso assoluto senza preoccuparsi di risolvere i collegamenti simbolici (insieme a diverse altre opzioni per ottenere vari tipi di percorsi, assoluti o relativi ad alcune directory).

Ciò richiede diverse osservazioni:

1. i collegamenti simbolici possono essere risolti solo se ciò che si suppone debbano collegare è già stato creato, il che ovviamente non è sempre il caso. I comandi realpathe readlinkhanno opzioni per tener conto di ciò.
2. una directory su un percorso può in seguito diventare un collegamento simbolico, il che significa che il percorso non lo è più canonical. Quindi il concetto dipende dal tempo (o dall'ambiente).
3. anche nel caso ideale, quando tutti i collegamenti simbolici possono essere risolti, potrebbe essercene ancora più di uno canonical patha un file, per due motivi:
   • la partizione contenente il file potrebbe essere stata montata contemporaneamente ( ro) su più punti di montaggio.
   • potrebbero esserci collegamenti concreti al file, il che significa essenzialmente che il file esiste in diverse directory.

Quindi, anche con la definizione molto più restrittiva di canonical path, potrebbero esserci diversi percorsi canonici per un file. Ciò significa anche che il qualificatore canonicalè alquanto inadeguato poiché di solito implica una nozione di unicità.

Questo espande una breve discussione sull'argomento in una risposta a un'altra domanda simile in Bash: recuperare il percorso assoluto dato relativo

La mia conclusione è che realpathè progettato meglio e molto più flessibile di readlink. L'unico uso readlinknon coperto da realpathè la chiamata senza opzione che restituisce il valore di un collegamento simbolico.

La dogbane risposta con la descrizione di ciò che sta accadendo:

#! /bin/sh
echo "$(cd "$(dirname "$1")"; pwd)/$(basename "$1")"

Spiegazione:

1. Questo script ottiene il percorso relativo come argomento "$1"
2. Quindi otteniamo dirname parte di quel percorso (puoi passare dir o file a questo script):dirname "$1"
3. Quindi entriamo cd "$(dirname "$1")in questa directory relativa e ne otteniamo il percorso assoluto eseguendo il pwdcomando shell
4. Dopodiché aggiungiamo basename al percorso assoluto:$(basename "$1")
5. Come passo finale che echosi

Perché le directory dirnamevengono inciampate ../e ritornano ./.

La funzione di nolan6000 può essere modificata per correggere che:

get_abs_filename() {
  # $1 : relative filename
  if [ -d "${1%/*}" ]; then
    echo "$(cd ${1%/*}; pwd)/${1##*/}"
  fi
}

Questa non è una risposta alla domanda, ma per chi fa script:

echo `cd "$1" 2>/dev/null&&pwd||(cd "$(dirname "$1")";pwd|sed "s|/*\$|/${1##*/}|")`

gestisce / .. ./ etc correttamente. Sembra anche che funzioni su OSX

Ho inserito il seguente script sul mio sistema e lo chiamo come alias bash per quando voglio prendere rapidamente il percorso completo di un file nella directory corrente:

#!/bin/bash
/usr/bin/find "$PWD" -maxdepth 1 -mindepth 1 -name "$1"

Non sono sicuro del perché, ma, su OS X quando chiamato da uno script "$ PWD" si espande nel percorso assoluto. Quando il comando find viene chiamato dalla riga di comando, non lo fa. Ma fa quello che voglio ... divertiti.

Il più semplice se si desidera utilizzare solo i builtin è probabilmente:

find `pwd` -name fileName

Solo altre due parole da digitare, e questo funzionerà su tutti i sistemi unix, così come su OSX.

#! /bin/bash

file="$@"
realpath "$file" 2>/dev/null || eval realpath $(echo $file | sed 's/ /\\ /g')

Questo compensa le carenze di realpath, memorizzalo in uno script di shell fullpath. Ora puoi chiamare:

$ cd && touch a\ a && rm A 2>/dev/null 
$ fullpath "a a"
/home/user/a a
$ fullpath ~/a\ a
/home/user/a a
$ fullpath A
A: No such file or directory.

Un'alternativa per ottenere il percorso assoluto in Ruby :

realpath() {ruby -e "require 'Pathname'; puts Pathname.new('$1').realpath.to_s";}

Funziona senza argomenti (cartella corrente) e percorso file o cartella relativo e assoluto come agument.

Rispondi con Homebrew

realpathè la risposta migliore, ma se non lo hai installato, devi prima eseguirlo brew install coreutilsche installerà coreutils con molte fantastiche funzioni. Scrivere una funzione personalizzata ed esportarla è troppo lavoro e rischi di errore per qualcosa del genere, ecco due righe:

$ brew install coreutils
$ realpath your-file-name.json 

Ehi ragazzi, lo so che è una vecchia discussione, ma sto solo pubblicando questo come riferimento per chiunque altro abbia visitato questo come me. Se ho capito correttamente la domanda, penso al locate $filenamecomando. Visualizza il percorso assoluto del file fornito, ma solo se esiste.