如何检索给定相对路径的绝对路径

Question

是否有命令可以检索给定相对路径的绝对路径？

例如我希望 $line 包含 dir ./etc/ 中每个文件的绝对路径

find ./ -type f | while read line; do
   echo $line
done

Answer 1

尝试真实路径。

~ $ sudo apt-get install realpath  # may already be installed
~ $ realpath .bashrc
/home/username/.bashrc

要避免扩展符号链接，请使用realpath -s。

答案来自“bash/fish 命令打印绝对路径文件路径”。

Answer 2

如果您安装了 coreutils 软件包，通常可以使用 readlink -frelative_file_name 来检索绝对文件名（已解析所有符号链接）

Answer 3

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

UPD 一些解释

1. 该脚本获取相对路径作为参数 "$1"
2. 然后我们获取该路径的 dirname 部分（您可以传递 dir 或 file到此脚本）： dirname "$1"
3. 然后我们 cd "$(dirname "$1") 进入这个相对目录，并通过运行 pwd 获取它的绝对路径 shell 命令
4. 之后，我们将basename附加到绝对路径：$(basename "$1")
5. 作为最后一步，我们echo它

Answer 4

使用：

find "$(pwd)"/ -type f

获取所有文件或

echo "$(pwd)/$line"

显示完整路径（如果相对路径很重要）

Answer 5

不管怎样，我投票给了所选择的答案，但想分享一个解决方案。缺点是，它仅限于 Linux - 在进入 Stack Overflow 之前，我花了大约 5 分钟试图找到 OSX 的等效版本。我确信它就在那里。

在 Linux 上，您可以将 readlink -e 与 dirname 结合使用。

$(dirname $(readlink -e ../../../../etc/passwd))

然后你使用

/etc/

dirname 的姐妹 basename 来获取
文件名

$(basename ../../../../../passwd)

产生

passwd

把它们放在一起..

F=../../../../../etc/passwd
echo "$(dirname $(readlink -e $F))/$(basename $F)"

产生

/etc/passwd

如果你的目标是目录，那么你是安全的，basename不会返回任何内容
你最终会在最终输出中得到双斜杠。

Answer 6

我认为这是最可移植的：

abspath() {                                               
    cd "$(dirname "$1")"
    printf "%s/%s\n" "$(pwd)" "$(basename "$1")"
    cd "$OLDPWD"
}

如果路径不存在，它将失败。

Answer 7

realpath 可能是最好的

但是......

最初的问题一开始就非常混乱，示例很差
与所述问题相关。

所选答案实际上回答了给出的示例，但根本不回答
标题中的问题。第一个命令就是答案（是吗？
真的 ？我怀疑），并且没有“/”也可以做到。我看不到
第二个命令正在做什么。

有几个问题是混合在一起的：

• 将相对路径名更改为绝对路径名，无论它是什么
  表示，可能什么也没有。
  （通常，如果您发出诸如 touch foo/bar 之类的命令，
  路径名 foo/bar 必须存在，并且可能用于
  在实际创建文件之前进行计算。)

• 可能有多个绝对路径名表示同一个文件
  （或潜在文件），特别是因为符号链接（symlinks）
  在路径上，但可能出于其他原因（设备可能是
  以只读方式安装两次）。人们可能想也可能不想解决
  明确这样的符号链接。

• 到达非符号链接的符号链接链的末尾
  文件或名称。这可能会也可能不会产生绝对路径名，
  取决于它是如何完成的。人们可能愿意，也可能不愿意
  将其解析为绝对路径名。

不带选项的命令 readlink foo 仅在以下情况下给出答案
参数 foo 是一个符号链接，答案就是它的值
符号链接。没有其他链接被跟随。答案可能是相对路径：
无论符号链接参数的值是什么。

但是，readlink 具有适用于所有内容的选项（-f -e 或 -m）
文件，并给出一个绝对路径名（没有符号链接的路径名）
参数实际表示的文件。

这对于任何不是符号链接的东西都适用，尽管有人可能会这样做
希望使用绝对路径名而不解析中间路径
路径上的符号链接。这是通过命令 realpath -s foo 完成的。

在符号链接参数的情况下，readlink 及其选项将
再次解析参数绝对路径上的所有符号链接，但是
它还将包括可能遇到的所有符号链接
跟随参数值。如果您想要一个，您可能不希望这样
参数符号链接本身的绝对路径，而不是任何内容的绝对路径
它可能链接到。同样，如果 foo 是符号链接，则 realpath -s foo 将
获取绝对路径而不解析符号链接，包括符号链接
作为参数给出。

如果没有 -s 选项，realpath 的作用与
readlink，除了简单的读取一个链接的值，还有几个
其他事情。我只是不清楚为什么 readlink 有它的
选项，显然造成了不受欢迎的冗余
真实路径。

探索网络就不多说了，除了可能有
不同系统之间存在一些差异。

结论：realpath 是最好用的命令，使用最多
灵活性，至少对于此处要求的使用而言。

Answer 8

我最喜欢的解决方案是@EugenKonkov 的这个，因为它并不意味着存在其他实用程序（coreutils 包）。

但相对路径“。”失败了。和“..”，所以这里是处理这些特殊情况的稍微改进的版本。

但是，如果用户没有 cd 权限进入相对路径的父目录，它仍然会失败。

#! /bin/sh

# Takes a path argument and returns it as an absolute path. 
# No-op if the path is already absolute.
function to-abs-path {
    local target="$1"

    if [ "$target" == "." ]; then
        echo "$(pwd)"
    elif [ "$target" == ".." ]; then
        echo "$(dirname "$(pwd)")"
    else
        echo "$(cd "$(dirname "$1")"; pwd)/$(basename "$1")"
    fi
}

Answer 9

尤金的答案对我来说不太有效，但这确实有效：

    absolute="$(cd $(dirname \"$file\"); pwd)/$(basename \"$file\")"

旁注，您当前的工作目录不受影响。

Answer 10

恕我直言，最好的解决方案是在这里发布的：https://stackoverflow.com/a/3373298/9724628。

它确实需要 python 才能工作，但它似乎涵盖了所有或大部分边缘情况，并且是非常可移植的解决方案。

1. 解析符号链接：

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

2. 或不解析：

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

Answer 11

对 @ernest-a 相当不错的版本的改进：

absolute_path() {
    cd "$(dirname "$1")"
    case $(basename $1) in
        ..) echo "$(dirname $(pwd))";;
        .)  echo "$(pwd)";;
        *)  echo "$(pwd)/$(basename $1)";;
    esac
}

这可以正确处理路径最后一个元素是 .. 的情况，在这种情况下 "$(pwd)/$( @ernest-a 的答案中的 basename "$1")" 将显示为 accurate_sub_path/spurious_subdirectory/..。

Answer 12

对于find，最简单的方法可能是只给出要搜索的绝对路径，例如：

find /etc
find `pwd`/subdir_of_current_dir/ -type f

Answer 13

如果您在 Mac OS X 上使用 bash，既没有 realpath 存在，也没有 readlink 可以打印绝对路径，您可以选择编写自己的版本来打印它。
这是我的实现：

（纯 bash）

abspath(){
  local thePath
  if [[ ! "$1" =~ ^/ ]];then
    thePath="$PWD/$1"
  else
    thePath="$1"
  fi
  echo "$thePath"|(
  IFS=/
  read -a parr
  declare -a outp
  for i in "${parr[@]}";do
    case "$i" in
    ''|.) continue ;;
    ..)
      len=${#outp[@]}
      if ((len==0));then
        continue
      else
        unset outp[$((len-1))] 
      fi
      ;;
    *)
      len=${#outp[@]}
      outp[$len]="$i"
      ;;
    esac
  done
  echo /"${outp[*]}"
)
}

（使用 gawk）

abspath_gawk() {
    if [[ -n "$1" ]];then
        echo $1|gawk '{
            if(substr($0,1,1) != "/"){
                path = ENVIRON["PWD"]"/"$0
            } else path = $0
            split(path, a, "/")
            n = asorti(a, b,"@ind_num_asc")
            for(i in a){
                if(a[i]=="" || a[i]=="."){
                    delete a[i]
                }
            }
            n = asorti(a, b, "@ind_num_asc")
            m = 0
            while(m!=n){
                m = n
                for(i=1;i<=n;i++){
                    if(a[b[i]]==".."){
                        if(b[i-1] in a){
                            delete a[b[i-1]]
                            delete a[b[i]]
                            n = asorti(a, b, "@ind_num_asc")
                            break
                        } else exit 1
                    }
                }
            }
            n = asorti(a, b, "@ind_num_asc")
            if(n==0){
                printf "/"
            } else {
                for(i=1;i<=n;i++){
                    printf "/"a[b[i]]
                }
            }
        }'
    fi
}

（纯 bsd awk）

#!/usr/bin/env awk -f
function abspath(path,    i,j,n,a,b,back,out){
  if(substr(path,1,1) != "/"){
    path = ENVIRON["PWD"]"/"path
  }
  split(path, a, "/")
  n = length(a)
  for(i=1;i<=n;i++){
    if(a[i]==""||a[i]=="."){
      continue
    }
    a[++j]=a[i]
  }
  for(i=j+1;i<=n;i++){
    delete a[i]
  }
  j=0
  for(i=length(a);i>=1;i--){
    if(back==0){
      if(a[i]==".."){
        back++
        continue
      } else {
        b[++j]=a[i]
      }
    } else {
      if(a[i]==".."){
        back++
        continue
      } else {
        back--
        continue
      }
    }
  }
  if(length(b)==0){
    return "/"
  } else {
    for(i=length(b);i>=1;i--){
      out=out"/"b[i]
    }
    return out
  }
}

BEGIN{
  if(ARGC>1){
    for(k=1;k<ARGC;k++){
      print abspath(ARGV[k])
    }
    exit
  }
}
{
  print abspath($0)
}

示例：

$ abspath I/am/.//..//the/./god/../of///.././war
/Users/leon/I/the/war

Answer 14

我发现Eugen Konkov的答案是最好的它不需要安装任何程序。但是，对于不存在的目录，它将失败。

我写了一个适用于不存在目录的函数：

function getRealPath()
{
    local -i traversals=0
    currentDir="$1"
    basename=''
    while :; do
        [[ "$currentDir" == '.' ]] && { echo "$1"; return 1; }
        [[ $traversals -eq 0 ]] && pwd=$(cd "$currentDir" 2>&1 && pwd) && { echo "$pwd/$basename"; return 0; }
        currentBasename="$(basename "$currentDir")"
        currentDir="$(dirname "$currentDir")"
        [[ "$currentBasename" == '..' ]] && (( ++traversals )) || { [[ traversals -gt 0 ]] && (( traversals-- )) || basename="$currentBasename/$basename"; }
    done
}

它解决了不存在目录的问题，通过用dirname向上遍历，直到cd成功，然后返回当前目录加上被 dirname 删除的所有内容。

Answer 15

与 @ernest-a 的答案类似，但不影响 $OLDPWD 或定义一个新函数，您可以触发子 shell (cd; pwd)

$ pwd
/etc/apache2
$ cd ../cups 
$ cd -
/etc/apache2
$ (cd ~/..; pwd)
/Users
$ cd -
/etc/cups

Answer 16

您可以对任何相对路径 $line 使用 bash 字符串替换：

line=$(echo ${line/#..\//`cd ..; pwd`\/})
line=$(echo ${line/#.\//`pwd`\/})
echo $line

基本的字符串前面替换遵循以下公式
${string/#substring/replacement}
这里讨论得很好： https://www.tldp.org/ LDP/abs/html/string-manipulation.html

当我们希望它成为我们查找/替换的字符串的一部分时，\ 字符会否定 / 。

Answer 17

我无法找到在 Mac OS Catalina、Ubuntu 16 和 Centos 7 之间完美移植的解决方案，因此我决定使用 python 内联来实现，它非常适合我的 bash 脚本。

to_abs_path() {
  python -c "import os; print os.path.abspath('$1')"
}

to_abs_path "/some_path/../secrets"

Answer 18

BLUF：

cd $relative_path ; pwd

这是符合 POSIX 标准的解释（我认为），所以它应该适用于任何平台。

当然，这是可以编写脚本的，但我认为将其分解可能会让某些人更容易理解/修改特定的用例。

您可以使用 which、locate、find、完整路径等。

x=your_file_name

$ x="nvi" 

file 轻松指示符号链接

$ file -h `which $x`
/usr/local/bin/nvi: symbolic link to ../Cellar/nvi/1.81.6_5/bin/nvi

接下来，稍微整理一下输出，以便我们获得“完整”相对路径。
我们只需要删除这个例子中的中间部分。

注意大写 Y 与小写 x。可能有一种更干净的方法可以做到这一点。

$ Y=$(file -h `which $x` | sed "s/$x: symbolic link to //")


$ echo $Y
/usr/local/bin/../Cellar/nvi/1.81.6_5/bin/nvi

使用dirname我们只得到路径部分。 cd 到它，名称应该会自行清理。

$ cd `dirname $Y` ; pwd
/usr/local/Cellar/nvi/1.81.6_5/bin

这引导我们使用古老的 UNIX 技巧，通过在括号/子 shell 中完成所有操作来“幽灵行走”目录。完成后，这实际上使我们返回到当前目录。

为了完整起见，我们可以将实际的文件名贴回末尾。

ls 甚至可以确保绝对路径有效，以获得奖励积分。

$ ( cd `dirname ${Y}` ; ls `pwd`/${x} )
/usr/local/Cellar/nvi/1.81.6_5/bin/nvi

所以 /usr/local/bin/nvi 实际上是 /usr/local/Cellar/nvi/1.81.6_5/bin/nvi

快速“转换”路径的简化示例：

$ (cd /usr/local/bin/../Cellar/nvi/1.81.6_5/bin ; pwd)
/usr/local/Cellar/nvi/1.81.6_5/bin

https://pubs.opengroup.org/onlinepubs/9699919799/utilities/file .html
https://pubs.opengroup.org/onlinepubs/9699919799/utilities/dirname。 html

Answer 19

他们所说的，除了 find $PWD 或（在 bash 中）find ~+ 更方便一些。

Answer 20

如果相对路径是目录路径，那么试试我的，应该是最好的：

absPath=$(pushd ../SOME_RELATIVE_PATH_TO_Directory > /dev/null && pwd && popd > /dev/null)

echo $absPath

Answer 21

这是一个相当短的函数，可用于仅使用 POSIX shell 和 readlink 语义来完全绝对化和规范化任何给定的输入路径：

canonicalize_path() {
    (
        FILEPATH="$1"
        for _ in 1 2 3 4 5 6 7 8;  # Maximum symlink recursion depth
        do
            cd -L "`case "${FILEPATH}" in */*) echo "${FILEPATH%/*}";; *) echo ".";; esac`/"  # cd $(dirname)
            if ! FILEPATH="$(readlink "${FILEPATH##*/}" || ( echo "${FILEPATH##*/}" && false ) )";
            then
                break
            fi
        done
        cd -P "." || return $?
        echo "$(pwd)/${FILEPATH}"
    )
}

如果引用的文件不存在，则仅使用通向最终文件名的目录路径将会得到解决。如果通向文件路径的任何目录不存在，则会返回 cd 错误。这恰好是它试图模仿的 GNU/Linux readlink -f 命令的确切语义。

在 bash/zsh 中，您还可以将数字列表压缩为 {1..8} 或类似内容。选择 8 的数量是因为这是 Linux 多年来的最大限制，之后在版本 4.2 中将其更改为整个路径的 40 个分辨率的总限制。如果达到分辨率限制，代码不会失败，而是返回最后考虑的路径 - 可以添加显式的 [ -L "${FILEPATH}" ] 检查来检测这个条件不过。

通过简单地删除函数和子 shell 包装器，此代码还可以轻松地重用，以确保当前工作目录与文件系统中执行的脚本的位置匹配（shell 脚本的常见要求）：

FILEPATH="$0"
for _ in 1 2 3 4 5 6 7 8;  # Maximum symlink recursion depth
do
    cd -L "`case "${FILEPATH}" in */*) echo "${FILEPATH%/*}";; *) echo ".";; esac`/"  # cd $(dirname)
    if ! FILEPATH="$(readlink "${FILEPATH##*/}" || ( echo "${FILEPATH##*/}" && false ) )";
    then
        break
    fi
done
cd -P "."
FILEPATH="$(pwd)/${FILEPATH}"

Answer 22

echo "mydir/doc/ mydir/usoe ./mydir/usm" |  awk '{ split($0,array," "); for(i in array){ system("cd "array[i]" && echo $PWD") } }'

在上面的代码片段中，awk 用于分割从 echo （通过管道）接收到的目录字符串并创建一个数组。

以下是所发生情况的分步列表：

• 以空格分隔的目录列表通过管道传输到 awk
• awk 通过空格将管道文本拆分为数组
• awk 对数组中的每个项目（变量 i）进行循环
• awk 使用 awk 系统命令运行 cli 命令
• CLI 命令将目录 (cd) 更改为数组中项目“i”指定的路径，然后使用环境变量 $PWD 打印（回显）工作目录”

使用 cd 移动到每个目录，然后打印 $PWD 的值是让操作系统确定绝对路径的好方法

Answer 23

如果您想将包含相对路径的变量转换为绝对路径，则可以这样做：

   dir=`cd "$dir"`

“cd”会在不更改工作目录的情况下进行回显，因为在子 shell 中执行。

Answer 24

这是来自所有其他解决方案的链式解决方案，例如，当 realpath 失败时，要么因为未安装，要么因为它以错误代码退出，然后尝试下一个解决方案，直到获得正确的路径。

#!/bin/bash

function getabsolutepath() {
    local target;
    local changedir;
    local basedir;
    local firstattempt;

    target="${1}";
    if [ "$target" == "." ];
    then
        printf "%s" "$(pwd)";

    elif [ "$target" == ".." ];
    then
        printf "%s" "$(dirname "$(pwd)")";

    else
        changedir="$(dirname "${target}")" && basedir="$(basename "${target}")" && firstattempt="$(cd "${changedir}" && pwd)" && printf "%s/%s" "${firstattempt}" "${basedir}" && return 0;
        firstattempt="$(readlink -f "${target}")" && printf "%s" "${firstattempt}" && return 0;
        firstattempt="$(realpath "${target}")" && printf "%s" "${firstattempt}" && return 0;

        # If everything fails... TRHOW PYTHON ON IT!!!
        local fullpath;
        local pythoninterpreter;
        local pythonexecutables;
        local pythonlocations;

        pythoninterpreter="python";
        declare -a pythonlocations=("/usr/bin" "/bin");
        declare -a pythonexecutables=("python" "python2" "python3");

        for path in "${pythonlocations[@]}";
        do
            for executable in "${pythonexecutables[@]}";
            do
                fullpath="${path}/${executable}";

                if [[ -f "${fullpath}" ]];
                then
                    # printf "Found ${fullpath}\\n";
                    pythoninterpreter="${fullpath}";
                    break;
                fi;
            done;

            if [[ "${pythoninterpreter}" != "python" ]];
            then
                # printf "Breaking... ${pythoninterpreter}\\n"
                break;
            fi;
        done;

        firstattempt="$(${pythoninterpreter} -c "import os, sys; print( os.path.abspath( sys.argv[1] ) );" "${target}")" && printf "%s" "${firstattempt}" && return 0;
        # printf "Error: Could not determine the absolute path!\\n";
        return 1;
    fi
}

printf "\\nResults:\\n%s\\nExit: %s\\n" "$(getabsolutepath "./asdfasdf/ asdfasdf")" "${?}"

Answer 25

基于此答案，作者：@EugenKonkov 和 此答案，作者：@HashChange，我的回答结合了前者的简洁性和后者对 . 和 .. 的处理。我相信下面的所有选项都依赖于基本的 Shell 命令语言 POSIX标准。

使用dirname和basename，一个选项是：

absPathDirname()
{
    [ -d "${1}" ] && set -- "${1}" || set -- "`dirname "${1}"`" "/`basename "${1}"`"
    echo "`cd "${1}"; pwd`${2}";
}

如果不使用dirname或basename，另一个简短的选项是：

absPathMinusD()
{
    [ -d "${1}" ] && set -- "${1}" || set -- "${1%${1##*/}}" "/${1##*/}"
    echo "`cd "${1:-.}"; pwd`${2}";
}

我会推荐上面两个选项之一，其余的只是为了好玩...

Grep 版本：

absPathGrep()
{
    echo "`[ "${1##/*}" ] && echo "$1" | grep -Eo '^(.*/)?\.\.($|/)' | { read d && cd "$d"; echo "${PWD}/${1#$d}"; } || echo "$1"`"
}

作为“使用 shell 的有限正则表达式可以做什么”的有趣示例：

absPathShellReplace()
{
    E="${1##*/}"; D="${E#$E${E#.}}"; DD="${D#$D${D#..}}"
    DIR="${1%$E}${E#$DD}"; FILE="${1#$DIR}"; SEP=${FILE:+/}
    echo "`cd "${DIR:-.}"; pwd`${SEP#$DIR}$FILE"
}

Answer 26

更新之前的答案

to_abs_path() {
  python -c "import os; print (os.path.abspath('$1'))"
}

使用 python 3允许

to_abs_path "./../some_file.txt"