Nhận liên kết tương đối giữa hai đường dẫn

Nói rằng tôi có hai con đường: <source_path>và <target_path>. Tôi muốn shell của tôi (zsh) tự động tìm hiểu xem có cách nào để biểu diễn <target_path>từ <source_path>một đường dẫn tương đối không.

Ví dụ: giả sử

• <source_path> Là /foo/bar/something
• <target_path> Là /foo/hello/world

Kết quả sẽ là ../../hello/world

Tại sao tôi cần điều này:

Tôi cần thích để tạo ra một liên kết tượng trưng từ <source_path>để <target_path>sử dụng một họ hàng liên kết tượng trưng bất cứ khi nào có thể, vì nếu không thì máy chủ samba của chúng tôi không hiển thị các thuộc tính của file khi tôi truy cập vào các tập tin trên mạng từ Windows (tôi không phải là quản trị viên sys, và don' t có quyền kiểm soát cài đặt này)

Giả sử rằng <target_path>và <source_path>là các đường dẫn tuyệt đối, sau đây tạo ra một liên kết tượng trưng chỉ đến một đường dẫn tuyệt đối .

ln -s <target_path> <source_path>

vì vậy nó không hoạt động cho nhu cầu của tôi. Tôi cần phải làm điều này cho hàng trăm tệp, vì vậy tôi không thể tự sửa nó.

Bất kỳ vỏ được xây dựng mà chăm sóc này?

Bạn có thể sử dụng symlinkslệnh để chuyển đổi đường dẫn tuyệt đối sang tương đối:

/tmp$ mkdir -p 1/{a,b,c} 2
/tmp$ cd 2
/tmp/2$ ln -s /tmp/1/* .
/tmp/2$ ls -l
total 0
lrwxrwxrwx 1 stephane stephane 8 Jul 31 16:32 a -> /tmp/1/a/
lrwxrwxrwx 1 stephane stephane 8 Jul 31 16:32 b -> /tmp/1/b/
lrwxrwxrwx 1 stephane stephane 8 Jul 31 16:32 c -> /tmp/1/c/

Chúng tôi đã có các liên kết tuyệt đối, hãy chuyển đổi chúng thành tương đối:

/tmp/2$ symlinks -cr .
absolute: /tmp/2/a -> /tmp/1/a
changed:  /tmp/2/a -> ../1/a
absolute: /tmp/2/b -> /tmp/1/b
changed:  /tmp/2/b -> ../1/b
absolute: /tmp/2/c -> /tmp/1/c
changed:  /tmp/2/c -> ../1/c
/tmp/2$ ls -l
total 0
lrwxrwxrwx 1 stephane stephane 6 Jul 31 16:32 a -> ../1/a/
lrwxrwxrwx 1 stephane stephane 6 Jul 31 16:32 b -> ../1/b/
lrwxrwxrwx 1 stephane stephane 6 Jul 31 16:32 c -> ../1/c/

Tài liệu tham khảo

• trang người đàn ông symlink

Hãy thử sử dụng realpathlệnh (một phần của GNU coreutils; > = 8.23 ), ví dụ:

realpath --relative-to=/foo/bar/something /foo/hello/world

^{Nếu bạn đang sử dụng macOS, hãy cài đặt phiên bản GNU qua: brew install coreutilsvà sử dụng grealpath.}

Lưu ý rằng cả hai đường dẫn cần tồn tại để lệnh thành công. Nếu bạn vẫn cần đường dẫn tương đối ngay cả khi một trong số chúng không tồn tại thì hãy thêm công tắc -m.

Để biết thêm ví dụ, xem Chuyển đổi đường dẫn tuyệt đối thành đường dẫn tương đối được cung cấp một thư mục hiện tại .

Tôi nghĩ rằng giải pháp python này (được lấy từ cùng một bài với câu trả lời của @ EvanTeitelman) cũng đáng được đề cập. Thêm phần này vào ~/.zshrc:

relpath() python -c 'import os.path, sys;\
  print os.path.relpath(sys.argv[1],sys.argv[2])' "$1" "${2-$PWD}"

Sau đó, bạn có thể làm, ví dụ:

$ relpath /usr/local/share/doc/emacs /usr/local/share/fonts
../doc/emacs

Không có bất kỳ nội dung shell nào để giải quyết vấn đề này. Tôi đã tìm thấy một giải pháp trên Stack Overflow mặc dù. Tôi đã sao chép giải pháp ở đây với những sửa đổi nhỏ và đánh dấu câu trả lời này là wiki cộng đồng.

relpath() {
    # both $1 and $2 are absolute paths beginning with /
    # $1 must be a canonical path; that is none of its directory
    # components may be ".", ".." or a symbolic link
    #
    # returns relative path to $2/$target from $1/$source
    source=$1
    target=$2

    common_part=$source
    result=

    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#?}
    fi

    printf '%s\n' "$result"
}

Bạn có thể sử dụng chức năng này như vậy:

source=/foo/bar/something
target=/foo/hello/world
ln -s "$(relpath "$source" "$target")" "$source"

# Prints out the relative path between to absolute paths. Trivial.
#
# Parameters:
# $1 = first path
# $2 = second path
#
# Output: the relative path between 1st and 2nd paths
relpath() {
    local pos="${1%%/}" ref="${2%%/}" down=''

    while :; do
        test "$pos" = '/' && break
        case "$ref" in $pos/*) break;; esac
        down="../$down"
        pos=${pos%/*}
    done

    echo "$down${ref##$pos/}"
}

Đây là giải pháp đơn giản và đẹp nhất cho vấn đề.

Ngoài ra, nó nên hoạt động trên tất cả các vỏ giống như bourne.

Và sự khôn ngoan ở đây là: hoàn toàn không cần đến các tiện ích bên ngoài hoặc thậm chí các điều kiện phức tạp. Một vài thay thế tiền tố / hậu tố và một vòng lặp while là tất cả những gì bạn cần để có được bất cứ thứ gì được thực hiện trên các vỏ giống như bourne.

Cũng có sẵn qua PasteBin: http://pastebin.com/CtTfvime

Tôi đã phải viết một tập lệnh bash để làm điều này một cách đáng tin cậy (và tất nhiên mà không cần xác minh sự tồn tại của tập tin).

Sử dụng

relpath <symlink path> <source path>

Trả về một đường dẫn nguồn tương đối.

thí dụ:

#/a/b/c/d/e   ->  /a/b/CC/DD/EE       ->  ../../CC/DD/EE
relpath /a/b/c/d/e   /a/b/CC/DD/EE

#./a/b/c/d/e   ->  ./a/b/CC/DD/EE       ->  ../../CC/DD/EE
relpath ./a/b/c/d/e  ./a/b/CC/DD/EE

cả hai nhận được ../../CC/DD/EE

Để có một bài kiểm tra nhanh, bạn có thể chạy

curl -sL https://github.com/jjqq2013/bash-scripts/raw/master/common/relpath | bash -s -- --test

kết quả: một danh sách kiểm tra

/a             ->  /                 ->  .
/a/b           ->  /                 ->  ..
/a/b           ->  /a                ->  .
/a/b/c         ->  /a                ->  ..
/a/b/c         ->  /a/b              ->  .
/a/b/c         ->  /a/b/CC           ->  CC
/a/b/c/d/e     ->  /a                ->  ../../..
/a/b/c/d/e     ->  /a/b              ->  ../..
/a/b/c/d/e     ->  /a/b/CC           ->  ../../CC
/a/b/c/d/e     ->  /a/b/CC/DD/EE     ->  ../../CC/DD/EE
./a            ->  ./                ->  .
./a/b          ->  ./                ->  ..
./a/b          ->  ./a               ->  .
./a/b/c        ->  ./a               ->  ..
./a/b/c        ->  ./a/b             ->  .
./a/b/c        ->  ./a/b/CC          ->  CC
./a/b/c/d/e    ->  ./a               ->  ../../..
./a/b/c/d/e    ->  ./a/b/CC          ->  ../../CC
./a/b/c/d/e    ->  ./a/b/CC/DD/EE    ->  ../../CC/DD/EE
/a             ->  /x                ->  x
/a/b           ->  /x                ->  ../x
/a/b/c         ->  /x                ->  ../../x
/a             ->  /x/y              ->  x/y
/a/b           ->  /x/y              ->  ../x/y
/a/b/c         ->  /x/y              ->  ../../x/y
/x             ->  /a                ->  a
/x             ->  /a/b              ->  a/b
/x             ->  /a/b/c            ->  a/b/c
/x/y           ->  /a                ->  ../a
/x/y           ->  /a/b              ->  ../a/b
/x/y           ->  /a/b/c            ->  ../a/b/c
./a a/b/c/d/e  ->  ./a a/b/CC/DD/EE  ->  ../../CC/DD/EE
/x x/y y       ->  /a a/b b/c c      ->  ../a a/b b/c c

BTW, nếu bạn muốn sử dụng tập lệnh này mà không lưu tập lệnh và bạn tin tưởng tập lệnh này, thì bạn có hai cách để thực hiện điều này với thủ thuật bash.

Nhập relpathdưới dạng hàm bash bằng lệnh sau. (Yêu cầu bash 4+)

source <(curl -sSL https://github.com/jjqq2013/bash-scripts/raw/master/common/relpath)

hoặc gọi kịch bản nhanh chóng như với combo bash curl.

curl -sSL https://github.com/jjqq2013/bash-scripts/raw/master/common/relpath | bash -s -- /a/b/c/d/e /a/b/CC/DD/EE