Bashを使用して現在のディレクトリを指定して絶対パスを相対パスに変換する


261

例:

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

# Magic

relative="../../bar"

マジックを作成するにはどうすればよいですか(できればコードが複雑すぎないようにしてください...)?


7
たとえば(私の場合は今のところ)gccに相対パスを指定して、ソースパスが変更されても使用可能な相対デバッグ情報を生成できるようにします。
Offirmo 2012

このような質問がU&Lで行われました:unix.stackexchange.com/questions/100918/…。答えの1つ(@Gilles)は、この問題を簡単に処理できるツールであるsymlinksについて言及しています。
slm 2013年

25
シンプル:realpath --relative-to=$absolute $current
kenorb

回答:


229

GNU coreutils 8.23のrealpathを使用するのが最も簡単だと思います。

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

例えば:

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

7
Ubuntu 14.04ではパッケージが古く、-relative-toオプションがないのは残念です。
kzh

3
Ubuntu 16.04で正常に動作します
cayhorstmann

7
$ realpath --relative-to="${PWD}" "$file"現在の作業ディレクトリからの相対パスが必要な場合に便利です。
dcoles

1
これは/usr/bin/nmap/-path 内の事柄には正しいですが、/usr/bin/nmapnmapto to は3回/tmp/testingではなく../../、それだけ../です。ただし、..rootfsで行うのはであるため、機能します/
Patrick B.

6
@PatrickBとして。暗黙的に--relative-to=…、ディレクトリを想定し、チェックしません。つまり、ファイルに対する相対パスを要求すると、余分な "../"が返されます(この例では、/usr/binディレクトリがほとんどまたはまったく含まれておらず、nmap通常はバイナリであるため)
IBBoard

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

与える:

../../bar

11
それは機能し、代替案はばかげて見えます。それは私にとってボーナスですxD
hasvn '19

31
+1。OK、あなたはだまされました...しかし、これはあまりにも良いので使用できません!relpath(){ python -c "import os.path; print os.path.relpath('$1','${2:-$PWD}')" ; }
MestreLion 2012

4
残念ながら、これは普遍的には利用できません。os.path.relpathはPython 2.6で新しく追加されました。
Chen Levy

15
@ChenLevy:Python 2.6は2008年にリリースされました。2012年に一般的に利用可能になるとは信じられませんでした
。– MestreLion

11
python -c 'import os, sys; print(os.path.relpath(*sys.argv[1:]))'最も自然かつ確実に動作します。
musiphil 2015

31

これは、@ 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"

1
LIB offirmoシェルで統合github.com/Offirmo/offirmo-shell-lib、機能«OSL_FILE_find_relative_path»(ファイル«osl_lib_file.sh»)
Offirmo

1
+1。簡単に交換することによって、任意のパス(/で始まるだけではなく、絶対パス)を処理させることができるsource=$1; target=$2source=$(realpath $1); target=$(realpath $2)
ジョッシュ・ケリー

2
@Joshは確かに、dirsが実際に存在するという条件で...単体テストには不便でした;)しかし、実際の使用でrealpathは、はい、推奨されsource=$(readlink -f $1)ます
。realpathが

私は次のように定義し$source$target好きです: `if [[-e $ 1]]; 次に、source = $(readlink -f $ 1); それ以外の場合、source = $ 1; fi if [[-e $ 2]]; 次にtarget = $(readlink -f $ 2); それ以外はtarget = $ 2; このようにして、関数は実際の/既存の相対パスや架空のディレクトリを処理できます。
Nathan S. Watson-Haigh、2014

1
@ NathanS.Watson-Haighさらに良いことに、私は最近それreadlinkを行う-mオプションがあることを最近発見しました;)
Offirmo

26
#!/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」を比較すると、スラッシュを変数に移動し、最後の評価から外すと、そのバグが修正されます。
jcwenger、2011年

3
このスクリプトは単に機能しません。単純な「1つのディレクトリのダウン」テストに失敗する jcwengerによる編集は少しうまく機能しますが、余分な "../"を追加する傾向があります。
パーソンパーソンII

1
引数の末尾に「/」がある場合、失敗する場合があります。たとえば、$ 1 = "$ HOME /"および$ 2 = "$ HOME / temp"の場合、 "/ home / user / temp /"を返しますが、$ 1 = $ HOMEの場合、相対パス "temp"を正しく返します。したがって、== source = $(echo "$ {1}" | sed 's / \ / * $ // ')
michael

1
マイナーな改善:ソース/ターゲットを直接$ 1と$ 2に設定する代わりに、次のようにします:source = $(cd $ 1; pwd)target = $(cd $ 2; pwd)。このようにして、でパスを処理します。そして..正しく。
ジョセフガービン

4
トップ投票の回答ですが、この回答には多くの制限があるため、他の多くの回答が投稿されています。代わりに他の回答、特にテストケースを表示する回答を参照してください。そして、このコメントに賛成投票してください!
Offirmo 2012年

25

Perlに組み込まれています2001年以降、ため、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

...うまくいきます。


3
sayperlではlogとして利用できませんが、ここでは効果的に使用できます。 perl -MFile::Spec -E 'say File::Spec->abs2rel(@ARGV)'
ウィリアムパーセル2014

+1ですが、古い(2012年2月)の同じような回答も参照してください。William Pursellからの関連するコメントも読んでください。私のバージョンは2つのコマンドラインです:perl -MFile::Spec -e 'print File::Spec->abs2rel(@ARGV)' "$target"perl -MFile::Spec -e 'print File::Spec->abs2rel(@ARGV)' "$target" "$origin"。最初の1行のperlスクリプトは1つの引数を使用します(起源は現在の作業ディレクトリです)。2番目の1行のperlスクリプトは2つの引数を使用します。
olibre 2014年

3
それが受け入れられる答えになるはずです。perl答えはまだワンライナーですが、ほとんどどこでも見つけることができます。
ドミトリーギンズバーグ

19

あなたがインストールしたと仮定します: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/}

私はピニと他のいくつかのアイデアからの答えをゴルフしてきました

:これには、両方のパスが既存のフォルダである必要があります。ファイルは機能しません


2
理想的な答え:/ bin / shで動作し、readlink、python、perlを必要としません->ライト/組み込みシステムまたはWindows bashコンソール
Francois

2
残念ながら、これにはパスが存在する必要がありますが、これは必ずしも望ましいことではありません。
drwatsoncode

敬虔な答え。cd-pwdは、リンクを解決するためのものですか?ナイスゴルフ!
Teck-freak

15

os.path.relpathシェル関数としてのPython

このrelpath演習の目標はos.path.relpathxniによって提案されたPython 2.7の機能(Pythonバージョン2.6から利用可能ですが、2.7でのみ正しく機能します)を模倣することです。結果として、一部の結果は他の回答で提供される機能と異なる場合があります。

(私はパスの改行でテストしていませんpython -c。それはZSHからの呼び出しに基づいて検証を壊すからです。それは確かにいくつかの努力で可能です。)

Bashの「魔法」に関しては、ずっと前にBashで魔法を探すことをあきらめてきましたが、それ以来、私が必要とするすべての魔法、そしてZSHでいくつかの魔法を見つけました。

したがって、2つの実装を提案します。

最初の実装は、完全にPOSIXに準拠することを目的としています/bin/dashDebian 6.0.6「スクイーズ」でテストしまし た。また/bin/sh、OS X 10.8.3 でも完全に動作します。これは、実際にはPOSIXシェルを装ったBashバージョン3.2です。

2番目の実装は、パス内の複数のスラッシュやその他の迷惑行為に対して堅牢なZSHシェル関数です。ZSHが利用可能な場合#!/usr/bin/env zsh、別のシェルから以下に示すスクリプト形式で(つまりのシバンで)呼び出す場合でも、これは推奨バージョンです。

最後に、他の回答で提供されたテストケースrelpath$PATH指定されたコマンドの出力を検証するZSHスクリプトを作成しました。! ? *あちこちにスペース、タブ、句読点を追加することで、これらのテストにスパイスを追加し、vim-powerlineにあるエキゾチックなUTF-8文字を使用したさらに別のテストも投入しました

POSIXシェル関数

まず、POSIX準拠のシェル関数。さまざまなパスで機能しますが、複数のスラッシュを削除したり、シンボリックリンクを解決したりしません。

#!/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シェル関数

今、より堅牢なzshバージョン。引数を実際のパスアラrealpath -f(Linux coreutilsパッケージで利用可能)に解決する場合は、:a3行目と4行目のをに置き換え: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、詳細出力を有効にするという1つのオプションを受け入れます。

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

2
恐れ入りますが、最初のパスが最後で終了する/と機能しません。
Noldorin 2015

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

上記のシェルスクリプトはpiniに触発されました(Thanks!)です。それはスタックオーバーフローの構文強調表示モジュールのバグをトリガーします(少なくとも私のプレビューフレームで)。強調表示が正しくない場合は無視してください。

いくつかのメモ:

  • コードの長さと複雑さを大幅に増加させることなく、エラーを取り除き、コードを改善しました
  • 使いやすさのために機能を機能に組み込む
  • すべてのPOSIXシェル(Ubuntu Linux 12.04のダッシュ、bash、およびzshでテスト)で動作するように(すべき)POSIX互換の機能を維持
  • グローバル変数の破壊とグローバル名前空間の汚染を避けるためにのみローカル変数を使用しました
  • 両方のディレクトリパスが存在する必要はありません(アプリケーションの要件)
  • パス名には、スペース、特殊文字、制御文字、バックスラッシュ、タブ、 '、 "、?、*、[、]などを含めることができます。
  • コア関数「relPath」はPOSIXシェル組み込みのみを使用しますが、パラメーターとして正規の絶対ディレクトリパスを必要とします
  • 拡張関数「relpath」は任意のディレクトリパス(相対パス、非標準パス)も処理できますが、外部GNUコアユーティリティ「readlink」が必要です
  • 組み込みの「echo」を避け、代わりに組み込みの「printf」を使用した理由は2つあります。
  • 不要な変換を避けるために、パス名はシェルおよびOSユーティリティによって返され、期待されるとおりに使用されます(たとえば、いくつかのバックスラッシュシーケンスを解釈するpythonの「os.path.relpath」とは異なり、cd、ln、ls、find、mkdir)。
  • 前述のバックスラッシュシーケンスを除いて、関数「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シェル互換)

回帰テストのコードリスト(単にそれをシェルスクリプトに追加します):

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

9

ここでの答えの多くは、毎日の使用に実用的ではありません。純粋なbashでこれを適切に行うことは非常に難しいため、次の信頼できる解決策を提案します(コメントに埋め込まれた1つの提案に類似しています)。

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

次に、現在のディレクトリに基づいて相対パスを取得できます。

echo $(relpath somepath)

または、パスが特定のディレクトリからの相対パスであることを指定できます。

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

1つの欠点は、これにはPythonが必要ですが、

  • どのpythonでも同じように機能します> = 2.6
  • ファイルまたはディレクトリが存在する必要はありません。
  • ファイル名には、さまざまな特殊文字を含めることができます。たとえば、ファイル名にスペースやその他の特殊文字が含まれている場合、他の多くのソリューションは機能しません。
  • これは、スクリプトが煩雑にならない1行の関数です。

なお含めるソリューションbasenamedirname、彼らはそれが必要として、必ずしも良いことではないかもしれcoreutilsインストールされて。誰かがbash(複雑な好奇心ではなく)信頼性が高くシンプルな純粋なソリューションを持っているとしたら、私は驚くでしょう。


これは、最も強力なアプローチのようです。
dimo414

7

このスクリプトは、絶対パスまたは相対パスなしである入力に対して正しい結果を与えます.か、..

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

1
これは動作するようです。ディレクトリが実際に存在する場合、入力で$(readlink -f $ 1)および$(readlink -f $ 2)を使用すると、「。」の問題を修正できます。または「..」が入力に表示されます。ディレクトリが実際に存在しない場合、これはいくつかの問題を引き起こす可能性があります。
Dr.パーソンパーソンII

7

私はこのそれほど簡単ではないタスクにPerlを使用します。

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

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

1
+1、ただし推奨:perl -MFile::Spec -e "print File::Spec->abs2rel('$absolute','$current')"絶対値と現在値が引用されるようにします。
ウィリアムパーセル2014

好きrelative=$(perl -MFile::Spec -e 'print File::Spec->abs2rel(@ARGV)' "$absolute" "$current")です。これにより、値自体にperlコードを含めることができなくなります!
Erik Aronesty 2015

6

kaskuPiniの回答を少し改善しました。これにより、スペースが適切に機能し、相対パスを渡すことができます。

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

4

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です。あなたは、しかし、また、呼び出す必要がありますreadlink$(pwd)
DevSolar 2010年

2
相対は、ファイルを同じディレクトリに配置する必要があるという意味ではありません。
greenoldman 2011年

元の質問は多くのテストケースを提供していませんが、このスクリプトは/ home / user1から/ home / user2への相対パスを見つけるなどの単純なテストでは失敗します(正解:../user2)。pini / jcwengerによるスクリプトは、この場合に機能します。
マイケル

4

さらに別の解決策、以下のコンテキストで簡単に使用できる純粋な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:-.}"
}

ノート:

  • ファイル名に*またはが含まれている場合に、不要なシェルメタ文字の展開に対して安全であるように注意が払われました?
  • 出力は、最初の引数として使用できるようになっています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ページbarから見たページの正確で正しい相対パスのみですmoo。他のすべては明らかに間違っているでしょう。

明らかにそれcurrentがディレクトリであると仮定する質問に出力を採用することは簡単です:

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

これは、要求されたとおりに正確に戻ります。

そして、眉を上げる前にrelpath、URL-Syntaxでも機能する(少しの違いを見つける)のもう少し複雑なバリアントを次に示します(そのため、/いくつかのbash-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"

動作しないものが見つかった場合は、下のコメントでお知らせください。ありがとう。

PS:

なぜの議論は relpathここで他のすべての答えとは対照的に「逆転」のですか?

変更した場合

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

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

次に、BASEが現在のディレクトリ/ URL /その他になるように、2番目のパラメータを省略できます。いつものように、これはUnixの原則にすぎません。

それが気に入らない場合は、Windowsに戻ってください。ありがとう。


3

悲しいことに、Mark Rushakoffの回答(現在は削除されています- ここからのコードを参照しています)は、次のように適応させた場合に正しく機能しないようです。

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

解説で概説されている考え方は、ほとんどの場合に正しく機能するように調整できます。スクリプトがソース引数(現在の場所)とターゲット引数(目的の場所)を受け取り、どちらも絶対パス名であるか、どちらも相対パスであると仮定します。一方が絶対的で、もう一方が相対的である場合、最も簡単なことは、現在の作業ディレクトリを相対名の前に付けることですが、以下のコードはそれを行いません。


注意してください

以下のコードは正常に動作するようですが、完全に正しくはありません。

  1. Dennis Williamsonからのコメントで対処された問題があります。
  2. パス名のこの純粋なテキスト処理であり、奇妙なシンボリックリンクによって深刻に混乱する可能性があるという問題もあります。
  3. このコードは、「xyz/./pqr」のようなパスの「ドット」を処理しません。
  4. このコードは、「」のようなパスの「二重ドット」を処理しません。xyz/../pqr」の。
  5. 簡単に言うと、コードは./パスから先頭の ' 'を削除しません。

Dennisのコードは1と5を修正しているのでより優れていますが、同じ問題が2、3、4あります。そのため、Dennisのコードを使用します(そして、これに先立って投票します)。

(注:POSIXは、realpath()パス名を解決してそれらにシンボリックリンクが残らないようにするシステムコールを提供します。入力名にそれを適用し、Dennisのコードを使用すると、毎回正しい答えが得られます。Cコードを書くのは簡単です。 wraps- realpath()私はそれを行いました-しかし、私はそれを行う標準的なユーティリティを知りません。)


このため、シェルよりもPerlの方が使いやすいと思いますが、bashは配列を適切にサポートしており、おそらくこれも実行できます。したがって、2つの互換性のある名前を指定して、それぞれをコンポーネントに分割します。

  • 相対パスを空に設定します。
  • コンポーネントは同じですが、次にスキップしてください。
  • 対応するコンポーネントが異なる場合、または1つのパスにコンポーネントがない場合:
  • ソースコンポーネントが残っておらず、相対パスが空の場合は、「。」を追加します。最初に。
  • 残りの各ソースコンポーネントについて、相対パスの前に「../」を付けます。
  • ターゲットコンポーネントが残っておらず、相対パスが空の場合は、「。」を追加します。最初に。
  • 残りの各ターゲットコンポーネントについて、コンポーネントをパスの最後のスラッシュの後に追加します。

したがって:

#!/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を使用して、存在する名前の実際のパスを解決し、存在しないパスのテキスト分析を行います。1つを除くすべてのケースで、Dennisのスクリプトと同じ出力を生成します。逸脱したケースは次のとおりです。

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

2つの結果は同等です-まったく同じではありません。(出力は、テストスクリプトの少し変更されたバージョンからのものです。以下の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には、/あまりにも多くのものを持っています../。それ以外の場合、私のスクリプトはあなたの出力と一致します.が、宛先が存在するものの最後に不要なものを追加し、上に行かないで下降するものの最初に.a ./を使用しません。
追って通知があるまで一時停止。

@Dennis:私は結果に目を凝らしながら時間を費やしました-時々私はその問題を見ることができ、時にはそれを再び見つけることができませんでした。先頭の「./」を削除することは、別の簡単なステップです。「埋め込みなし」に関するコメント。または.. 'も適切です。実際に仕事を正しく行うのは驚くほど難しいです。名前のいずれかが実際にシンボリックリンクである場合は、二重になります。どちらも純粋なテキスト分析を行っています。
ジョナサンレフラー

@Dennis:もちろん、Newcastle Connectionネットワーキングがない限り、ルートより上に到達しようとしても無駄なので、.. / .. / .. / ..と../../ ..は同等です。しかし、それは純粋な現実逃避です。あなたの批判は正しいです。(Newcastle Connectionを使用すると、表記/../host/path/on/remote/machineを使用して、別のホストにアクセスすることができます。きちんとしたスキームです。/../../network/host/がサポートされていると思います。 path / on / remote / network / and / hostも。Wikipediaに掲載されています。)
Jonathan Leffler、

したがって、代わりに、UNCの二重スラッシュを使用します。
追って通知があるまで一時停止。

1
「-f」オプションを渡すと、「readlink」ユーティリティ(少なくともGNUバージョン)はrealpath()と同等の機能を実行できます。たとえば、私のシステムでreadlink /usr/bin/vi/etc/alternatives/vireadlink -f /usr/bin/vigivesですが/usr/bin/vim.basic、これは別のシンボリックリンクですが、givesは、すべてのシンボリックリンクの最終的な宛先です...
psmears

3

私はあなたの質問を「移植可能な」シェルコードでこれを書くための挑戦と捉えました、すなわち

  • POSIXシェルを念頭に置いて
  • 配列などのバシズムはありません
  • ペストのような外見を呼び出すことは避けてください。スクリプトにはフォークが1つもありません。これにより、特にcygwinのようなフォークのオーバーヘッドが大きいシステムでは、非常に高速になります。
  • パス名のグロブ文字(*、?、[、])を処理する必要があります

POSIX準拠のシェル(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 :

2

私の解決策:

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

}

これは非常にポータブルです:)
匿名

2

これが私のバージョンです。それはに基づいている答えによって@Offirmo。私はそれをダッシュ​​互換にし、次のテストケースの失敗を修正しました:

./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
}

1

これもトリックを実行すると思います...(組み込みテストが付属しています):)

はい、オーバーヘッドが予想されますが、ここではBourneシェルを実行しています!;)

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

1

このスクリプトは、パス名に対してのみ機能します。ファイルが存在する必要はありません。渡されたパスが絶対パスではない場合、動作は少し異常ですが、両方のパスが相対パスである場合、期待どおりに動作するはずです。

私は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

また、コードはビットコピー&ペーストのようですが、私はこれをすぐに必要としました。
juancn 2010

ニース...ちょうど私が必要としたもの。そして、私が見た他のほとんどのものよりも優れた正規化ルーチンを含めました(通常、正規表現の置換に依存しています)。
drwatsoncode

0

この回答は質問の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したテストケースと同じように動作すると思います。
Gary Wisniewski、2015

-1

以下は、他のプログラムを呼び出さずにそれを行うシェルスクリプトです。

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


1
これは、POSIXではない$ {param / pattern / subst}コンストラクトを使用しているため、実際には移植可能ではありません(2011年現在)。
イェンス

参照されているソースynform.org/w/Pub/Relpathは、スクリプトの内容を数回含む完全に文字化けしたWikiページを指し、viチルド行、コマンドが見つからないことに関するエラーメッセージなどが混在しています。オリジナルを研究している人にとってはまったく役に立たない。
イェンス

-1

私はこのようなものが必要でしたが、シンボリックリンクも解決しました。その目的のために、pwdに-Pフラグがあることがわかりました。スクリプトのフラグメントが追加されます。シェルスクリプトの関数内にあるため、$ 1と$ 2になります。START_ABSからEND_ABSへの相対パスである結果値は、UPDIRS変数にあります。スクリプトは、pwd -Pを実行するために各パラメーターディレクトリにcdします。これは、相対パスパラメーターが処理されることも意味します。乾杯、ジム

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"
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.