Pregunta: ¿hay un comando simple sh / bash / zsh / fish / ... para imprimir la ruta absoluta de cualquier archivo que lo alimente?

Caso de uso: Estoy en el directorio /a/by me gustaría para imprimir la ruta completa al archivo cen la línea de comandos para que pueda pegar fácilmente en otro programa: /a/b/c. Simple, pero un pequeño programa para hacer esto probablemente podría ahorrarme aproximadamente 5 segundos cuando se trata de manejar caminos largos, lo que al final se suma. Entonces me sorprende que no puedo encontrar una utilidad estándar para hacer esto, ¿realmente no hay ninguna?

Aquí hay una implementación de muestra, 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)

Tratar realpath.

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

Pruebe readlinkcuál resolverá los enlaces simbólicos:

readlink -e /foo/bar/baz

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

Olvídate readlinky realpathqué puede o no estar instalado en tu sistema.

Ampliando la respuesta anterior de dogbane aquí se expresa como una función:

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

entonces puedes usarlo así:

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

¿Cómo y por qué funciona?

La solución explota el hecho de que el pwdcomando incorporado Bash imprimirá la ruta absoluta del directorio actual cuando se invoque sin argumentos.

¿Por qué me gusta esta solución?

Es portátil y no requiere ninguno readlinko realpathque a menudo no existe en una instalación predeterminada de una distribución de Linux / Unix dada.

¿Qué pasa si el directorio no existe?

Como se indicó anteriormente, la función fallará e imprimirá en stderr si la ruta de directorio dada no existe. Esto puede no ser lo que quieres. Puede expandir la función para manejar esa situación:

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

Ahora devolverá una cadena vacía si uno de los directorios principales no existe.

¿Cómo manejas el final '..' o '.' en entrada?

Bueno, da un camino absoluto en ese caso, pero no uno mínimo. Se verá así:

/Users/bob/Documents/..

Si desea resolver el '...', deberá crear el script como:

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

Esto es mejor que readlink -e FILEo realpath, porque funciona incluso si el archivo no existe.

Esta ruta relativa a la función de shell del convertidor de ruta absoluta

• no requiere utilidades (solo cdy pwd)
• funciona para directorios y archivos
• asas ..y.
• maneja espacios en dir o nombres de archivos
• requiere que exista ese archivo o directorio
• no devuelve nada si no existe nada en la ruta dada
• maneja rutas absolutas como entrada (las pasa esencialmente)

Código:

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
}

Muestra:

# 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: Esto se basa en las respuestas de nolan6000 y bsingh , pero corrige el caso del archivo.

También entiendo que la pregunta original era sobre una utilidad de línea de comando existente. Pero dado que esta parece ser LA pregunta sobre stackoverflow para eso, incluidos los scripts de shell que desean tener dependencias mínimas, puse esta solución de script aquí, para que pueda encontrarla más tarde :)

El findcomando puede ayudar

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

Enumera todos los archivos en o debajo del directorio actual con nombres que coinciden con el patrón. Puede simplificarlo si solo obtiene unos pocos resultados (por ejemplo, un directorio cerca de la parte inferior del árbol que contiene algunos archivos), solo

find $PWD

Lo uso en Solaris 10, que no tiene las otras utilidades mencionadas.

Si no tiene las utilidades readlink o realpath, puede usar la siguiente función que funciona en bash y zsh (no estoy seguro del resto).

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

Esto también funciona para archivos inexistentes (al igual que la función python os.path.abspath).

Lamentablemente abspath ./../somefileno se deshace de los puntos.

Aquí hay una función de solo zsh que me gusta por su compacidad. Utiliza el modificador de expansión 'A'; consulte zshexpn (1).

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

Generalmente, no hay tal cosa como la absolute path de un archivo (este medio declaración de que no puede haber más de uno, en general, de ahí el uso del artículo definido el no es el caso). Una absolute pathes cualquier ruta que comienza desde la raíz "/" y designa un archivo sin ambigüedad independientemente del directorio de trabajo (ver, por ejemplo, wikipedia ).

A relative pathes una ruta que se debe interpretar a partir de otro directorio. Puede ser el directorio de trabajo si está relative pathsiendo manipulado por una aplicación (aunque no necesariamente). Cuando está en un enlace simbólico en un directorio, generalmente está destinado a ser relativo a ese directorio (aunque el usuario puede tener otros usos en mente).

Por lo tanto, una ruta absoluta es solo una ruta relativa al directorio raíz.

Una ruta (absoluta o relativa) puede o no contener enlaces simbólicos. Si no lo hace, también es algo impermeable a los cambios en la estructura de enlace, pero esto no es necesariamente necesario ni deseable. Algunas personas llaman canonical path(o canonical file nameo resolved path) una absolute pathen la que se han resuelto todos los enlaces simbólicos, es decir, han sido sustituidos por un camino a la Whetever que enlazan a. Los comandos realpathy readlinkambos buscan una ruta canónica, pero solo realpathtiene una opción para obtener una ruta absoluta sin molestarse en resolver enlaces simbólicos (junto con varias otras opciones para obtener varios tipos de rutas, absolutas o relativas a algún directorio).

Esto requiere varios comentarios:

1. los enlaces simbólicos solo pueden resolverse si lo que se supone que deben vincular ya está creado, lo que obviamente no siempre es así. Los comandos realpathy readlinktienen opciones para dar cuenta de eso.
2. un directorio en una ruta puede luego convertirse en un enlace simbólico, lo que significa que la ruta ya no lo es canonical. Por lo tanto, el concepto depende del tiempo (o del entorno).
3. incluso en el caso ideal, cuando se pueden resolver todos los enlaces simbólicos, puede haber más de uno canonical pathen un archivo, por dos razones:
   • la partición que contiene el archivo puede haberse montado simultáneamente ( ro) en varios puntos de montaje.
   • puede haber enlaces duros al archivo, lo que significa que esencialmente el archivo existe en varios directorios diferentes.

Por lo tanto, incluso con la definición mucho más restrictiva de canonical path, puede haber varias rutas canónicas a un archivo. Esto también significa que el calificador canonicales algo inadecuado, ya que generalmente implica una noción de unicidad.

Esto amplía una breve discusión del tema en una respuesta a otra pregunta similar en Bash: recuperar la ruta absoluta dada relativa

Mi conclusión es que realpathestá mejor diseñado y es mucho más flexible que readlink. El único uso readlinkque no está cubierto realpathes la llamada sin opción que devuelve el valor de un enlace simbólico.

La dogbane respuesta con la descripción de lo que viene:

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

Explicación:

1. Este script obtiene una ruta relativa como argumento "$1"
2. Entonces obtenemos dirname parte de ese camino (se puede pasar a cualquiera dir o archivo a esta secuencia de comandos):dirname "$1"
3. Entonces nosotros cd "$(dirname "$1") en este directorio relativo y obtenemos una ruta absoluta para él ejecutando el pwdcomando de shell
4. Después de eso agregamos basename a la ruta absoluta:$(basename "$1")
5. Como paso final que echose

Para los directorios dirnamese dispara ../y regresa ./.

La función de nolan6000 se puede modificar para arreglar eso:

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

Esta no es una respuesta a la pregunta, sino para aquellos que hacen scripts:

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

maneja / .. ./ etc correctamente. También parece que trabajo en OSX

He colocado el siguiente script en mi sistema y lo llamo como un alias bash para cuando quiero tomar rápidamente la ruta completa a un archivo en el directorio actual:

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

No estoy seguro de por qué, pero en OS X cuando se llama por un script "$ PWD" se expande a la ruta absoluta. Cuando se llama al comando find en la línea de comando, no lo hace. Pero hace lo que quiero ... disfrutar.

Probablemente, la más simple si desea utilizar solo builtins es:

find `pwd` -name fileName

Solo dos palabras adicionales para escribir, y esto funcionará en todos los sistemas Unix, así como en OSX.

#! /bin/bash

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

Esto compensa las deficiencias de realpathalmacenarlo en un script de shell fullpath. Ahora puedes llamar:

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

Una alternativa para obtener el camino absoluto en Ruby :

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

Funciona sin argumentos (carpeta actual) y el archivo relativo y absoluto o la ruta de la carpeta como elemento.

Responde con Homebrew

realpathes la mejor respuesta, pero si no lo tiene instalado, primero debe ejecutar brew install coreutilslo que instalará coreutils con muchas funciones increíbles. Escribir una función personalizada y exportarla es demasiado trabajo y riesgo de error para algo como esto, aquí hay dos líneas:

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

Hola chicos, sé que es un hilo viejo, pero solo estoy publicando esto para referencia a cualquier otra persona que haya visitado esto como yo. Si entendí la pregunta correctamente, creo que el locate $filenamecomando. Muestra la ruta absoluta del archivo suministrado, pero solo si existe.