Question: existe-t-il une simple commande sh / bash / zsh / fish / ... pour imprimer le chemin absolu du fichier que je l'alimente?

Utilisation cas: Je suis dans le répertoire /a/bet je voudrais imprimer le chemin complet vers le fichier csur la ligne de commande afin que je puisse facilement le coller dans un autre programme: /a/b/c. Simple, mais un petit programme pour le faire pourrait probablement me faire gagner environ 5 secondes lorsqu'il s'agit de gérer de longs chemins, ce qui en fin de compte s'additionne. Cela me surprend donc que je ne trouve pas d'utilitaire standard pour le faire - n'y en a-t-il vraiment pas?

Voici un exemple d'implémentation, 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)

Essayez realpath.

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

Essayez readlinkqui résoudra les liens symboliques:

readlink -e /foo/bar/baz

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

Oublier readlinket realpathqui peut ou ne peut pas être installé sur votre système.

Développant la réponse de Dogbane ci-dessus, elle est exprimée en fonction:

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

vous pouvez ensuite l'utiliser comme ceci:

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

Comment et pourquoi ça marche?

La solution exploite le fait que la pwdcommande intégrée Bash affichera le chemin absolu du répertoire courant lorsqu'elle sera invoquée sans arguments.

Pourquoi j'aime cette solution?

Il est portable et ne nécessite pas non plus readlinkou realpathqui n'existe souvent pas sur une installation par défaut d'un distro Linux / Unix donné.

Et si dir n'existe pas?

Comme indiqué ci-dessus, la fonction échouera et s'imprimera sur stderr si le chemin de répertoire donné n'existe pas. Ce n'est peut-être pas ce que vous voulez. Vous pouvez développer la fonction pour gérer cette situation:

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

Maintenant, il retournera une chaîne vide si l'un des répertoires parents n'existe pas.

Comment gérez-vous les «..» ou les «.» en entrée?

Eh bien, cela donne un chemin absolu dans ce cas, mais pas minimal. Cela ressemblera à:

/Users/bob/Documents/..

Si vous voulez résoudre le «..», vous devrez faire le script comme:

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

C'est mieux que readlink -e FILEou realpath, car cela fonctionne même si le fichier n'existe pas.

Ce chemin relatif vers la fonction shell du convertisseur de chemin absolu

• ne nécessite aucun utilitaire (juste cdet pwd)
• fonctionne pour les répertoires et les fichiers
• poignées ..et.
• gère les espaces en dir ou en noms de fichiers
• nécessite l'existence d'un fichier ou d'un répertoire
• ne renvoie rien si rien n'existe sur le chemin donné
• gère les chemins absolus en entrée (les traverse essentiellement)

Code:

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
}

Échantillon:

# 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

Remarque: Ceci est basé sur les réponses de nolan6000 et bsingh , mais corrige le cas du fichier.

Je comprends également que la question d'origine concernait un utilitaire de ligne de commande existant. Mais comme cela semble être LA question sur stackoverflow pour cela, y compris les scripts shell qui veulent avoir des dépendances minimales, j'ai mis cette solution de script ici, donc je peux la trouver plus tard :)

La findcommande peut aider

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

Répertorie tous les fichiers dans ou sous le répertoire actuel avec des noms correspondant au modèle. Vous pouvez le simplifier si vous n'obtiendrez que quelques résultats (par exemple un répertoire au bas de l'arborescence contenant peu de fichiers), juste

find $PWD

Je l'utilise sur Solaris 10, qui n'a pas les autres utilitaires mentionnés.

Si vous n'avez pas d'utilitaires readlink ou realpath, vous pouvez utiliser la fonction suivante qui fonctionne en bash et zsh (pas sûr du reste).

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

Cela fonctionne également pour les fichiers inexistants (tout comme la fonction python os.path.abspath ).

Malheureusement, abspath ./../somefilene se débarrasse pas des points.

Voici une fonction uniquement zsh que j'aime pour sa compacité. Il utilise le modificateur d'expansion 'A' - voir zshexpn (1).

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

Il n'y a généralement pas une telle chose que l' absolute path un fichier (ce moyen de déclaration qu'il peut y avoir plus d'un général, d' où l'utilisation de l'article défini l' est pas approprié). An absolute pathest un chemin qui part de la racine "/" et désigne un fichier sans ambiguïté indépendamment du répertoire de travail (voir par exemple wikipedia ).

A relative pathest un chemin qui doit être interprété à partir d'un autre répertoire. Il peut s'agir du répertoire de travail s'il s'agit d'un relative pathêtre manipulé par une application (mais pas nécessairement). Lorsqu'il se trouve dans un lien symbolique dans un répertoire, il est généralement destiné à être relatif à ce répertoire (bien que l'utilisateur puisse avoir d'autres utilisations en tête).

Par conséquent, un chemin absolu n'est qu'un chemin relatif au répertoire racine.

Un chemin (absolu ou relatif) peut contenir ou non des liens symboliques. Si ce n'est pas le cas, il est également quelque peu imperméable aux changements dans la structure de liaison, mais ce n'est pas nécessairement requis ni même souhaitable. Certaines personnes appellent canonical path(ou canonical file nameou resolved path) un absolute pathdans lequel tous les liens symboliques ont été résolus, c'est-à-dire qu'ils ont été remplacés par un chemin vers tout ce vers quoi ils se connectent. Les commandes realpathet les readlinkdeux recherchent un chemin canonique, mais n'ont realpathqu'une option pour obtenir un chemin absolu sans se soucier de résoudre les liens symboliques (ainsi que plusieurs autres options pour obtenir différents types de chemins, absolus ou relatifs à certains répertoires).

Cela appelle plusieurs remarques:

1. les liens symboliques ne peuvent être résolus que si tout ce qu'ils sont censés lier est déjà créé, ce qui n'est évidemment pas toujours le cas. Les commandes realpathet readlinkont des options pour en tenir compte.
2. un répertoire sur un chemin peut plus tard devenir un lien symbolique, ce qui signifie que le chemin n'est plus canonical. Par conséquent, le concept dépend du temps (ou de l'environnement).
3. même dans le cas idéal, lorsque tous les liens symboliques peuvent être résolus, il peut y en avoir plus d'un canonical pathvers un fichier, pour deux raisons:
   • la partition contenant le fichier peut avoir été montée simultanément ( ro) sur plusieurs points de montage.
   • il peut y avoir des liens durs vers le fichier, ce qui signifie essentiellement que le fichier existe dans plusieurs répertoires différents.

Par conséquent, même avec la définition beaucoup plus restrictive de canonical path, il peut y avoir plusieurs chemins canoniques vers un fichier. Cela signifie également que le qualificatif canonicalest quelque peu inadéquat car il implique généralement une notion d'unicité.

Cela développe une brève discussion du sujet dans une réponse à une autre question similaire à Bash: récupérer le chemin absolu étant donné relatif

Ma conclusion est que realpathc'est mieux conçu et beaucoup plus flexible que readlink. La seule utilisation de readlinkcela n'est pas couverte par realpathl'appel sans option renvoyant la valeur d'un lien symbolique.

La dogbane réponse avec la description de ce qui se passe:

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

Explication:

1. Ce script obtient le chemin relatif comme argument "$1"
2. Ensuite, nous obtenons une partie dirname de ce chemin (vous pouvez passer dir ou file à ce script):dirname "$1"
3. Ensuite, nous entrons cd "$(dirname "$1")dans ce répertoire relatif et obtenons le chemin absolu pour celui-ci en exécutant la pwdcommande shell
4. Après cela, nous ajoutons le nom de base au chemin absolu:$(basename "$1")
5. Comme étape finale , nous echone

Pour les répertoires dirnameest déclenché ../et retourne ./.

La fonction de nolan6000 peut être modifiée pour corriger cela:

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

Ce n'est pas une réponse à la question, mais pour ceux qui font du script:

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

il gère / .. ./ etc correctement. Je semble aussi travailler sur OSX

J'ai placé le script suivant sur mon système et je l'appelle comme un alias bash lorsque je veux saisir rapidement le chemin d'accès complet à un fichier dans le répertoire actuel:

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

Je ne sais pas pourquoi, mais sous OS X quand il est appelé par un script "$ PWD" se développe sur le chemin absolu. Lorsque la commande find est appelée sur la ligne de commande, elle ne le fait pas. Mais il fait ce que je veux ... profiter.

Le plus simple si vous souhaitez utiliser uniquement des builtins est probablement:

find `pwd` -name fileName

Seulement deux mots supplémentaires à taper, et cela fonctionnera sur tous les systèmes Unix, ainsi que OSX.

#! /bin/bash

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

Cela compense les lacunes de realpath, stockez-le dans un script shell fullpath. Vous pouvez maintenant appeler:

$ 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.

Une alternative pour obtenir le chemin absolu en Ruby :

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

Fonctionne sans arguments (dossier actuel) et chemin de fichier ou de dossier relatif et absolu comme agument.

Répondre avec Homebrew

realpathest la meilleure réponse, mais si vous ne l'avez pas installé, vous devez d'abord exécuter brew install coreutilsce qui installera coreutils avec beaucoup de fonctions impressionnantes. Écrire une fonction personnalisée et l'exporter est trop de travail et risque d'erreur pour quelque chose comme ça, voici deux lignes:

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

Hé les gars, je sais que c'est un vieux fil de discussion, mais je poste juste ceci pour référence à toute autre personne qui a visité ce site comme moi. Si j'ai bien compris la question, je pense que la locate $filenamecommande. Il affiche le chemin absolu du fichier fourni, mais uniquement s'il existe.