¿Cómo obtener la ruta completa de un archivo?

¿Hay alguna manera fácil de imprimir la ruta completa file.txt?

file.txt = /nfs/an/disks/jj/home/dir/file.txt

los <command>

dir> <command> file.txt  

debería imprimir

/nfs/an/disks/jj/home/dir/file.txt

Use readlink :

readlink -f file.txt

Supongo que estás usando Linux.

Encontré una utilidad llamada realpathen coreutils 8.15.

realpath file.txt
/data/ail_data/transformed_binaries/coreutils/test_folder_realpath/file.txt

Según los comentarios de @ styrofoam-fly y @ arch-standton, realpathsolo no verifica la existencia del archivo, para resolver esto agregue el eargumento:realpath -e file

Lo siguiente generalmente hace el truco:

 echo $(cd $(dirname "$1") && pwd -P)/$(basename "$1")

Yo sé que hay una manera más fácil que esto, pero aspen si puedo encontrarlo ...

jcomeau@intrepid:~$ python -c 'import os; print(os.path.abspath("cat.wav"))'
/home/jcomeau/cat.wav

jcomeau@intrepid:~$ ls $PWD/cat.wav
/home/jcomeau/cat.wav

find $PWD -type f | grep "filename"

o

find $PWD -type f -name "*filename*"

Si está en el mismo directorio que el archivo:

ls "`pwd`/file.txt"

Reemplace file.txtcon su nombre de archivo de destino.

En Windows:

• Mantener Shiftpresionado y hacer clic derecho en un archivo en el Explorador de Windows le brinda una opción llamada Copy as Path. Esto copiará la ruta completa del archivo al portapapeles.

En Linux:

• Puede usar el comando realpath yourfilepara obtener la ruta completa de un archivo según lo sugerido por otros.

Sé que esta es una vieja pregunta ahora, pero solo para agregar a la información aquí:

El comando de Linux whichse puede usar para encontrar la ruta del archivo de un archivo de comando, es decir

$ which ls
/bin/ls

Hay algunas advertencias a esto; consulte https://www.cyberciti.biz/faq/how-do-i-find-the-path-to-a-command-file/ .

Funciona en Mac, Linux, * nix:

Esto le dará un csv citado de todos los archivos en el directorio actual:

ls | xargs -I {} echo "$(pwd -P)/{}" | xargs | sed 's/ /","/g'

El resultado de esto se puede copiar fácilmente en una lista de Python o en cualquier estructura de datos similar.

Puede usar el script fpn (nombre de ruta completo) :

% pwd
/Users/adamatan/bins/scripts/fpn

% ls
LICENSE   README.md fpn.py

% fpn *
/Users/adamatan/bins/scripts/fpn/LICENSE
/Users/adamatan/bins/scripts/fpn/README.md
/Users/adamatan/bins/scripts/fpn/fpn.py

fpnno es un paquete estándar de Linux, pero es un proyecto github gratuito y abierto y puede configurarlo en un minuto .

Puedes usar esta función. Si el nombre del archivo se proporciona sin una ruta relativa, se supone que está presente en el directorio de trabajo actual:

abspath() { old=`pwd`;new=$(dirname "$1");if [ "$new" != "." ]; then cd $new; fi;file=`pwd`/$(basename "$1");cd $old;echo $file; }

Uso:

$ abspath file.txt
/I/am/in/present/dir/file.txt

Uso con ruta relativa:

$ abspath ../../some/dir/some-file.txt
/I/am/in/some/dir/some-file.txt

Con espacios en el nombre del archivo:

$ abspath "../../some/dir/another file.txt"
/I/am/in/some/dir/another file.txt

En un escenario similar, estoy lanzando un script cshell desde otra ubicación. Para configurar la ruta absoluta correcta del script para que se ejecute solo en el directorio designado, estoy usando el siguiente código:

set script_dir = `pwd`/`dirname $0`

$0 almacena la cadena exacta de cómo se ejecutó el script.

Por ejemplo, si el guión se puso en marcha la siguiente manera: $> ../../test/test.csh, $script_dircontendrá/home/abc/sandbox/v1/../../test

Para Mac OS X, reemplacé las utilidades que vienen con el sistema operativo y las reemplacé con una versión más nueva de coreutils. Esto le permite acceder a herramientas como readlink -f(para la ruta absoluta a los archivos) y realpath(ruta absoluta a los directorios) en su Mac.

La versión Homebrew agrega una 'G' (para GNU Tools) delante del nombre del comando, por lo que los equivalentes se convierten en greadlink -f FILEy grealpath DIRECTORY.

Puede encontrar instrucciones sobre cómo instalar Coreutils / GNU Tools en Mac OS X a través de Homebrew en este artículo de StackExchange .

NB: Los comandos readlink -fy realpathdeberían funcionar de manera predeterminada para los usuarios que no son Mac Unix.

echo $(cd $(dirname "$1") && pwd -P)/$(basename "$1")

Esta es la explicación de lo que está sucediendo en la respuesta de @ ZeRemz :

1. Este script obtiene una ruta relativa como argumento "$1"
2. Entonces conseguimos nombredir parte de ese camino (se puede pasar a cualquiera dir o archivo a esta secuencia de comandos):dirname "$1"
3. Entonces entramos cd "$(dirname "$1")en este directorio relativo
4. && pwd -Py obtener el camino absoluto para ello. -Pla opción evitará todos los enlaces simbólicos
5. Después de eso agregamos basename a la ruta absoluta:$(basename "$1")
6. Como paso final que echose

Esto funcionó bastante bien para mí. No depende del sistema de archivos (un pro / con según la necesidad), por lo que será rápido; y debería ser portátil para la mayoría de cualquier * NIX. Asume que la cadena pasada es de hecho relativa a la PWD y no a algún otro directorio.

function abspath () {
   echo $1 | awk '\
      # Root parent directory refs to the PWD for replacement below
      /^\.\.\// { sub("^", "./") } \
      # Replace the symbolic PWD refs with the absolute PWD \
      /^\.\//   { sub("^\.", ENVIRON["PWD"])} \
      # Print absolute paths \
      /^\//   {print} \'
}

Esto es ingenuo, pero tuve que hacer que sea compatible con POSIX. Requiere permiso para cd en el directorio del archivo.

#!/bin/sh
if [ ${#} = 0 ]; then
  echo "Error: 0 args. need 1" >&2
  exit 1
fi


if [ -d ${1} ]; then


  # Directory


  base=$( cd ${1}; echo ${PWD##*/} )
  dir=$( cd ${1}; echo ${PWD%${base}} )

  if [ ${dir} = / ]; then
    parentPath=${dir}
  else
    parentPath=${dir%/}
  fi

  if [ -z ${base} ] || [ -z ${parentPath} ]; then
    if [ -n ${1} ]; then
      fullPath=$( cd ${1}; echo ${PWD} )
    else
      echo "Error: unsupported scenario 1" >&2
      exit 1
    fi
  fi

elif [ ${1%/*} = ${1} ]; then

  if [ -f ./${1} ]; then


    # File in current directory

    base=$( echo ${1##*/} )
    parentPath=$( echo ${PWD} )

  else
    echo "Error: unsupported scenario 2" >&2
    exit 1
  fi
elif [ -f ${1} ] && [ -d ${1%/*} ]; then


  # File in directory

  base=$( echo ${1##*/} )
  parentPath=$( cd ${1%/*}; echo ${PWD} )

else
  echo "Error: not file or directory" >&2
  exit 1
fi

if [ ${parentPath} = / ]; then
  fullPath=${fullPath:-${parentPath}${base}}
fi

fullPath=${fullPath:-${parentPath}/${base}}

if [ ! -e ${fullPath} ]; then
  echo "Error: does not exist" >&2
  exit 1
fi

echo ${fullPath}

Generalmente:

find `pwd` | grep <filename>

Alternativamente, solo para la carpeta actual:

find `pwd` -maxdepth 1 | grep <filename>

Me gustan muchas de las respuestas ya dadas, pero he encontrado esto realmente útil, especialmente dentro de un script para obtener la ruta completa de un archivo, incluidos los siguientes enlaces simbólicos y referencias relativas como .y..

dirname `readlink -e relative/path/to/file`

Lo que devolverá la ruta completa de la fileruta raíz en adelante. Esto se puede usar en un script para que el script sepa desde qué ruta se está ejecutando, lo cual es útil en un clon de repositorio que podría ubicarse en cualquier lugar de una máquina.

basePath=`dirname \`readlink -e $0\``

Entonces puedo usar la ${basePath}variable en mis scripts para hacer referencia directa a otros scripts.

Espero que esto ayude,

Dave

Puede guardar esto en su shell.rco simplemente ponerlo en la consola

function absolute_path { echo "$PWD/$1"; }
alias ap="absolute_path"

ejemplo:

ap somefile.txt

saldrá

/home/user/somefile.txt

find / -samefile file.txt -print

Encontrará todos los enlaces al archivo con el mismo número de inodo que file.txt

agregar una -xdevbandera evitará findcruzar los límites del dispositivo ("puntos de montaje"). (Pero esto probablemente no hará que se encuentre nada si findno comienza en un directorio en el mismo dispositivo que file.txt)

Tenga en cuenta que findpuede informar múltiples rutas para un solo objeto de sistema de archivos, porque un Inode puede estar vinculado por más de una entrada de directorio, posiblemente incluso usando diferentes nombres. Por ejemplo:

find /bin -samefile /bin/gunzip -ls

Saldrá:

12845178    4 -rwxr-xr-x   2 root     root         2251 feb  9  2012 /bin/uncompress
12845178    4 -rwxr-xr-x   2 root     root         2251 feb  9  2012 /bin/gunzip

Esto funcionará tanto para el archivo como para la carpeta:

getAbsolutePath(){
    [[ -d $1 ]] && { cd "$1"; echo "$(pwd -P)"; } || 
    { cd "$(dirname "$1")" || exit 1; echo "$(pwd -P)/$(basename "$1")"; }
}

Esto funciona con Linux y Mac OSX.

 echo $(pwd)$/$(ls file.txt)

Otra utilidad de Linux, que hace este trabajo:

fname <file>

Para Mac OS, si solo desea obtener la ruta de un archivo en el buscador, haga clic en el archivo y desplácese hacia abajo hasta "Servicios" en la parte inferior. Obtiene muchas opciones, incluyendo "copiar ruta" y "copiar ruta completa". Al hacer clic en uno de estos, se coloca la ruta en el portapapeles.

En mac mencionado a continuación, la línea funciona. No es necesario agregar líneas elegantes.

> pwd filename

fp () {
PHYS_DIR=`pwd -P`
RESULT=$PHYS_DIR/$1
echo $RESULT | pbcopy
echo $RESULT
}

Copia el texto en su portapapeles y muestra el texto en la ventana del terminal.

:)

(Copié parte del código de otra respuesta de desbordamiento de pila pero ya no puedo encontrar esa respuesta)

la forma más fácil que encontré es

for i in `ls`; do echo "`pwd`/$i"; done

me funciona bien

En Mac OSX, realice los siguientes pasos:

1. cd en el directorio del archivo de destino.
2. Escriba cualquiera de los siguientes comandos de terminal.

ls "`pwd`/file.txt"
echo $(pwd)/file.txt

3. Reemplace file.txtcon su nombre de archivo real.
4. prensa Enter

Junto a "readlink -f", otro comando de uso común:

$find  /the/long/path/but/I/can/use/TAB/to/auto/it/to/ -name myfile
/the/long/path/but/I/can/use/TAB/to/auto/it/to/myfile
$

Esto también proporciona la ruta completa y el nombre del archivo en la consola

Fuera de tema: este método solo proporciona enlaces relativos , no absolutos. El readlink -fcomando es el correcto.

Cree una función como la siguiente (repite la ruta absoluta de un archivo con pwd y agrega el archivo al final de la ruta:

abspath() { echo $(pwd "$1")/"$1"; }

Ahora puede encontrar cualquier ruta de archivo:

abspath myfile.ext