¿Cómo se normaliza una ruta de archivo en Bash?

Quiero transformarme /foo/bar/..a/foo

¿Hay un comando bash que hace esto?

Editar: en mi caso práctico, el directorio existe.

si desea cortar parte de un nombre de archivo de la ruta, "dirname" y "basename" son sus amigos, y "realpath" también es útil.

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 alternativas

Si realpathsu shell no lo admite, puede intentar

readlink -f /path/here/.. 

también

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

Funciona igual que

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

en que el camino no necesita existir para ser normalizado.

No sé si hay un comando bash directo para hacer esto, pero generalmente lo hago

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

y funciona bien

Tratar realpath. A continuación se muestra la fuente en su totalidad, por la presente donada al dominio público.

// 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 solución portátil y confiable es usar python, que está preinstalado prácticamente en todas partes (incluido Darwin). Tienes dos opciones:

1. abspath devuelve una ruta absoluta pero no resuelve enlaces simbólicos:

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

2. realpath devuelve una ruta absoluta y al hacerlo resuelve enlaces simbólicos, generando una ruta canónica:

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

En cada caso, path/to/filepuede ser una ruta relativa o absoluta.

Use la utilidad readlink del paquete coreutils.

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

readlinkes el estándar bash para obtener la ruta absoluta. También tiene la ventaja de devolver cadenas vacías si las rutas o una ruta no existe (dadas las banderas para hacerlo).

Para obtener la ruta absoluta a un directorio que puede existir o no, pero los padres de quién existen, use:

abspath=$(readlink -f $path)

Para obtener la ruta absoluta a un directorio que debe existir junto con todos los padres:

abspath=$(readlink -e $path)

Para canonizar la ruta dada y seguir enlaces simbólicos si existen, pero ignorar los directorios que faltan y simplemente devolver la ruta de todos modos, es:

abspath=$(readlink -m $path)

El único inconveniente es que readlink seguirá a los enlaces. Si no desea seguir los enlaces, puede usar esta convención alternativa:

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

Eso conducirá a la parte del directorio de $ path e imprimirá el directorio actual junto con la parte del archivo de $ path. Si no puede chdir, obtienes una cadena vacía y un error en stderr.

Antigua pregunta, pero hay una forma mucho más simple si se trata de nombres de ruta completos a nivel de shell:

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

Como el cd ocurre en una subshell, no afecta el script principal.

Dos variaciones, suponiendo que sus comandos integrados de shell acepten -L y -P, son:

   abspath = "$ (cd -P" $ ruta "&& pwd -P)" # ruta física con enlaces simbólicos resueltos
   abspath = "$ (cd -L" $ ruta "&& pwd -L)" # ruta lógica conservando enlaces simbólicos

Personalmente, rara vez necesito este enfoque posterior a menos que me fascinen los enlaces simbólicos por alguna razón.

FYI: variación en la obtención del directorio de inicio de un script que funciona incluso si el script cambia su directorio actual más adelante.

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

El uso de CD asegura que siempre tenga el directorio absoluto, incluso si el script se ejecuta mediante comandos como ./script.sh que, sin el cd / pwd, a menudo da solo ... Inútil si el script hace un cd más adelante.

Como señaló Adam Liss, realpathno se incluye en todas las distribuciones. Lo cual es una pena, porque es la mejor solución. El código fuente proporcionado es excelente, y probablemente comenzaré a usarlo ahora. Esto es lo que he estado usando hasta ahora, que comparto aquí solo para completar:

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

Si usted quiere que los enlaces simbólicos a resolver, simplemente reemplazar pwdcon pwd -P.

Mi solución reciente fue:

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

Basado en la respuesta de Tim Whitcomb.

No es exactamente una respuesta, sino quizás una pregunta de seguimiento (la pregunta original no era explícita):

readlinkestá bien si realmente quieres seguir enlaces simbólicos. Pero también hay un caso de uso por el solo hecho de la normalización ./y ../y //secuencias, que se pueden hacer puramente sintáctico, sin canonizan enlaces simbólicos. readlinkno es bueno para esto, y tampoco lo es realpath.

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

funciona para caminos existentes, pero se rompe para otros.

Una sedsecuencia de comandos parecería ser una buena apuesta, excepto que no puede reemplazar iterativamente secuencias ( /foo/bar/baz/../..-> /foo/bar/..-> /foo) sin usar algo como Perl, que no es seguro asumir en todos los sistemas, o usar algún bucle feo para comparar la salida de seda su entrada

FWIW, una línea usando 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

Llego tarde a la fiesta, pero esta es la solución que he creado después de leer un montón de hilos como este:

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

Esto resolverá la ruta absoluta de $ 1, jugará bien con ~, mantendrá los enlaces simbólicos en la ruta donde están, y no interferirá con su pila de directorios. Devuelve la ruta completa o nada si no existe. Espera que $ 1 sea un directorio y probablemente fallará si no lo es, pero esa es una verificación fácil de hacer usted mismo.

Hablador, y un poco tarde la respuesta. Necesito escribir uno ya que estoy atascado en RHEL4 / 5 anterior. Manejo los enlaces absolutos y relativos, y simplifica las entradas //, /./ y 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`

Pruebe nuestro nuevo producto de biblioteca Bash realpath-lib que hemos colocado en GitHub para uso gratuito y sin gravámenes. Está completamente documentado y es una gran herramienta de aprendizaje.

Resuelve rutas locales, relativas y absolutas y no tiene ninguna dependencia, excepto Bash 4+; por lo que debería funcionar en casi cualquier lugar. Es gratis, limpio, simple e instructivo.

Tu puedes hacer:

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

Esta función es el núcleo de la biblioteca:

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

}

También contiene funciones para get_dirname, get_filename, get_ stemname y validate_path. Pruébelo en todas las plataformas y ayude a mejorarlo.

El problema realpathes que no está disponible en BSD (u OSX para el caso). Aquí hay una receta simple extraída de un artículo bastante antiguo (2009) de Linux Journal , que es bastante portátil:

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

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

Observe esta variante tampoco no requiere la trayectoria de existir.

Según la respuesta de @ Andre, podría tener una versión un poco mejor, en caso de que alguien busque una solución basada en la manipulación de cadenas completamente libre de bucles. También es útil para aquellos que no desean desreferenciar ningún enlace simbólico, que es la desventaja de usar realpatho readlink -f.

Funciona en versiones bash 3.2.25 y superiores.

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

Basado en el excelente fragmento de python de loveborg, escribí esto:

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

Esto funciona incluso si el archivo no existe. Requiere que exista el directorio que contiene el archivo.

Necesitaba una solución que hiciera las tres cosas:

• Trabaja en una Mac de serie. realpathy readlink -fson complementos
• Resolver enlaces simbólicos
• Tiene manejo de errores

Ninguna de las respuestas tenía tanto # 1 como # 2. Agregué el n. ° 3 para salvar a los demás.

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

Aquí hay un breve caso de prueba con algunos espacios retorcidos en las rutas para ejercer completamente la cita

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 "

Sé que esta es una pregunta antigua. Todavía estoy ofreciendo una alternativa. Recientemente me encontré con el mismo problema y no encontré ningún comando portátil y existente para hacerlo. Así que escribí el siguiente script de shell que incluye una función que puede hacer el truco.

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

Hice una función integrada solo para manejar esto con un enfoque en el rendimiento más alto posible (por diversión). No resuelve enlaces simbólicos, por lo que es básicamente lo mismo que 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: Esta función no maneja rutas que comiencen //, ya que exactamente dos barras diagonales dobles al comienzo de una ruta son comportamientos definidos por la implementación. Sin embargo, se maneja /, ///y así sucesivamente.

Esta función parece manejar todos los casos límite correctamente, pero aún puede haber algunos por ahí que no he tratado.

Nota de rendimiento: cuando se llama con miles de argumentos, se abspathejecuta aproximadamente 10 veces más lento que realpath -sm; cuando se llama con un solo argumento, se abspathejecuta> 110 veces más rápido que realpath -smen mi máquina, principalmente debido a que no es necesario ejecutar un nuevo programa cada vez.

Hoy descubrí que puedes usar el statcomando para resolver rutas.

Entonces, para un directorio como "~ / Documentos":

Puedes ejecutar esto:

stat -f %N ~/Documents

Para obtener el camino completo:

/Users/me/Documents

Para enlaces simbólicos, puede usar la opción de formato% Y:

stat -f %Y example_symlink

Lo que podría devolver un resultado como:

/usr/local/sbin/example_symlink

Las opciones de formato pueden ser diferentes en otras versiones de * NIX, pero me han funcionado en OSX.

Una solución simple usando node.js:

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