Pergunta: existe um comando sh / bash / zsh / fish / ... simples para imprimir o caminho absoluto de qualquer arquivo que eu o alimente?

Caso de uso: Eu estou no diretório /a/be eu gostaria de imprimir o caminho completo para o arquivo cna linha de comando para que eu possa facilmente colá-lo em outro programa: /a/b/c. Simples, mas um pequeno programa para fazer isso provavelmente poderia me economizar 5 segundos ou mais quando se trata de lidar com caminhos longos, o que, no final, se soma. Então, me surpreende não poder encontrar um utilitário padrão para fazer isso - não existe realmente nenhum?

Aqui está uma implementação de exemplo, abspath.py:

#!/usr/bin/python
# Author: Diggory Hardy <[email protected]>
# 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)

Tente realpath.

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

Experimente o readlinkque resolverá os links simbólicos:

readlink -e /foo/bar/baz

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

Esqueça readlinkerealpath quais podem ou não estar instalados no seu sistema.

Expandindo a resposta do dogbane acima aqui, ele é expresso como uma função:

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

você pode usá-lo assim:

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

Como e por que isso funciona?

A solução explora o fato de que o Bash embutido pwd comando imprime o caminho absoluto do diretório atual quando chamado sem argumentos.

Por que gosto desta solução?

É portátil e não requer nenhum readlinkou realpathque geralmente não existe em uma instalação padrão de uma determinada distribuição Linux / Unix.

E se dir não existir?

Conforme indicado acima, a função falhará e será impressa no stderr se o caminho do diretório fornecido não existir. Pode não ser o que você deseja. Você pode expandir a função para lidar com essa situação:

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

Agora ele retornará uma string vazia se uma das diretivas pai não existir.

Como você lida com os caracteres '..' ou '.' na entrada?

Bem, dá um caminho absoluto nesse caso, mas não um caminho mínimo. Será parecido com:

/Users/bob/Documents/..

Se você quiser resolver o '..', precisará fazer o 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

Isso é melhor que readlink -e FILEou realpathporque funciona mesmo que o arquivo não exista.

Esse caminho relativo para a função de shell do conversor de caminho absoluto

• não requer utilitários (apenas cde pwd)
• funciona para diretórios e arquivos
• alças ..e.
• lida com espaços em dir ou nomes de arquivos
• requer que arquivo ou diretório exista
• não retorna nada se nada existir no caminho especificado
• lida com caminhos absolutos como entrada (passa-os essencialmente)

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
}

Amostra:

# 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: Isso é baseado nas respostas de nolan6000 e bsingh , mas corrige a caixa do arquivo.

Também entendo que a pergunta original era sobre um utilitário de linha de comando existente. Mas, como essa parece ser a pergunta no stackoverflow, incluindo scripts shell que desejam ter dependências mínimas, coloquei essa solução de script aqui, para encontrá-la mais tarde :)

O findcomando pode ajudar

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

Lista todos os arquivos no diretório atual ou abaixo dele com nomes correspondentes ao padrão. Você pode simplificá-lo se obter apenas alguns resultados (por exemplo, diretório próximo ao final da árvore contendo poucos arquivos), apenas

find $PWD

Eu uso isso no Solaris 10, que não possui os outros utilitários mencionados.

Se você não possui utilitários readlink ou realpath, pode usar a seguinte função, que funciona no bash e no zsh (não tem certeza sobre o resto).

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

Isso também funciona para arquivos inexistentes (assim como a função python os.path.abspath).

Infelizmente abspath ./../somefilenão se livra dos pontos.

Aqui está uma função apenas do zsh que eu gosto por sua compacidade. Ele usa o modificador de expansão 'A' - consulte zshexpn (1).

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

Geralmente não há tal coisa como o absolute path para um arquivo (o que significa demonstração de que pode haver mais de um em geral, daí o uso do artigo definido o não é o caso). An absolute pathé qualquer caminho que começa na raiz "/" e designa um arquivo sem ambiguidade, independentemente do diretório de trabalho (veja, por exemplo, wikipedia ).

A relative pathé um caminho que deve ser interpretado a partir de outro diretório. Pode ser o diretório de trabalho se for umrelative path sendo manipulado por um aplicativo (embora não necessariamente). Quando está em um link simbólico em um diretório, geralmente se destina a ser relativo a esse diretório (embora o usuário possa ter outros usos em mente).

Portanto, um caminho absoluto é apenas um caminho relativo ao diretório raiz.

Um caminho (absoluto ou relativo) pode ou não conter links simbólicos. Caso contrário, também é um pouco impermeável a alterações na estrutura de ligação, mas isso não é necessariamente necessário ou mesmo desejável. Algumas pessoas chamam canonical path(ou canonical file nameou resolved path) um absolute pathem que todos os links simbólicos foram resolvidos, ou seja, foram substituídos por um caminho para onde quer que eles estejam. Os comandos realpathe os readlinkdois procuram um caminho canônico, mas só realpathtêm uma opção para obter um caminho absoluto sem se preocupar em resolver links simbólicos (junto com várias outras opções para obter vários tipos de caminhos, absolutos ou relativos a algum diretório).

Isso exige várias observações:

1. links simbólicos só podem ser resolvidos se o que eles deveriam vincular já estiver criado, o que obviamente nem sempre é o caso. Os comandos realpathe readlinktem opções para explicar isso.
2. posteriormente, um diretório em um caminho pode se tornar um link simbólico, o que significa que o caminho não é mais canonical. Portanto, o conceito depende do tempo (ou do ambiente).
3. mesmo no caso ideal, quando todos os links simbólicos podem ser resolvidos, ainda pode haver mais de um canonical pathpara um arquivo, por dois motivos:
   • a partição que contém o arquivo pode ter sido montada simultaneamente (ro ) em vários pontos de montagem.
   • pode haver links físicos para o arquivo, significando essencialmente que o arquivo existe em vários diretórios diferentes.

Portanto, mesmo com a definição muito mais restritiva de canonical path , pode haver vários caminhos canônicos para um arquivo. Isso também significa que o qualificador canonicalé um tanto inadequado, pois geralmente implica uma noção de singularidade.

Isso expande uma breve discussão sobre o tópico em uma resposta a outra pergunta semelhante em Bash: recuperar o caminho absoluto dado

Minha conclusão é que realpathé melhor projetado e muito mais flexível do que readlink. O único uso readlinkdisso não coberto realpathé a chamada sem opção retornando o valor de um link simbólico.

A dogbane resposta com a descrição do que está por vir:

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

Explicação:

1. Este script obtém o caminho relativo como argumento "$1"
2. Então temos o dirname parte desse caminho (você pode passar dir ou arquivo para este script):dirname "$1"
3. Então, cd "$(dirname "$1")entramos nesse diretório relativo e obtemos o caminho absoluto para ele executandopwd comando shell
4. Depois disso, acrescentamos o nome da base ao caminho absoluto:$(basename "$1")
5. Como etapa final, echoele

Para diretórios dirnameé acionado ../e retorna./ .

A função do nolan6000 pode ser modificada para corrigir isso:

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

Esta não é uma resposta para a pergunta, mas para quem faz scripts:

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

ele lida com / .. ./ etc corretamente. Eu também parece trabalhar no OSX

Coloquei o seguinte script no meu sistema e chamo-o como um alias do bash para quando eu quiser pegar rapidamente o caminho completo para um arquivo no diretório atual:

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

Não sei por que, mas no OS X quando chamado por um script "$ PWD" se expande para o caminho absoluto. Quando o comando find é chamado na linha de comando, não é. Mas faz o que eu quero ... curtir.

O mais simples se você deseja usar apenas os recursos internos é provavelmente:

find `pwd` -name fileName

Apenas duas palavras extras para digitar, e isso funcionará em todos os sistemas unix, bem como no OSX.

#! /bin/bash

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

Isso compensa as deficiências de realpath, armazene-o em um script de shell fullpath. Agora você pode ligar para:

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

Uma alternativa para obter o caminho absoluto no Ruby :

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

Funciona sem argumentos (pasta atual) e caminho relativo e absoluto de arquivo ou pasta como um instrumento.

Responder com Homebrew

realpathé a melhor resposta, mas se você não o tiver instalado, execute primeiro o brew install coreutilsque instalará o coreutils com muitas funções impressionantes. Escrever uma função personalizada e exportar é muito trabalho e risco de erro para algo como isto, aqui estão duas linhas:

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

Ei pessoal, eu sei que é um tópico antigo, mas estou postando isso para referência a qualquer pessoa que tenha visitado isso como eu. Se entendi a pergunta corretamente, acho que o locate $filenamecomando. Ele exibe o caminho absoluto do arquivo fornecido, mas apenas se ele existir.