Bash：检索给定相对的绝对路径

Question

是否有命令在给定相对路径的情况下检索绝对路径？

例如，我希望$ line包含dir ./etc/

中每个文件的绝对路径

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

Answer 1

试试realpath。

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

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

答案来自＆＃34; bash/fish command to print absolute path to a file＆＃34;。

Answer 2

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

Answer 3

使用：

find $(pwd)/ -type f

获取所有文件或

echo $(pwd)/$line

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

Answer 4

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

UPD 一些解释

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

Answer 5

为了它的价值，我投票选出了答案，但想分享一个解决方案。缺点是，它只是Linux - 我花了大约5分钟试图在进入Stack溢出之前找到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必须存在，并且可能在其中使用 计算，在实际创建文件之前。）

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

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

没有选项的readlink foo命令仅在答案时给出答案 参数foo是一个符号链接，答案就是它的价值 符号链接。没有其他链接。答案可能是相对路径： 什么是符号链接参数的值。

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

这适用于任何非符号链接的东西，尽管可能 希望在不解析中间体的情况下使用绝对路径名 路径上的符号链接。这是通过命令realpath -s foo

完成的

对于符号链接参数，readlink及其选项将会出现 再次解析参数的绝对路径上的所有符号链接，但是 这也将包括可能遇到的所有符号链接 遵循参数值。如果你想要的话，你可能不希望这样 参数符号链接本身的绝对路径，而不是任何东西 它可能链接到。同样，如果foo是符号链接，realpath -s foo会 获得绝对路径而不解析符号链接，包括一个 作为论点。

如果没有-s选项，realpath的作用几乎相同 readlink，除了简单地读取链接的值，以及几个 其他事情。我不清楚为什么readlink有它 选项，显然创建了一个不合需要的冗余 realpath。

探索网络并没有多说，除了可能有 跨系统的一些变化。

结论：realpath是最常用的命令 灵活性，至少在这里要求使用。

Answer 8

Eugen的回答并不适合我，但确实如此：

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

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

Answer 9

我最喜欢的解决方案是@EugenKonkov的the one，因为它并不暗示存在其他实用程序（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 10

如果是find，最简单的方法是给它搜索的绝对路径，例如：

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

Answer 11

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

（纯粹的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 12

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

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

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 13

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

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

1. 具有解析符号链接：

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

1. 或没有它：

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

Answer 14

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

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 15

我找不到在Mac OS Catalina，Ubuntu 16和Centos 7之间可整齐移植的解决方案，因此我决定使用python inline来实现，并且对我的bash脚本效果很好。

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

to_abs_path "/some_path/../secrets"

Answer 16

这是一个相当短的函数，可用于仅使用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 17

基于this answer的@EugenKonkov和this answer的@HashChange，我的回答结合了前者的简洁性以及.和{{1的处理}} 后者。我相信下面的所有选项都只依赖于基本的 Shell Command Language POSIX standards。

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

basename

不使用 absPathDirname() { [ -d "${1}" ] && set -- "${1}" || set -- "`dirname "${1}"`" "/`basename "${1}"`" echo "`cd "${1}"; pwd`${2}"; } 或 dirname，另一个简短的选择是：

basename

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

Grep 版本：

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

作为“可以用 shell 的有限 RegEx 做什么”的一个有趣例子：

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

Answer 18

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

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

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

Answer 19

这是所有其他解决方案的链式解决方案，例如，当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 20

如果要将包含相对路径的变量转换为绝对路径，则可以：

   dir=`cd "$dir"`

“cd”回声而不改变工作目录，因为这里在子shell中执行。

Answer 21

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

Answer 22

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

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

echo $absPath

Answer 23

与@ ernest-a的答案类似，但不影响$OLDPWD或定义新功能，您可以触发子shell (cd <path>; pwd)

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

Answer 24

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