【问题标题】：Convert absolute path into relative path given a current directory using Bash使用 Bash 将给定当前目录的绝对路径转换为相对路径
【发布时间】：2011-02-03 14:40:41
【问题描述】：

例子：

absolute="/foo/bar"
current="/foo/baz/foo"

# Magic

relative="../../bar"

我如何创造魔法（希望代码不要太复杂...）？

【问题讨论】：

例如（我现在的情况）为 gcc 提供相对路径，这样即使源路径发生变化，它也可以生成可用的相对调试信息。
在 U&L 上提出了一个类似的问题：unix.stackexchange.com/questions/100918/…。其中一个答案 (@Gilles) 提到了一个工具，symlinks，它可以轻松解决这个问题。
简单：realpath --relative-to=$absolute $current.

标签： bash shell path relative-path absolute-path

【解决方案1】：

我使用的是默认没有realpath命令的macOS，所以我做了一个pure bash函数来计算它。

#!/bin/bash

##
# print a relative path from "source folder" to "target file"
#
# params:
#  $1 - target file, can be a relative path or an absolute path.
#  $2 - source folder, can be a relative path or an absolute path.
#
# test:
#  $ mkdir -p ~/A/B/C/D; touch ~/A/B/C/D/testfile.txt; touch ~/A/B/testfile.txt
#
#  $ getRelativePath ~/A/B/C/D/testfile.txt  ~/A/B
#  $ C/D/testfile.txt
#  
#  $ getRelativePath ~/A/B/testfile.txt  ~/A/B/C
#  $ ../testfile.txt
#
#  $ getRelativePath ~/A/B/testfile.txt  /
#  $ home/bunnier/A/B/testfile.txt 
#
function getRelativePath(){
    local targetFilename=$(basename $1)
    local targetFolder=$(cd $(dirname $1);pwd) # absolute target folder path
    local currentFolder=$(cd $2;pwd) # absulute source folder
    local result=.

    while [ "$currentFolder" != "$targetFolder" ];do
      if [[ "$targetFolder" =~ "$currentFolder"* ]];then
          pointSegment=${targetFolder#$currentFolder}
          result=$result/${pointSegment#/}
          break
      fi  
      result="$result"/..
      currentFolder=$(dirname $currentFolder)
    done

    result=$result/$targetFilename
    echo ${result#./}
}

【讨论】：

【解决方案2】：

另一种解决方案，纯 bash + GNU readlink 以便在以下上下文中轻松使用：

ln -s "$(relpath "$A" "$B")" "$B"

编辑：在这种情况下，请确保“$B”不存在或没有软链接，否则relpath 跟随此链接，这不是您想要的！

这适用于几乎所有当前的 Linux。如果readlink -m 在您身边不起作用，请尝试使用readlink -f。另请参阅https://gist.github.com/hilbix/1ec361d00a8178ae8ea0 了解可能的更新：

: relpath A B
# Calculate relative path from A to B, returns true on success
# Example: ln -s "$(relpath "$A" "$B")" "$B"
relpath()
{
local X Y A
# We can create dangling softlinks
X="$(readlink -m -- "$1")" || return
Y="$(readlink -m -- "$2")" || return
X="${X%/}/"
A=""
while   Y="${Y%/*}"
        [ ".${X#"$Y"/}" = ".$X" ]
do
        A="../$A"
done
X="$A${X#"$Y"/}"
X="${X%/}"
echo "${X:-.}"
}

注意事项：

注意防止不必要的 shell 元字符扩展，以防文件名包含 * 或 ?。
输出可用作ln -s 的第一个参数：
- relpath / / 给出 . 而不是空字符串
- relpath a a 给出a，即使a 恰好是一个目录
也对大多数常见案例进行了测试以得出合理的结果。
此解决方案使用字符串前缀匹配，因此需要readlink 来规范化路径。
感谢readlink -m，它也适用于尚不存在的路径。

在旧系统上，readlink -m 不可用，如果文件不存在，readlink -f 将失败。所以你可能需要一些这样的解决方法（未经测试！）：

readlink_missing()
{
readlink -m -- "$1" && return
readlink -f -- "$1" && return
[ -e . ] && echo "$(readlink_missing "$(dirname "$1")")/$(basename "$1")"
}

如果$1 包含不存在路径的. 或..（如/doesnotexist/./a），这并不完全正确，但它应该涵盖大多数情况。

（将上面的readlink -m --替换为readlink_missing。）

编辑因为不赞成投票跟随

这是一个测试，这个函数确实是正确的：

check()
{
res="$(relpath "$2" "$1")"
[ ".$res" = ".$3" ] && return
printf ':WRONG: %-10q %-10q gives %q\nCORRECT %-10q %-10q gives %q\n' "$1" "$2" "$res" "$@"
}

#     TARGET   SOURCE         RESULT
check "/A/B/C" "/A"           ".."
check "/A/B/C" "/A.x"         "../../A.x"
check "/A/B/C" "/A/B"         "."
check "/A/B/C" "/A/B/C"       "C"
check "/A/B/C" "/A/B/C/D"     "C/D"
check "/A/B/C" "/A/B/C/D/E"   "C/D/E"
check "/A/B/C" "/A/B/D"       "D"
check "/A/B/C" "/A/B/D/E"     "D/E"
check "/A/B/C" "/A/D"         "../D"
check "/A/B/C" "/A/D/E"       "../D/E"
check "/A/B/C" "/D/E/F"       "../../D/E/F"

check "/foo/baz/moo" "/foo/bar" "../bar"

困惑？嗯，这些是正确的结果！即使您认为它不适合这个问题，也可以证明这是正确的：

check "http://example.com/foo/baz/moo" "http://example.com/foo/bar" "../bar"

毫无疑问，../bar 是从页面moo 看到的页面bar 的准确且唯一正确的相对路径。其他一切都是错误的。

采用显然假设current 是一个目录的问题的输出是微不足道的：

absolute="/foo/bar"
current="/foo/baz/foo"
relative="../$(relpath "$absolute" "$current")"

这将准确返回所要求的内容。

在你挑眉之前，这里有一个更复杂的 relpath 变体（发现细微差别），它也应该适用于 URL 语法（所以尾随 / 仍然存在，感谢一些 @ 987654357@-magic):

# Calculate relative PATH to the given DEST from the given BASE
# In the URL case, both URLs must be absolute and have the same Scheme.
# The `SCHEME:` must not be present in the FS either.
# This way this routine works for file paths an
: relpathurl DEST BASE
relpathurl()
{
local X Y A
# We can create dangling softlinks
X="$(readlink -m -- "$1")" || return
Y="$(readlink -m -- "$2")" || return
X="${X%/}/${1#"${1%/}"}"
Y="${Y%/}${2#"${2%/}"}"
A=""
while   Y="${Y%/*}"
        [ ".${X#"$Y"/}" = ".$X" ]
do
        A="../$A"
done
X="$A${X#"$Y"/}"
X="${X%/}"
echo "${X:-.}"
}

这里的检查只是为了说明：它确实如所描述的那样工作。

check()
{
res="$(relpathurl "$2" "$1")"
[ ".$res" = ".$3" ] && return
printf ':WRONG: %-10q %-10q gives %q\nCORRECT %-10q %-10q gives %q\n' "$1" "$2" "$res" "$@"
}

#     TARGET   SOURCE         RESULT
check "/A/B/C" "/A"           ".."
check "/A/B/C" "/A.x"         "../../A.x"
check "/A/B/C" "/A/B"         "."
check "/A/B/C" "/A/B/C"       "C"
check "/A/B/C" "/A/B/C/D"     "C/D"
check "/A/B/C" "/A/B/C/D/E"   "C/D/E"
check "/A/B/C" "/A/B/D"       "D"
check "/A/B/C" "/A/B/D/E"     "D/E"
check "/A/B/C" "/A/D"         "../D"
check "/A/B/C" "/A/D/E"       "../D/E"
check "/A/B/C" "/D/E/F"       "../../D/E/F"

check "/foo/baz/moo" "/foo/bar" "../bar"
check "http://example.com/foo/baz/moo" "http://example.com/foo/bar" "../bar"

check "http://example.com/foo/baz/moo/" "http://example.com/foo/bar" "../../bar"
check "http://example.com/foo/baz/moo"  "http://example.com/foo/bar/" "../bar/"
check "http://example.com/foo/baz/moo/"  "http://example.com/foo/bar/" "../../bar/"

下面是如何使用它来从问题中给出想要的结果：

absolute="/foo/bar"
current="/foo/baz/foo"
relative="$(relpathurl "$absolute" "$current/")"
echo "$relative"

如果您发现某些东西不起作用，请在下面的 cmets 中告诉我。谢谢。

PS：

为什么relpath 的论点与这里的所有其他答案相反？

如果你改变了

Y="$(readlink -m -- "$2")" || return

到

Y="$(readlink -m -- "${2:-"$PWD"}")" || return

然后您可以保留第二个参数，这样 BASE 就是当前目录/URL/whatever。和往常一样，这只是 Unix 原则。

【讨论】：

【解决方案3】：

假设你已经安装了：bash、pwd、dirname、echo；那么 relpath 是

#!/bin/bash
s=$(cd ${1%%/};pwd); d=$(cd $2;pwd); b=; while [ "${d#$s/}" == "${d}" ]
do s=$(dirname $s);b="../${b}"; done; echo ${b}${d#$s/}

我已经从pini 和其他一些想法中得到了答案

注意：这要求两个路径都是现有文件夹。文件将不工作。

【讨论】：

理想答案：与 /bin/sh 一起使用，不需要 readlink、python、perl -> 非常适合轻型/嵌入式系统或 windows bash 控制台
不幸的是，这需要路径存在，这并不总是需要的。
虔诚的回答。 cd-pwd 的东西是为了解决我猜的链接？打高尔夫球不错！

【解决方案4】：

我认为使用 GNU coreutils 8.23 中的 realpath 是最简单的：

$ realpath --relative-to="$file1" "$file2"

例如：

$ realpath --relative-to=/usr/bin/nmap /tmp/testing
../../../tmp/testing

【讨论】：

在Ubuntu 14.04上这个包已经过时了，没有--relative-to选项，很可惜。
在 Ubuntu 16.04 上运行良好
如果您想要相对于当前工作目录的路径，$ realpath --relative-to="${PWD}" "$file" 很有用。
这适用于/usr/bin/nmap/-path 中的内容，但不适用于/usr/bin/nmap：从nmap 到/tmp/testing 只有../../，而不是../ 的3 次。但是它可以工作，因为在 rootfs 上执行 .. 是 /。
作为@PatrickB。暗示，--relative-to=… 需要一个目录并且不检查。这意味着如果您请求相对于文件的路径，您最终会得到一个额外的“../”（就像这个例子一样，因为/usr/bin 很少或从不包含目录，而nmap 通常是二进制文件）

【解决方案5】：

这是我的版本。它基于answer by @Offirmo。我使它与 Dash 兼容并修复了以下测试用例失败：

./compute-relative.sh "/a/b/c/de/f/g" "/a/b/c/def/g/" --> "../..f/g/"

现在：

CT_FindRelativePath "/a/b/c/de/f/g" "/a/b/c/def/g/" --> "../../../def/g/"

查看代码：

# both $1 and $2 are absolute paths beginning with /
# returns relative path to $2/$target from $1/$source
CT_FindRelativePath()
{
    local insource=$1
    local intarget=$2

    # Ensure both source and target end with /
    # This simplifies the inner loop.
    #echo "insource : \"$insource\""
    #echo "intarget : \"$intarget\""
    case "$insource" in
        */) ;;
        *) source="$insource"/ ;;
    esac

    case "$intarget" in
        */) ;;
        *) target="$intarget"/ ;;
    esac

    #echo "source : \"$source\""
    #echo "target : \"$target\""

    local common_part=$source # for now

    local result=""

    #echo "common_part is now : \"$common_part\""
    #echo "result is now      : \"$result\""
    #echo "target#common_part : \"${target#$common_part}\""
    while [ "${target#$common_part}" = "${target}" -a "${common_part}" != "//" ]; do
        # no match, means that candidate common part is not correct
        # go up one level (reduce common part)
        common_part=$(dirname "$common_part")/
        # and record that we went back
        if [ -z "${result}" ]; then
            result="../"
        else
            result="../$result"
        fi
        #echo "(w) common_part is now : \"$common_part\""
        #echo "(w) result is now      : \"$result\""
        #echo "(w) target#common_part : \"${target#$common_part}\""
    done

    #echo "(f) common_part is     : \"$common_part\""

    if [ "${common_part}" = "//" ]; then
        # special case for root (no common path)
        common_part="/"
    fi

    # since we now have identified the common part,
    # compute the non-common part
    forward_part="${target#$common_part}"
    #echo "forward_part = \"$forward_part\""

    if [ -n "${result}" -a -n "${forward_part}" ]; then
        #echo "(simple concat)"
        result="$result$forward_part"
    elif [ -n "${forward_part}" ]; then
        result="$forward_part"
    fi
    #echo "result = \"$result\""

    # if a / was added to target and result ends in / then remove it now.
    if [ "$intarget" != "$target" ]; then
        case "$result" in
            */) result=$(echo "$result" | awk '{ string=substr($0, 1, length($0)-1); print string; }' ) ;;
        esac
    fi

    echo $result

    return 0
}

【讨论】：

【解决方案6】：

这个答案没有解决问题的 Bash 部分，但是因为我试图使用这个问题中的答案来实现 Emacs 中的这个功能，所以我会把它扔在那里。

Emacs 实际上有一个开箱即用的功能：

ELISP> (file-relative-name "/a/b/c" "/a/b/c")
"."
ELISP> (file-relative-name "/a/b/c" "/a/b")
"c"
ELISP> (file-relative-name "/a/b/c" "/c/b")
"../../a/b/c"

【讨论】：

请注意，对于您提供的测试用例，我相信我最近添加的 python 答案（relpath 函数）的行为与 file-relative-name 相同。

【解决方案7】：

它自 2001 年以来内置于 Perl，因此它几乎适用于您能想象到的所有系统，甚至是 VMS。

perl -e 'use File::Spec; print File::Spec->abs2rel(@ARGV) . "\n"' FILE BASE

而且，解决方案很容易理解。

所以对于你的例子：

perl -e 'use File::Spec; print File::Spec->abs2rel(@ARGV) . "\n"' $absolute $current

...可以正常工作。

【讨论】：

say 在 perl 中不能用作日志，但在这里可以有效地使用。 perl -MFile::Spec -E 'say File::Spec->abs2rel(@ARGV)'
+1 但另见 this similar answer 较旧（2012 年 2 月）。另请阅读来自William Pursell 的相关 cmets。我的版本是两个命令行：perl -MFile::Spec -e 'print File::Spec->abs2rel(@ARGV)' "$target" 和 perl -MFile::Spec -e 'print File::Spec->abs2rel(@ARGV)' "$target" "$origin"。第一个单行perl 脚本使用一个参数（原点是当前工作目录）。第二个单行 perl 脚本使用两个参数。
这应该是公认的答案。 perl 几乎随处可见，但答案仍然是单行的。

【解决方案8】：

此脚本仅适用于路径名。它不需要任何文件存在。如果传递的路径不是绝对的，则行为有点不寻常，但如果两条路径都是相对的，它应该会按预期工作。

我只在 OS X 上测试过，所以它可能不便携。

#!/bin/bash
set -e
declare SCRIPT_NAME="$(basename $0)"
function usage {
    echo "Usage: $SCRIPT_NAME <base path> <target file>"
    echo "       Outputs <target file> relative to <base path>"
    exit 1
}

if [ $# -lt 2 ]; then usage; fi

declare base=$1
declare target=$2
declare -a base_part=()
declare -a target_part=()

#Split path elements & canonicalize
OFS="$IFS"; IFS='/'
bpl=0;
for bp in $base; do
    case "$bp" in
        ".");;
        "..") let "bpl=$bpl-1" ;;
        *) base_part[${bpl}]="$bp" ; let "bpl=$bpl+1";;
    esac
done
tpl=0;
for tp in $target; do
    case "$tp" in
        ".");;
        "..") let "tpl=$tpl-1" ;;
        *) target_part[${tpl}]="$tp" ; let "tpl=$tpl+1";;
    esac
done
IFS="$OFS"

#Count common prefix
common=0
for (( i=0 ; i<$bpl ; i++ )); do
    if [ "${base_part[$i]}" = "${target_part[$common]}" ] ; then
        let "common=$common+1"
    else
        break
    fi
done

#Compute number of directories up
let "updir=$bpl-$common" || updir=0 #if the expression is zero, 'let' fails

#trivial case (after canonical decomposition)
if [ $updir -eq 0 ]; then
    echo .
    exit
fi

#Print updirs
for (( i=0 ; i<$updir ; i++ )); do
    echo -n ../
done

#Print remaining path
for (( i=$common ; i<$tpl ; i++ )); do
    if [ $i -ne $common ]; then
        echo -n "/"
    fi
    if [ "" != "${target_part[$i]}" ] ; then
        echo -n "${target_part[$i]}"
    fi
done
#One last newline
echo

【讨论】：

另外，代码有点复制和粘贴，但我需要这个很快。
很好......正是我所需要的。而且你已经包含了一个比我见过的大多数其他人更好的规范化例程（通常依赖于正则表达式替换）。

【解决方案9】：

这里没有很多答案适合日常使用。由于在纯 bash 中正确执行此操作非常困难，因此我建议以下可靠的解决方案（类似于隐藏在评论中的一个建议）：

function relpath() { 
  python -c "import os,sys;print(os.path.relpath(*(sys.argv[1:])))" "$@";
}

然后，可以根据当前目录获取相对路径：

echo $(relpath somepath)

或者您可以指定路径是相对于给定目录的：

echo $(relpath somepath /etc)  # relative to /etc

一个缺点是这需要python，但是：

它在任何 python >= 2.6 中的工作原理都是一样的
不要求文件或目录存在。
文件名可能包含更广泛的特殊字符。例如，如果文件名包含许多其他解决方案将不起作用空格或其他特殊字符。
这是一个不会使脚本混乱的单行函数。

请注意，包含basename 或dirname 的解决方案不一定更好，因为它们需要安装coreutils。如果有人有一个可靠且简单的纯bash 解决方案（而不是令人费解的好奇心），我会感到惊讶。

【讨论】：

这似乎是迄今为止最可靠的方法。

【解决方案10】：

这是对来自 @pini 的当前评价最高的解决方案（遗憾的是，它只处理少数情况）的更正、功能齐全的改进

提醒：'-z' 测试字符串是否为零长度（=空），'-n' 测试字符串是否不为空。

# both $1 and $2 are absolute paths beginning with /
# returns relative path to $2/$target from $1/$source
source=$1
target=$2

common_part=$source # for now
result="" # for now

while [[ "${target#$common_part}" == "${target}" ]]; do
    # no match, means that candidate common part is not correct
    # go up one level (reduce common part)
    common_part="$(dirname $common_part)"
    # and record that we went back, with correct / handling
    if [[ -z $result ]]; then
        result=".."
    else
        result="../$result"
    fi
done

if [[ $common_part == "/" ]]; then
    # special case for root (no common path)
    result="$result/"
fi

# since we now have identified the common part,
# compute the non-common part
forward_part="${target#$common_part}"

# and now stick all parts together
if [[ -n $result ]] && [[ -n $forward_part ]]; then
    result="$result$forward_part"
elif [[ -n $forward_part ]]; then
    # extra slash removal
    result="${forward_part:1}"
fi

echo $result

测试用例：

compute_relative.sh "/A/B/C" "/A"           -->  "../.."
compute_relative.sh "/A/B/C" "/A/B"         -->  ".."
compute_relative.sh "/A/B/C" "/A/B/C"       -->  ""
compute_relative.sh "/A/B/C" "/A/B/C/D"     -->  "D"
compute_relative.sh "/A/B/C" "/A/B/C/D/E"   -->  "D/E"
compute_relative.sh "/A/B/C" "/A/B/D"       -->  "../D"
compute_relative.sh "/A/B/C" "/A/B/D/E"     -->  "../D/E"
compute_relative.sh "/A/B/C" "/A/D"         -->  "../../D"
compute_relative.sh "/A/B/C" "/A/D/E"       -->  "../../D/E"
compute_relative.sh "/A/B/C" "/D/E/F"       -->  "../../../D/E/F"

【讨论】：

集成在offirmo shell lib github.com/Offirmo/offirmo-shell-lib，函数«OSL_FILE_find_relative_path»（文件«osl_lib_file.sh»）
+1。通过将 source=$1; target=$2 替换为 source=$(realpath $1); target=$(realpath $2)，可以轻松地处理任何路径（不仅仅是以 / 开头的绝对路径）
@Josh 确实如此，前提是 dirs 确实存在......这对于单元测试来说是不方便的 ;) 但在实际使用中是的，建议使用 realpath，或者 source=$(readlink -f $1) 等，如果 realpath不可用（非标准）
我这样定义$source和$target：` if [[ -e $1 ]];然后 source=$(readlink -f $1);否则来源=$1；如果 [[ -e $2 ]];然后目标=$(readlink -f $2);否则目标=$2； fi` 这样，该函数可以处理真实/现有的相对路径以及虚构的目录。
@NathanS.Watson-Haigh 更好的是，我最近发现readlink 有一个-m 选项可以做到这一点；）

【解决方案11】：

$ python -c "import os.path; print os.path.relpath('/foo/bar', '/foo/baz/foo')"

给予：

../../bar

【讨论】：

它有效，它使替代方案看起来很荒谬。这对我来说是个奖励xD
+1。好吧，你被骗了……但这太好了，不能用！ relpath(){ python -c "import os.path; print os.path.relpath('$1','${2:-$PWD}')" ; }
遗憾的是，这并不是普遍可用的：os.path.relpath 是 Python 2.6 中的新功能。
@ChenLevy：Python 2.6 于 2008 年发布。很难相信它在 2012 年还没有普及。
python -c 'import os, sys; print(os.path.relpath(*sys.argv[1:]))' 工作最自然、最可靠。

【解决方案12】：

我需要这样的东西，但它也解决了符号链接。我发现 pwd 为此目的有一个 -P 标志。附加了我的脚本片段。它在 shell 脚本的一个函数中，因此是 $1 和 $2。结果值，即从 START_ABS 到 END_ABS 的相对路径，位于 UPDIRS 变量中。脚本 cd 进入每个参数目录以执行 pwd -P，这也意味着处理相对路径参数。干杯，吉姆

SAVE_DIR="$PWD"
cd "$1"
START_ABS=`pwd -P`
cd "$SAVE_DIR"
cd "$2"
END_ABS=`pwd -P`

START_WORK="$START_ABS"
UPDIRS=""

while test -n "${START_WORK}" -a "${END_ABS/#${START_WORK}}" '==' "$END_ABS";
do
    START_WORK=`dirname "$START_WORK"`"/"
    UPDIRS=${UPDIRS}"../"
done
UPDIRS="$UPDIRS${END_ABS/#${START_WORK}}"
cd "$SAVE_DIR"

【讨论】：

【解决方案13】：

对kasku's 和Pini's 的回答略有改进，可以更好地处理空格并允许传递相对路径：

#!/bin/bash
# both $1 and $2 are paths
# returns $2 relative to $1
absolute=`readlink -f "$2"`
current=`readlink -f "$1"`
# Perl is magic
# Quoting horror.... spaces cause problems, that's why we need the extra " in here:
relative=$(perl -MFile::Spec -e "print File::Spec->abs2rel(q($absolute),q($current))")

echo $relative

【讨论】：

【解决方案14】：

#!/bin/sh

# Return relative path from canonical absolute dir path $1 to canonical
# absolute dir path $2 ($1 and/or $2 may end with one or no "/").
# Does only need POSIX shell builtins (no external command)
relPath () {
    local common path up
    common=${1%/} path=${2%/}/
    while test "${path#"$common"/}" = "$path"; do
        common=${common%/*} up=../$up
    done
    path=$up${path#"$common"/}; path=${path%/}; printf %s "${path:-.}"
}

# Return relative path from dir $1 to dir $2 (Does not impose any
# restrictions on $1 and $2 but requires GNU Core Utility "readlink"
# HINT: busybox's "readlink" does not support option '-m', only '-f'
#       which requires that all but the last path component must exist)
relpath () { relPath "$(readlink -m "$1")" "$(readlink -m "$2")"; }

以上 shell 脚本的灵感来自 pini's（谢谢！）。它触发了一个错误在 Stack Overflow 的语法高亮模块中（至少在我的预览中）框架）。所以如果高亮不正确请忽略。

一些注意事项：

在不显着增加代码的情况下删除了错误并改进了代码长度和复杂性
将功能放入函数中以方便使用
保持函数与 POSIX 兼容，以便它们（应该）与所有 POSIX 兼容 shells（在 Ubuntu Linux 12.04 中使用 dash、bash 和 zsh 测试）
仅使用局部变量来避免破坏全局变量和污染全局命名空间
两个目录路径都不需要存在（我的应用程序的要求）
路径名可能包含空格、特殊字符、控制字符、反斜杠、制表符、'、"、?、*、[、] 等。
核心函数“relPath”仅使用 POSIX shell 内置函数，但需要规范的绝对目录路径作为参数
扩展函数“relpath”可以处理任意目录路径（也相对的，非规范的），但需要外部 GNU 核心实用程序“readlink”
避免使用内置“echo”并使用内置“printf”，原因有两个：
- 由于内置“echo”它的历史实现相互冲突在不同的 shell 中表现不同 -> POSIX recommends that printf is preferred over echo.
- 某些 POSIX shell 的内置“回显”将interpret some backslash sequences 并因此损坏包含此类序列的路径名
为避免不必要的转换，在返回时使用路径名并被 shell 和 OS 实用程序（例如 cd、ln、ls、find、mkdir；与 python 的“os.path.relpath”不同，它将解释一些反斜杠序列）
除了提到的反斜杠序列函数“relPath”的最后一行输出与 python 兼容的路径名：
```
path=$up${path#"$common"/}; path=${path%/}; printf %s "${path:-.}"
```
最后一行可以用行替换（和简化）
```
printf %s "$up${path#"$common"/}"
```
我更喜欢后者，因为
1. 文件名可以直接附加到relPath获取的dir路径中，例如：
```
ln -s "$(relpath "<fromDir>" "<toDir>")<file>" "<fromDir>"
```
2. 使用此方法创建的同一目录中的符号链接没有丑陋的"./" 前缀在文件名中。
如果您发现错误，请联系 linuxball (at) gmail.com，我会尝试修复它。
添加了回归测试套件（也兼容 POSIX shell）

回归测试的代码清单（只需将其附加到 shell 脚本）：

############################################################################
# If called with 2 arguments assume they are dir paths and print rel. path #
############################################################################

test "$#" = 2 && {
    printf '%s\n' "Rel. path from '$1' to '$2' is '$(relpath "$1" "$2")'."
    exit 0
}

#######################################################
# If NOT called with 2 arguments run regression tests #
#######################################################

format="\t%-19s %-22s %-27s %-8s %-8s %-8s\n"
printf \
"\n\n*** Testing own and python's function with canonical absolute dirs\n\n"
printf "$format\n" \
    "From Directory" "To Directory" "Rel. Path" "relPath" "relpath" "python"
IFS=
while read -r p; do
    eval set -- $p
    case $1 in '#'*|'') continue;; esac # Skip comments and empty lines
    # q stores quoting character, use " if ' is used in path name
    q="'"; case $1$2 in *"'"*) q='"';; esac
    rPOk=passed rP=$(relPath "$1" "$2"); test "$rP" = "$3" || rPOk=$rP
    rpOk=passed rp=$(relpath "$1" "$2"); test "$rp" = "$3" || rpOk=$rp
    RPOk=passed
    RP=$(python -c "import os.path; print os.path.relpath($q$2$q, $q$1$q)")
    test "$RP" = "$3" || RPOk=$RP
    printf \
    "$format" "$q$1$q" "$q$2$q" "$q$3$q" "$q$rPOk$q" "$q$rpOk$q" "$q$RPOk$q"
done <<-"EOF"
    # From directory    To directory           Expected relative path

    '/'                 '/'                    '.'
    '/usr'              '/'                    '..'
    '/usr/'             '/'                    '..'
    '/'                 '/usr'                 'usr'
    '/'                 '/usr/'                'usr'
    '/usr'              '/usr'                 '.'
    '/usr/'             '/usr'                 '.'
    '/usr'              '/usr/'                '.'
    '/usr/'             '/usr/'                '.'
    '/u'                '/usr'                 '../usr'
    '/usr'              '/u'                   '../u'
    "/u'/dir"           "/u'/dir"              "."
    "/u'"               "/u'/dir"              "dir"
    "/u'/dir"           "/u'"                  ".."
    "/"                 "/u'/dir"              "u'/dir"
    "/u'/dir"           "/"                    "../.."
    "/u'"               "/u'"                  "."
    "/"                 "/u'"                  "u'"
    "/u'"               "/"                    ".."
    '/u"/dir'           '/u"/dir'              '.'
    '/u"'               '/u"/dir'              'dir'
    '/u"/dir'           '/u"'                  '..'
    '/'                 '/u"/dir'              'u"/dir'
    '/u"/dir'           '/'                    '../..'
    '/u"'               '/u"'                  '.'
    '/'                 '/u"'                  'u"'
    '/u"'               '/'                    '..'
    '/u /dir'           '/u /dir'              '.'
    '/u '               '/u /dir'              'dir'
    '/u /dir'           '/u '                  '..'
    '/'                 '/u /dir'              'u /dir'
    '/u /dir'           '/'                    '../..'
    '/u '               '/u '                  '.'
    '/'                 '/u '                  'u '
    '/u '               '/'                    '..'
    '/u\n/dir'          '/u\n/dir'             '.'
    '/u\n'              '/u\n/dir'             'dir'
    '/u\n/dir'          '/u\n'                 '..'
    '/'                 '/u\n/dir'             'u\n/dir'
    '/u\n/dir'          '/'                    '../..'
    '/u\n'              '/u\n'                 '.'
    '/'                 '/u\n'                 'u\n'
    '/u\n'              '/'                    '..'

    '/    a   b/å/⮀*/!' '/    a   b/å/⮀/xäå/?' '../../⮀/xäå/?'
    '/'                 '/A'                   'A'
    '/A'                '/'                    '..'
    '/  & /  !/*/\\/E'  '/'                    '../../../../..'
    '/'                 '/  & /  !/*/\\/E'     '  & /  !/*/\\/E'
    '/  & /  !/*/\\/E'  '/  & /  !/?/\\/E/F'   '../../../?/\\/E/F'
    '/X/Y'              '/  & /  !/C/\\/E/F'   '../../  & /  !/C/\\/E/F'
    '/  & /  !/C'       '/A'                   '../../../A'
    '/A /  !/C'         '/A /B'                '../../B'
    '/Â/  !/C'          '/Â/  !/C'             '.'
    '/  & /B / C'       '/  & /B / C/D'        'D'
    '/  & /  !/C'       '/  & /  !/C/\\/Ê'     '\\/Ê'
    '/Å/  !/C'          '/Å/  !/D'             '../D'
    '/.A /*B/C'         '/.A /*B/\\/E'         '../\\/E'
    '/  & /  !/C'       '/  & /D'              '../../D'
    '/  & /  !/C'       '/  & /\\/E'           '../../\\/E'
    '/  & /  !/C'       '/\\/E/F'              '../../../\\/E/F'
    '/home/p1/p2'       '/home/p1/p3'          '../p3'
    '/home/p1/p2'       '/home/p4/p5'          '../../p4/p5'
    '/home/p1/p2'       '/work/p6/p7'          '../../../work/p6/p7'
    '/home/p1'          '/work/p1/p2/p3/p4'    '../../work/p1/p2/p3/p4'
    '/home'             '/work/p2/p3'          '../work/p2/p3'
    '/'                 '/work/p2/p3/p4'       'work/p2/p3/p4'
    '/home/p1/p2'       '/home/p1/p2/p3/p4'    'p3/p4'
    '/home/p1/p2'       '/home/p1/p2/p3'       'p3'
    '/home/p1/p2'       '/home/p1/p2'          '.'
    '/home/p1/p2'       '/home/p1'             '..'
    '/home/p1/p2'       '/home'                '../..'
    '/home/p1/p2'       '/'                    '../../..'
    '/home/p1/p2'       '/work'                '../../../work'
    '/home/p1/p2'       '/work/p1'             '../../../work/p1'
    '/home/p1/p2'       '/work/p1/p2'          '../../../work/p1/p2'
    '/home/p1/p2'       '/work/p1/p2/p3'       '../../../work/p1/p2/p3'
    '/home/p1/p2'       '/work/p1/p2/p3/p4'    '../../../work/p1/p2/p3/p4'

    '/-'                '/-'                   '.'
    '/?'                '/?'                   '.'
    '/??'               '/??'                  '.'
    '/???'              '/???'                 '.'
    '/?*'               '/?*'                  '.'
    '/*'                '/*'                   '.'
    '/*'                '/**'                  '../**'
    '/*'                '/***'                 '../***'
    '/*.*'              '/*.**'                '../*.**'
    '/*.???'            '/*.??'                '../*.??'
    '/[]'               '/[]'                  '.'
    '/[a-z]*'           '/[0-9]*'              '../[0-9]*'
EOF


format="\t%-19s %-22s %-27s %-8s %-8s\n"
printf "\n\n*** Testing own and python's function with arbitrary dirs\n\n"
printf "$format\n" \
    "From Directory" "To Directory" "Rel. Path" "relpath" "python"
IFS=
while read -r p; do
    eval set -- $p
    case $1 in '#'*|'') continue;; esac # Skip comments and empty lines
    # q stores quoting character, use " if ' is used in path name
    q="'"; case $1$2 in *"'"*) q='"';; esac
    rpOk=passed rp=$(relpath "$1" "$2"); test "$rp" = "$3" || rpOk=$rp
    RPOk=passed
    RP=$(python -c "import os.path; print os.path.relpath($q$2$q, $q$1$q)")
    test "$RP" = "$3" || RPOk=$RP
    printf "$format" "$q$1$q" "$q$2$q" "$q$3$q" "$q$rpOk$q" "$q$RPOk$q"
done <<-"EOF"
    # From directory    To directory           Expected relative path

    'usr/p1/..//./p4'   'p3/../p1/p6/.././/p2' '../../p1/p2'
    './home/../../work' '..//././../dir///'    '../../dir'

    'home/p1/p2'        'home/p1/p3'           '../p3'
    'home/p1/p2'        'home/p4/p5'           '../../p4/p5'
    'home/p1/p2'        'work/p6/p7'           '../../../work/p6/p7'
    'home/p1'           'work/p1/p2/p3/p4'     '../../work/p1/p2/p3/p4'
    'home'              'work/p2/p3'           '../work/p2/p3'
    '.'                 'work/p2/p3'           'work/p2/p3'
    'home/p1/p2'        'home/p1/p2/p3/p4'     'p3/p4'
    'home/p1/p2'        'home/p1/p2/p3'        'p3'
    'home/p1/p2'        'home/p1/p2'           '.'
    'home/p1/p2'        'home/p1'              '..'
    'home/p1/p2'        'home'                 '../..'
    'home/p1/p2'        '.'                    '../../..'
    'home/p1/p2'        'work'                 '../../../work'
    'home/p1/p2'        'work/p1'              '../../../work/p1'
    'home/p1/p2'        'work/p1/p2'           '../../../work/p1/p2'
    'home/p1/p2'        'work/p1/p2/p3'        '../../../work/p1/p2/p3'
    'home/p1/p2'        'work/p1/p2/p3/p4'     '../../../work/p1/p2/p3/p4'
EOF

【讨论】：

【解决方案15】：

Python 的 `os.path.relpath` 作为 shell 函数

这个relpath 练习的目标是模仿xni 提出的Python 2.7 的os.path.relpath 函数（可从Python 2.6 版获得，但只能在2.7 中正常工作）。因此，某些结果可能与其他答案中提供的函数不同。

（我没有在路径中使用换行符进行测试，仅仅是因为它破坏了基于从 ZSH 调用 python -c 的验证。通过一些努力当然可以。）

关于 Bash 中的“魔法”，我很久以前就放弃了在 Bash 中寻找魔法，但后来我在 ZSH 中找到了我需要的所有魔法，然后还有一些。

因此，我提出了两种实现方式。

第一个实现旨在完全POSIX 兼容。我已经在 Debian 6.0.6 “Squeeze” 上使用 /bin/dash 对其进行了测试。它还可以与 OS X 10.8.3 上的 /bin/sh 完美配合，这实际上是伪装成 POSIX shell 的 Bash 版本 3.2。

第二个实现是一个 ZSH shell 函数，它对路径中的多个斜杠和其他麻烦具有鲁棒性。如果您有可用的 ZSH，这是推荐的版本，即使您是从另一个 shell 以下面提供的脚本形式（即使用 #!/usr/bin/env zsh 的 shebang）调用它。

最后，我编写了一个 ZSH 脚本，根据其他答案中提供的测试用例，验证 $PATH 中的 relpath 命令的输出。我在这里和那里添加了一些空格、制表符和标点符号（例如! ? *），为这些测试添加了一些趣味，还使用vim-powerline 中的奇异UTF-8 字符进行了另一个测试。

POSIX shell 函数

首先，符合 POSIX 的 shell 函数。它适用于各种路径，但不能清除多个斜杠或解析符号链接。

#!/bin/sh
relpath () {
    [ $# -ge 1 ] && [ $# -le 2 ] || return 1
    current="${2:+"$1"}"
    target="${2:-"$1"}"
    [ "$target" != . ] || target=/
    target="/${target##/}"
    [ "$current" != . ] || current=/
    current="${current:="/"}"
    current="/${current##/}"
    appendix="${target##/}"
    relative=''
    while appendix="${target#"$current"/}"
        [ "$current" != '/' ] && [ "$appendix" = "$target" ]; do
        if [ "$current" = "$appendix" ]; then
            relative="${relative:-.}"
            echo "${relative#/}"
            return 0
        fi
        current="${current%/*}"
        relative="$relative${relative:+/}.."
    done
    relative="$relative${relative:+${appendix:+/}}${appendix#/}"
    echo "$relative"
}
relpath "$@"

ZSH shell 函数

现在，更强大的zsh 版本。如果您希望它将参数解析为真实路径 à la realpath -f（在 Linux coreutils 包中可用），请将第 3 行和第 4 行的 :a 替换为 :A。

要在 zsh 中使用它，请删除第一行和最后一行并将其放在您的 $FPATH 变量中的目录中。

#!/usr/bin/env zsh
relpath () {
    [[ $# -ge 1 ]] && [[ $# -le 2 ]] || return 1
    local target=${${2:-$1}:a} # replace `:a' by `:A` to resolve symlinks
    local current=${${${2:+$1}:-$PWD}:a} # replace `:a' by `:A` to resolve symlinks
    local appendix=${target#/}
    local relative=''
    while appendix=${target#$current/}
        [[ $current != '/' ]] && [[ $appendix = $target ]]; do
        if [[ $current = $appendix ]]; then
            relative=${relative:-.}
            print ${relative#/}
            return 0
        fi
        current=${current%/*}
        relative="$relative${relative:+/}.."
    done
    relative+=${relative:+${appendix:+/}}${appendix#/}
    print $relative
}
relpath "$@"

测试脚本

最后是测试脚本。它接受一个选项，即-v 来启用详细输出。

#!/usr/bin/env zsh
set -eu
VERBOSE=false
script_name=$(basename $0)

usage () {
    print "\n    Usage: $script_name SRC_PATH DESTINATION_PATH\n" >&2
    exit ${1:=1}
}
vrb () { $VERBOSE && print -P ${(%)@} || return 0; }

relpath_check () {
    [[ $# -ge 1 ]] && [[ $# -le 2 ]] || return 1
    target=${${2:-$1}}
    prefix=${${${2:+$1}:-$PWD}}
    result=$(relpath $prefix $target)
    # Compare with python's os.path.relpath function
    py_result=$(python -c "import os.path; print os.path.relpath('$target', '$prefix')")
    col='%F{green}'
    if [[ $result != $py_result ]] && col='%F{red}' || $VERBOSE; then
        print -P "${col}Source: '$prefix'\nDestination: '$target'%f"
        print -P "${col}relpath: ${(qq)result}%f"
        print -P "${col}python:  ${(qq)py_result}%f\n"
    fi
}

run_checks () {
    print "Running checks..."

    relpath_check '/    a   b/å/⮀*/!' '/    a   b/å/⮀/xäå/?'

    relpath_check '/'  '/A'
    relpath_check '/A'  '/'
    relpath_check '/  & /  !/*/\\/E' '/'
    relpath_check '/' '/  & /  !/*/\\/E'
    relpath_check '/  & /  !/*/\\/E' '/  & /  !/?/\\/E/F'
    relpath_check '/X/Y' '/  & /  !/C/\\/E/F'
    relpath_check '/  & /  !/C' '/A'
    relpath_check '/A /  !/C' '/A /B'
    relpath_check '/Â/  !/C' '/Â/  !/C'
    relpath_check '/  & /B / C' '/  & /B / C/D'
    relpath_check '/  & /  !/C' '/  & /  !/C/\\/Ê'
    relpath_check '/Å/  !/C' '/Å/  !/D'
    relpath_check '/.A /*B/C' '/.A /*B/\\/E'
    relpath_check '/  & /  !/C' '/  & /D'
    relpath_check '/  & /  !/C' '/  & /\\/E'
    relpath_check '/  & /  !/C' '/\\/E/F'

    relpath_check /home/part1/part2 /home/part1/part3
    relpath_check /home/part1/part2 /home/part4/part5
    relpath_check /home/part1/part2 /work/part6/part7
    relpath_check /home/part1       /work/part1/part2/part3/part4
    relpath_check /home             /work/part2/part3
    relpath_check /                 /work/part2/part3/part4
    relpath_check /home/part1/part2 /home/part1/part2/part3/part4
    relpath_check /home/part1/part2 /home/part1/part2/part3
    relpath_check /home/part1/part2 /home/part1/part2
    relpath_check /home/part1/part2 /home/part1
    relpath_check /home/part1/part2 /home
    relpath_check /home/part1/part2 /
    relpath_check /home/part1/part2 /work
    relpath_check /home/part1/part2 /work/part1
    relpath_check /home/part1/part2 /work/part1/part2
    relpath_check /home/part1/part2 /work/part1/part2/part3
    relpath_check /home/part1/part2 /work/part1/part2/part3/part4 
    relpath_check home/part1/part2 home/part1/part3
    relpath_check home/part1/part2 home/part4/part5
    relpath_check home/part1/part2 work/part6/part7
    relpath_check home/part1       work/part1/part2/part3/part4
    relpath_check home             work/part2/part3
    relpath_check .                work/part2/part3
    relpath_check home/part1/part2 home/part1/part2/part3/part4
    relpath_check home/part1/part2 home/part1/part2/part3
    relpath_check home/part1/part2 home/part1/part2
    relpath_check home/part1/part2 home/part1
    relpath_check home/part1/part2 home
    relpath_check home/part1/part2 .
    relpath_check home/part1/part2 work
    relpath_check home/part1/part2 work/part1
    relpath_check home/part1/part2 work/part1/part2
    relpath_check home/part1/part2 work/part1/part2/part3
    relpath_check home/part1/part2 work/part1/part2/part3/part4

    print "Done with checks."
}
if [[ $# -gt 0 ]] && [[ $1 = "-v" ]]; then
    VERBOSE=true
    shift
fi
if [[ $# -eq 0 ]]; then
    run_checks
else
    VERBOSE=true
    relpath_check "$@"
fi

【讨论】：

恐怕第一条路径以/结尾时不起作用。

【解决方案16】：

我只会使用 Perl 来完成这个不那么简单的任务：

absolute="/foo/bar"
current="/foo/baz/foo"

# Perl is magic
relative=$(perl -MFile::Spec -e 'print File::Spec->abs2rel("'$absolute'","'$current'")')

【讨论】：

+1，但建议：perl -MFile::Spec -e "print File::Spec->abs2rel('$absolute','$current')" 以便引用绝对值和当前值。
我喜欢relative=$(perl -MFile::Spec -e 'print File::Spec->abs2rel(@ARGV)' "$absolute" "$current")。这确保了值本身不能包含 perl 代码！

【解决方案17】：

猜猜这个也可以解决问题...（带有内置测试）:)

好的，预计会有一些开销，但我们在这里使用 Bourne shell！ ;)

#!/bin/sh

#
# Finding the relative path to a certain file ($2), given the absolute path ($1)
# (available here too http://pastebin.com/tWWqA8aB)
#
relpath () {
  local  FROM="$1"
  local    TO="`dirname  $2`"
  local  FILE="`basename $2`"
  local  DEBUG="$3"

  local FROMREL=""
  local FROMUP="$FROM"
  while [ "$FROMUP" != "/" ]; do
    local TOUP="$TO"
    local TOREL=""
    while [ "$TOUP" != "/" ]; do
      [ -z "$DEBUG" ] || echo 1>&2 "$DEBUG$FROMUP =?= $TOUP"
      if [ "$FROMUP" = "$TOUP" ]; then
        echo "${FROMREL:-.}/$TOREL${TOREL:+/}$FILE"
        return 0
      fi
      TOREL="`basename $TOUP`${TOREL:+/}$TOREL"
      TOUP="`dirname $TOUP`"
    done
    FROMREL="..${FROMREL:+/}$FROMREL"
    FROMUP="`dirname $FROMUP`"
  done
  echo "${FROMREL:-.}${TOREL:+/}$TOREL/$FILE"
  return 0
}

relpathshow () {
  echo " - target $2"
  echo "   from   $1"
  echo "   ------"
  echo "   => `relpath $1 $2 '      '`"
  echo ""
}

# If given 2 arguments, do as said...
if [ -n "$2" ]; then
  relpath $1 $2

# If only one given, then assume current directory
elif [ -n "$1" ]; then
  relpath `pwd` $1

# Otherwise perform a set of built-in tests to confirm the validity of the method! ;)
else

  relpathshow /usr/share/emacs22/site-lisp/emacs-goodies-el \
              /usr/share/emacs22/site-lisp/emacs-goodies-el/filladapt.el

  relpathshow /usr/share/emacs23/site-lisp/emacs-goodies-el \
              /usr/share/emacs22/site-lisp/emacs-goodies-el/filladapt.el

  relpathshow /usr/bin \
              /usr/share/emacs22/site-lisp/emacs-goodies-el/filladapt.el

  relpathshow /usr/bin \
              /usr/share/emacs22/site-lisp/emacs-goodies-el/filladapt.el

  relpathshow /usr/bin/share/emacs22/site-lisp/emacs-goodies-el \
              /etc/motd

  relpathshow / \
              /initrd.img
fi

【讨论】：

【解决方案18】：

我的解决方案：

computeRelativePath() 
{

    Source=$(readlink -f ${1})
    Target=$(readlink -f ${2})

    local OLDIFS=$IFS
    IFS="/"

    local SourceDirectoryArray=($Source)
    local TargetDirectoryArray=($Target)

    local SourceArrayLength=$(echo ${SourceDirectoryArray[@]} | wc -w)
    local TargetArrayLength=$(echo ${TargetDirectoryArray[@]} | wc -w)

    local Length
    test $SourceArrayLength -gt $TargetArrayLength && Length=$SourceArrayLength || Length=$TargetArrayLength


    local Result=""
    local AppendToEnd=""

    IFS=$OLDIFS

    local i

    for ((i = 0; i <= $Length + 1 ; i++ ))
    do
            if [ "${SourceDirectoryArray[$i]}" = "${TargetDirectoryArray[$i]}" ]
            then
                continue    
            elif [ "${SourceDirectoryArray[$i]}" != "" ] && [ "${TargetDirectoryArray[$i]}" != "" ] 
            then
                AppendToEnd="${AppendToEnd}${TargetDirectoryArray[${i}]}/"
                Result="${Result}../"               

            elif [ "${SourceDirectoryArray[$i]}" = "" ]
            then
                Result="${Result}${TargetDirectoryArray[${i}]}/"
            else
                Result="${Result}../"
            fi
    done

    Result="${Result}${AppendToEnd}"

    echo $Result

}

【讨论】：

这是非常便携的:)

【解决方案19】：

这是一个无需调用其他程序即可执行此操作的 shell 脚本：

#! /bin/env bash 

#bash script to find the relative path between two directories

mydir=${0%/}
mydir=${0%/*}
creadlink="$mydir/creadlink"

shopt -s extglob

relpath_ () {
        path1=$("$creadlink" "$1")
        path2=$("$creadlink" "$2")
        orig1=$path1
        path1=${path1%/}/
        path2=${path2%/}/

        while :; do
                if test ! "$path1"; then
                        break
                fi
                part1=${path2#$path1}
                if test "${part1#/}" = "$part1"; then
                        path1=${path1%/*}
                        continue
                fi
                if test "${path2#$path1}" = "$path2"; then
                        path1=${path1%/*}
                        continue
                fi
                break
        done
        part1=$path1
        path1=${orig1#$part1}
        depth=${path1//+([^\/])/..}
        path1=${path2#$path1}
        path1=${depth}${path2#$part1}
        path1=${path1##+(\/)}
        path1=${path1%/}
        if test ! "$path1"; then
                path1=.
        fi
        printf "$path1"

}

relpath_test () {
        res=$(relpath_ /path1/to/dir1 /path1/to/dir2 )
        expected='../dir2'
        test_results "$res" "$expected"

        res=$(relpath_ / /path1/to/dir2 )
        expected='path1/to/dir2'
        test_results "$res" "$expected"

        res=$(relpath_ /path1/to/dir2 / )
        expected='../../..'
        test_results "$res" "$expected"

        res=$(relpath_ / / )
        expected='.'
        test_results "$res" "$expected"

        res=$(relpath_ /path/to/dir2/dir3 /path/to/dir1/dir4/dir4a )
        expected='../../dir1/dir4/dir4a'
        test_results "$res" "$expected"

        res=$(relpath_ /path/to/dir1/dir4/dir4a /path/to/dir2/dir3 )
        expected='../../../dir2/dir3'
        test_results "$res" "$expected"

        #res=$(relpath_ . /path/to/dir2/dir3 )
        #expected='../../../dir2/dir3'
        #test_results "$res" "$expected"
}

test_results () {
        if test ! "$1" = "$2"; then
                printf 'failed!\nresult:\nX%sX\nexpected:\nX%sX\n\n' "$@"
        fi
}

#relpath_test

来源：http://www.ynform.org/w/Pub/Relpath

【讨论】：

由于使用了 ${param/pattern/subst} 构造，这不是真正可移植的，它不是 POSIX（截至 2011 年）。
引用的源 ynform.org/w/Pub/Relpath 指向一个完全乱码的 wiki 页面，其中多次包含脚本内容，其中夹杂着 vi 波浪线、有关未找到命令的错误消息等等。对于研究原著的人来说完全没用。

【解决方案20】：

我把你的问题当作一个挑战，用“便携式”shell代码编写这个，即

考虑到 POSIX shell
没有诸如数组之类的 bashism
避免像瘟疫一样调用外部。脚本中没有一个分叉！这使得它的速度非常快，尤其是在具有大量分叉开销的系统上，例如 cygwin。
必须处理路径名中的全局字符（*、?、[、]）

它可以在任何符合 POSIX 标准的 shell（zsh、bash、ksh、ash、busybox 等）上运行。它甚至包含一个测试套件来验证其操作。路径名的规范化留作练习。 :-)

#!/bin/sh

# Find common parent directory path for a pair of paths.
# Call with two pathnames as args, e.g.
# commondirpart foo/bar foo/baz/bat -> result="foo/"
# The result is either empty or ends with "/".
commondirpart () {
   result=""
   while test ${#1} -gt 0 -a ${#2} -gt 0; do
      if test "${1%${1#?}}" != "${2%${2#?}}"; then   # First characters the same?
         break                                       # No, we're done comparing.
      fi
      result="$result${1%${1#?}}"                    # Yes, append to result.
      set -- "${1#?}" "${2#?}"                       # Chop first char off both strings.
   done
   case "$result" in
   (""|*/) ;;
   (*)     result="${result%/*}/";;
   esac
}

# Turn foo/bar/baz into ../../..
#
dir2dotdot () {
   OLDIFS="$IFS" IFS="/" result=""
   for dir in $1; do
      result="$result../"
   done
   result="${result%/}"
   IFS="$OLDIFS"
}

# Call with FROM TO args.
relativepath () {
   case "$1" in
   (*//*|*/./*|*/../*|*?/|*/.|*/..)
      printf '%s\n' "'$1' not canonical"; exit 1;;
   (/*)
      from="${1#?}";;
   (*)
      printf '%s\n' "'$1' not absolute"; exit 1;;
   esac
   case "$2" in
   (*//*|*/./*|*/../*|*?/|*/.|*/..)
      printf '%s\n' "'$2' not canonical"; exit 1;;
   (/*)
      to="${2#?}";;
   (*)
      printf '%s\n' "'$2' not absolute"; exit 1;;
   esac

   case "$to" in
   ("$from")   # Identical directories.
      result=".";;
   ("$from"/*) # From /x to /x/foo/bar -> foo/bar
      result="${to##$from/}";;
   ("")        # From /foo/bar to / -> ../..
      dir2dotdot "$from";;
   (*)
      case "$from" in
      ("$to"/*)       # From /x/foo/bar to /x -> ../..
         dir2dotdot "${from##$to/}";;
      (*)             # Everything else.
         commondirpart "$from" "$to"
         common="$result"
         dir2dotdot "${from#$common}"
         result="$result/${to#$common}"
      esac
      ;;
   esac
}

set -f # noglob

set -x
cat <<EOF |
/ / .
/- /- .
/? /? .
/?? /?? .
/??? /??? .
/?* /?* .
/* /* .
/* /** ../**
/* /*** ../***
/*.* /*.** ../*.**
/*.??? /*.?? ../*.??
/[] /[] .
/[a-z]* /[0-9]* ../[0-9]*
/foo /foo .
/foo / ..
/foo/bar / ../..
/foo/bar /foo ..
/foo/bar /foo/baz ../baz
/foo/bar /bar/foo  ../../bar/foo
/foo/bar/baz /gnarf/blurfl/blubb ../../../gnarf/blurfl/blubb
/foo/bar/baz /gnarf ../../../gnarf
/foo/bar/baz /foo/baz ../../baz
/foo. /bar. ../bar.
EOF
while read FROM TO VIA; do
   relativepath "$FROM" "$TO"
   printf '%s\n' "FROM: $FROM" "TO:   $TO" "VIA:  $result"
   if test "$result" != "$VIA"; then
      printf '%s\n' "OOOPS! Expected '$VIA' but got '$result'"
   fi
done

# vi: set tabstop=3 shiftwidth=3 expandtab fileformat=unix :

【讨论】：

【解决方案21】：

此脚本仅对绝对路径或没有. 或.. 的相对路径的输入给出正确结果：

#!/bin/bash

# usage: relpath from to

if [[ "$1" == "$2" ]]
then
    echo "."
    exit
fi

IFS="/"

current=($1)
absolute=($2)

abssize=${#absolute[@]}
cursize=${#current[@]}

while [[ ${absolute[level]} == ${current[level]} ]]
do
    (( level++ ))
    if (( level > abssize || level > cursize ))
    then
        break
    fi
done

for ((i = level; i < cursize; i++))
do
    if ((i > level))
    then
        newpath=$newpath"/"
    fi
    newpath=$newpath".."
done

for ((i = level; i < abssize; i++))
do
    if [[ -n $newpath ]]
    then
        newpath=$newpath"/"
    fi
    newpath=$newpath${absolute[i]}
done

echo "$newpath"

【讨论】：

这似乎有效。如果目录确实存在，则在输入上使用 $(readlink -f $1) 和 $(readlink -f $2) 可以解决“。”的问题。或“..”出现在输入中。如果目录实际上不存在，这可能会导致一些麻烦。

【解决方案22】：

#!/bin/bash
# both $1 and $2 are absolute paths
# returns $2 relative to $1

source=$1
target=$2

common_part=$source
back=
while [ "${target#$common_part}" = "${target}" ]; do
  common_part=$(dirname $common_part)
  back="../${back}"
done

echo ${back}${target#$common_part/}

【讨论】：

精彩的脚本——短而干净。我应用了一个编辑（等待同行评审）：common_part=$source/common_part=$(dirname $common_part)/echo ${back}${target#$common_part} 由于目录名称开头的不适当匹配，现有脚本将失败比较时，例如：“/foo/bar/baz”与“/foo/barsucks/bonk”。将斜杠移入 var 并移出最终 eval 可纠正该错误。
这个脚本根本不起作用。一个简单的“一个目录下”测试失败。 jcwenger 的编辑效果更好一些，但往往会添加一个额外的“../”。
如果参数上有尾随的“/”，在某些情况下对我来说会失败；例如，如果 $1="$HOME/" 和 $2="$HOME/temp"，则返回“/home/user/temp/”，但如果 $1=$HOME，则正确返回相对路径“temp”。因此 source=$1 和 target=$2 都可以使用 sed （或使用 bash 变量替换，但这可能是不必要的不透明）“清理”，例如 => source=$(echo "${1}" | sed 's/ \/*$//')
小改进：不要直接将源/目标设置为 $1 和 $2，而是执行：source=$(cd $1; pwd) target=$(cd $2; pwd)。这样它处理带有 .和..正确。
尽管是投票最多的答案，但这个答案有很多限制，因此发布了许多其他答案。请参阅其他答案，尤其是显示测试用例的答案。请为这条评论点赞！

【解决方案23】：

test.sh:

#!/bin/bash                                                                 

cd /home/ubuntu
touch blah
TEST=/home/ubuntu/.//blah
echo TEST=$TEST
TMP=$(readlink -e "$TEST")
echo TMP=$TMP
REL=${TMP#$(pwd)/}
echo REL=$REL

测试：

$ ./test.sh 
TEST=/home/ubuntu/.//blah
TMP=/home/ubuntu/blah
REL=blah

【讨论】：

+1 表示紧凑和 bash-ness。但是，您也应该在$(pwd) 上致电readlink。
相对并不意味着文件必须放在同一目录中。
虽然最初的问题没有提供很多测试用例，但是这个脚本对于简单的测试失败了，比如找到从 /home/user1 到 /home/user2 的相对路径（正确答案：../user2 )。 pini/jcwenger 的脚本适用于这种情况。

【解决方案24】：

遗憾的是，Mark Rushakoff 的答案（现已删除 - 它引用了来自 here 的代码）在适应以下情况时似乎无法正常工作：

source=/home/part2/part3/part4
target=/work/proj1/proj2

评论中概述的想法可以改进，使其在大多数情况下都能正常工作。我将假设脚本接受一个源参数（你在哪里）和一个目标参数（你想去哪里），并且要么都是绝对路径名，要么都是相对的。如果一个是绝对的，另一个是相对的，最简单的方法是在相对名称前面加上当前工作目录 - 但下面的代码没有这样做。

小心

下面的代码接近于正常工作，但并不完全正确。

Dennis Williamson 的 cmets 解决了这个问题。
还有一个问题是，这种纯粹的路径名文本处理可能会被奇怪的符号链接严重搞砸。
代码不处理路径中的杂散“点”，例如“xyz/./pqr”。
代码不处理路径中的杂散“双点”，如“xyz/../pqr”。
简单地说：代码不会从路径中删除前导“./”。

Dennis 的代码更好，因为它修复了 1 和 5 - 但有相同的问题 2、3、4。因此，请使用丹尼斯的代码（并在此之前对其进行投票）。

（注意：POSIX 提供了一个系统调用realpath() 来解析路径名，以便其中没有符号链接。将其应用于输入名称，然后使用丹尼斯的代码每次都会给出正确的答案。这很简单编写包装 realpath() 的 C 代码 - 我已经完成了 - 但我不知道这样做的标准实用程序。）

为此，我发现 Perl 比 shell 更易于使用，尽管 bash 对数组有很好的支持并且可能也可以做到这一点 - 为读者练习。因此，给定两个兼容的名称，将它们分别拆分为组件：

将相对路径设置为空。
虽然组件相同，但请跳至下一个。
当对应的组件不同或一条路径没有更多组件时：
如果没有剩余的源组件且相对路径为空，则添加“.”从头开始。
对于每个剩余的源组件，在相对路径前加上“../”前缀。
如果没有剩余目标组件且相对路径为空，则添加“.”从头开始。
对于每个剩余的目标组件，将组件添加到路径末尾的斜杠之后。

因此：

#!/bin/perl -w

use strict;

# Should fettle the arguments if one is absolute and one relative:
# Oops - missing functionality!

# Split!
my(@source) = split '/', $ARGV[0];
my(@target) = split '/', $ARGV[1];

my $count = scalar(@source);
   $count = scalar(@target) if (scalar(@target) < $count);
my $relpath = "";

my $i;
for ($i = 0; $i < $count; $i++)
{
    last if $source[$i] ne $target[$i];
}

$relpath = "." if ($i >= scalar(@source) && $relpath eq "");
for (my $s = $i; $s < scalar(@source); $s++)
{
    $relpath = "../$relpath";
}
$relpath = "." if ($i >= scalar(@target) && $relpath eq "");
for (my $t = $i; $t < scalar(@target); $t++)
{
    $relpath .= "/$target[$t]";
}

# Clean up result (remove double slash, trailing slash, trailing slash-dot).
$relpath =~ s%//%/%;
$relpath =~ s%/$%%;
$relpath =~ s%/\.$%%;

print "source  = $ARGV[0]\n";
print "target  = $ARGV[1]\n";
print "relpath = $relpath\n";

测试脚本（方括号包含一个空格和一个制表符）：

sed 's/#.*//;/^[    ]*$/d' <<! |

/home/part1/part2 /home/part1/part3
/home/part1/part2 /home/part4/part5
/home/part1/part2 /work/part6/part7
/home/part1       /work/part1/part2/part3/part4
/home             /work/part2/part3
/                 /work/part2/part3/part4

/home/part1/part2 /home/part1/part2/part3/part4
/home/part1/part2 /home/part1/part2/part3
/home/part1/part2 /home/part1/part2
/home/part1/part2 /home/part1
/home/part1/part2 /home
/home/part1/part2 /

/home/part1/part2 /work
/home/part1/part2 /work/part1
/home/part1/part2 /work/part1/part2
/home/part1/part2 /work/part1/part2/part3
/home/part1/part2 /work/part1/part2/part3/part4

home/part1/part2 home/part1/part3
home/part1/part2 home/part4/part5
home/part1/part2 work/part6/part7
home/part1       work/part1/part2/part3/part4
home             work/part2/part3
.                work/part2/part3

home/part1/part2 home/part1/part2/part3/part4
home/part1/part2 home/part1/part2/part3
home/part1/part2 home/part1/part2
home/part1/part2 home/part1
home/part1/part2 home
home/part1/part2 .

home/part1/part2 work
home/part1/part2 work/part1
home/part1/part2 work/part1/part2
home/part1/part2 work/part1/part2/part3
home/part1/part2 work/part1/part2/part3/part4

!

while read source target
do
    perl relpath.pl $source $target
    echo
done

测试脚本的输出：

source  = /home/part1/part2
target  = /home/part1/part3
relpath = ../part3

source  = /home/part1/part2
target  = /home/part4/part5
relpath = ../../part4/part5

source  = /home/part1/part2
target  = /work/part6/part7
relpath = ../../../work/part6/part7

source  = /home/part1
target  = /work/part1/part2/part3/part4
relpath = ../../work/part1/part2/part3/part4

source  = /home
target  = /work/part2/part3
relpath = ../work/part2/part3

source  = /
target  = /work/part2/part3/part4
relpath = ./work/part2/part3/part4

source  = /home/part1/part2
target  = /home/part1/part2/part3/part4
relpath = ./part3/part4

source  = /home/part1/part2
target  = /home/part1/part2/part3
relpath = ./part3

source  = /home/part1/part2
target  = /home/part1/part2
relpath = .

source  = /home/part1/part2
target  = /home/part1
relpath = ..

source  = /home/part1/part2
target  = /home
relpath = ../..

source  = /home/part1/part2
target  = /
relpath = ../../../..

source  = /home/part1/part2
target  = /work
relpath = ../../../work

source  = /home/part1/part2
target  = /work/part1
relpath = ../../../work/part1

source  = /home/part1/part2
target  = /work/part1/part2
relpath = ../../../work/part1/part2

source  = /home/part1/part2
target  = /work/part1/part2/part3
relpath = ../../../work/part1/part2/part3

source  = /home/part1/part2
target  = /work/part1/part2/part3/part4
relpath = ../../../work/part1/part2/part3/part4

source  = home/part1/part2
target  = home/part1/part3
relpath = ../part3

source  = home/part1/part2
target  = home/part4/part5
relpath = ../../part4/part5

source  = home/part1/part2
target  = work/part6/part7
relpath = ../../../work/part6/part7

source  = home/part1
target  = work/part1/part2/part3/part4
relpath = ../../work/part1/part2/part3/part4

source  = home
target  = work/part2/part3
relpath = ../work/part2/part3

source  = .
target  = work/part2/part3
relpath = ../work/part2/part3

source  = home/part1/part2
target  = home/part1/part2/part3/part4
relpath = ./part3/part4

source  = home/part1/part2
target  = home/part1/part2/part3
relpath = ./part3

source  = home/part1/part2
target  = home/part1/part2
relpath = .

source  = home/part1/part2
target  = home/part1
relpath = ..

source  = home/part1/part2
target  = home
relpath = ../..

source  = home/part1/part2
target  = .
relpath = ../../..

source  = home/part1/part2
target  = work
relpath = ../../../work

source  = home/part1/part2
target  = work/part1
relpath = ../../../work/part1

source  = home/part1/part2
target  = work/part1/part2
relpath = ../../../work/part1/part2

source  = home/part1/part2
target  = work/part1/part2/part3
relpath = ../../../work/part1/part2/part3

source  = home/part1/part2
target  = work/part1/part2/part3/part4
relpath = ../../../work/part1/part2/part3/part4

面对奇怪的输入，这个 Perl 脚本在 Unix 上运行得相当彻底（它没有考虑 Windows 路径名的所有复杂性）。它使用模块Cwd 及其函数realpath 来解析存在的名称的真实路径，并对不存在的路径进行文本分析。除一种情况外，在所有情况下，它都会产生与 Dennis 的脚本相同的输出。异常情况是：

source   = home/part1/part2
target   = .
relpath1 = ../../..
relpath2 = ../../../.

这两个结果是等价的——只是不相同。（输出来自测试脚本的轻微修改版本 - 下面的 Perl 脚本只是打印答案，而不是上面脚本中的输入和答案。）现在：我应该消除无效的答案?也许……

#!/bin/perl -w
# Based loosely on code from: http://unix.derkeiler.com/Newsgroups/comp.unix.shell/2005-10/1256.html
# Via: http://stackoverflow.com/questions/2564634

use strict;

die "Usage: $0 from to\n" if scalar @ARGV != 2;

use Cwd qw(realpath getcwd);

my $pwd;
my $verbose = 0;

# Fettle filename so it is absolute.
# Deals with '//', '/./' and '/../' notations, plus symlinks.
# The realpath() function does the hard work if the path exists.
# For non-existent paths, the code does a purely textual hack.
sub resolve
{
    my($name) = @_;
    my($path) = realpath($name);
    if (!defined $path)
    {
        # Path does not exist - do the best we can with lexical analysis
        # Assume Unix - not dealing with Windows.
        $path = $name;
        if ($name !~ m%^/%)
        {
            $pwd = getcwd if !defined $pwd;
            $path = "$pwd/$path";
        }
        $path =~ s%//+%/%g;     # Not UNC paths.
        $path =~ s%/$%%;        # No trailing /
        $path =~ s%/\./%/%g;    # No embedded /./
        # Try to eliminate /../abc/
        $path =~ s%/\.\./(?:[^/]+)(/|$)%$1%g;
        $path =~ s%/\.$%%;      # No trailing /.
        $path =~ s%^\./%%;      # No leading ./
        # What happens with . and / as inputs?
    }
    return($path);
}

sub print_result
{
    my($source, $target, $relpath) = @_;
    if ($verbose)
    {
        print "source  = $ARGV[0]\n";
        print "target  = $ARGV[1]\n";
        print "relpath = $relpath\n";
    }
    else
    {
        print "$relpath\n";
    }
    exit 0;
}

my($source) = resolve($ARGV[0]);
my($target) = resolve($ARGV[1]);
print_result($source, $target, ".") if ($source eq $target);

# Split!
my(@source) = split '/', $source;
my(@target) = split '/', $target;

my $count = scalar(@source);
   $count = scalar(@target) if (scalar(@target) < $count);
my $relpath = "";
my $i;

# Both paths are absolute; Perl splits an empty field 0.
for ($i = 1; $i < $count; $i++)
{
    last if $source[$i] ne $target[$i];
}

for (my $s = $i; $s < scalar(@source); $s++)
{
    $relpath = "$relpath/" if ($s > $i);
    $relpath = "$relpath..";
}
for (my $t = $i; $t < scalar(@target); $t++)
{
    $relpath = "$relpath/" if ($relpath ne "");
    $relpath = "$relpath$target[$t]";
}

print_result($source, $target, $relpath);

【讨论】：

您的/home/part1/part2 到/ 有一个太多../。否则，我的脚本与您的输出相匹配，除了我的脚本在目标为 . 的末尾添加了一个不必要的 . 并且我不在下降而不上升的开头使用 ./。
@Dennis：我花了很多时间对结果进行了斗鸡眼——有时我可以看到这个问题，有时我又找不到它。删除前导 './' 是另一个微不足道的步骤。您对“没有嵌入”的评论。或 ..' 也是相关的。正确地完成这项工作实际上非常困难 - 如果任何名称实际上是符号链接，则更是如此；我们都在做纯文本分析。
@Dennis：当然，除非你有 Newcastle Connection 网络，否则试图超越 root 是徒劳的，所以 ../../../.. 和 ../../..是等价的。然而，那是纯粹的逃避现实；你的批评是正确的。（Newcastle Connection 允许您配置和使用符号 /../host/path/on/remote/machine 来访问不同的主机 - 一个简洁的方案。我相信它支持 /../../network/host/ path/on/remote/network/and/host 也是。它在维基百科上。）
因此，我们现在有了 UNC 的双斜线。
“readlink”实用程序（至少是 GNU 版本）可以执行与 realpath() 等效的操作，如果您将“-f”选项传递给它。例如，在我的系统上，readlink /usr/bin/vi 提供 /etc/alternatives/vi，但这是另一个符号链接 - 而 readlink -f /usr/bin/vi 提供 /usr/bin/vim.basic，这是所有符号链接的最终目的地...

编辑因为不赞成投票跟随

Python 的 os.path.relpath 作为 shell 函数

POSIX shell 函数

ZSH shell 函数

测试脚本

小心

Python 的 `os.path.relpath` 作为 shell 函数