Cách mở rộng thủ công một biến đặc biệt (ví dụ: ~ dấu ngã) trong bash

Tôi có một biến trong tập lệnh bash có giá trị như sau:

~/a/b/c

Lưu ý rằng đó là dấu ngã chưa được mở rộng. Khi tôi thực hiện ls -lt trên biến này (gọi nó là $ VAR), tôi không nhận được thư mục nào như vậy. Tôi muốn để bash diễn giải / mở rộng biến này mà không thực hiện nó. Nói cách khác, tôi muốn bash chạy eval nhưng không chạy lệnh được đánh giá. Điều này có thể trong bash?

Làm thế nào tôi quản lý để chuyển điều này vào kịch bản của mình mà không cần mở rộng? Tôi đã thông qua các đối số xung quanh nó với dấu ngoặc kép.

Hãy thử lệnh này để xem ý tôi là gì:

ls -lt "~"

Đây chính xác là tình huống tôi đang gặp phải. Tôi muốn dấu ngã được mở rộng. Nói cách khác, tôi nên thay thế phép thuật bằng cách làm cho hai lệnh này giống hệt nhau:

ls -lt ~/abc/def/ghi

và

ls -lt $(magic "~/abc/def/ghi")

Lưu ý rằng ~ / abc / def / ghi có thể tồn tại hoặc không tồn tại.

Do tính chất của StackOverflow, tôi không thể chấp nhận câu trả lời này, nhưng trong 5 năm kể từ khi tôi đăng bài này, đã có những câu trả lời tốt hơn nhiều so với câu trả lời thô sơ và khá tệ của tôi (tôi còn trẻ, đừng giết tôi).

Các giải pháp khác trong chủ đề này là giải pháp an toàn hơn và tốt hơn. Tốt nhất là tôi nên đi với một trong hai người sau:

• Giải pháp của Charle's Duffy
• Giải pháp của Håkon Hægland

Câu trả lời gốc cho mục đích lịch sử (nhưng vui lòng không sử dụng điều này)

Nếu tôi không nhầm, "~"sẽ không được mở rộng bằng tập lệnh bash theo cách đó vì nó được coi là một chuỗi ký tự "~". Bạn có thể buộc mở rộng thông qua evalnhư thế này.

#!/bin/bash

homedir=~
eval homedir=$homedir
echo $homedir # prints home path

Ngoài ra, chỉ cần sử dụng ${HOME}nếu bạn muốn thư mục nhà của người dùng.

Nếu biến varlà đầu vào bởi người sử dụng, evalnên không được sử dụng để mở rộng dấu ngã sử dụng

eval var=$var  # Do not use this!

Lý do là: người dùng có thể vô tình (hoặc do mục đích) loại ví dụ var="$(rm -rf $HOME/)"với hậu quả tai hại có thể xảy ra.

Một cách tốt hơn (và an toàn hơn) là sử dụng mở rộng tham số Bash:

var="${var/#\~/$HOME}"

Tự tôn mình từ một câu trả lời trước , để làm điều này một cách mạnh mẽ mà không có rủi ro bảo mật liên quan đến eval:

expandPath() {
  local path
  local -a pathElements resultPathElements
  IFS=':' read -r -a pathElements <<<"$1"
  : "${pathElements[@]}"
  for path in "${pathElements[@]}"; do
    : "$path"
    case $path in
      "~+"/*)
        path=$PWD/${path#"~+/"}
        ;;
      "~-"/*)
        path=$OLDPWD/${path#"~-/"}
        ;;
      "~"/*)
        path=$HOME/${path#"~/"}
        ;;
      "~"*)
        username=${path%%/*}
        username=${username#"~"}
        IFS=: read -r _ _ _ _ _ homedir _ < <(getent passwd "$username")
        if [[ $path = */* ]]; then
          path=${homedir}/${path#*/}
        else
          path=$homedir
        fi
        ;;
    esac
    resultPathElements+=( "$path" )
  done
  local result
  printf -v result '%s:' "${resultPathElements[@]}"
  printf '%s\n' "${result%:}"
}

...được dùng như...

path=$(expandPath '~/hello')

Thay phiên, một cách tiếp cận đơn giản hơn sử dụng evalcẩn thận:

expandPath() {
  case $1 in
    ~[+-]*)
      local content content_q
      printf -v content_q '%q' "${1:2}"
      eval "content=${1:0:2}${content_q}"
      printf '%s\n' "$content"
      ;;
    ~*)
      local content content_q
      printf -v content_q '%q' "${1:1}"
      eval "content=~${content_q}"
      printf '%s\n' "$content"
      ;;
    *)
      printf '%s\n' "$1"
      ;;
  esac
}

Một cách an toàn để sử dụng eval là "$(printf "~/%q" "$dangerous_path")". Lưu ý đó là bash cụ thể.

#!/bin/bash

relativepath=a/b/c
eval homedir="$(printf "~/%q" "$relativepath")"
echo $homedir # prints home path

Xem câu hỏi này để biết chi tiết

Ngoài ra, lưu ý rằng theo zsh, điều này sẽ đơn giản như echo ${~dangerous_path}

Còn cái này thì sao:

path=`realpath "$1"`

Hoặc là:

path=`readlink -f "$1"`

Mở rộng (không có ý định chơi chữ) đối với câu trả lời của birryree và hallole: Cách tiếp cận chung là sử dụng eval, nhưng nó đi kèm với một số cảnh báo quan trọng, cụ thể là khoảng trắng và chuyển hướng đầu ra ( >) trong biến. Những điều sau đây có vẻ hiệu quả với tôi:

mypath="$1"

if [ -e "`eval echo ${mypath//>}`" ]; then
    echo "FOUND $mypath"
else
    echo "$mypath NOT FOUND"
fi

Hãy thử nó với từng đối số sau đây:

'~'
'~/existing_file'
'~/existing file with spaces'
'~/nonexistant_file'
'~/nonexistant file with spaces'
'~/string containing > redirection'
'~/string containing > redirection > again and >> again'

Giải trình

• Các ký tự ${mypath//>}loại bỏ các >ký tự có thể ghi đè lên một tệp trong eval.
• Việc eval echo ...mở rộng dấu ngã thực sự là gì
• Các trích dẫn kép xung quanh -eđối số là để hỗ trợ tên tệp có dấu cách.

Có lẽ có một giải pháp thanh lịch hơn, nhưng đây là những gì tôi có thể nghĩ ra.

Tôi tin rằng đây là những gì bạn đang tìm kiếm

magic() { # returns unexpanded tilde express on invalid user
    local _safe_path; printf -v _safe_path "%q" "$1"
    eval "ln -sf ${_safe_path#\\} /tmp/realpath.$$"
    readlink /tmp/realpath.$$
    rm -f /tmp/realpath.$$
}

Ví dụ sử dụng:

$ magic ~nobody/would/look/here
/var/empty/would/look/here

$ magic ~invalid/this/will/not/expand
~invalid/this/will/not/expand

Đây là giải pháp của tôi:

#!/bin/bash


expandTilde()
{
    local tilde_re='^(~[A-Za-z0-9_.-]*)(.*)'
    local path="$*"
    local pathSuffix=

    if [[ $path =~ $tilde_re ]]
    then
        # only use eval on the ~username portion !
        path=$(eval echo ${BASH_REMATCH[1]})
        pathSuffix=${BASH_REMATCH[2]}
    fi

    echo "${path}${pathSuffix}"
}



result=$(expandTilde "$1")

echo "Result = $result"

Chỉ cần sử dụng evalchính xác: với xác nhận.

case $1${1%%/*} in
([!~]*|"$1"?*[!-+_.[:alnum:]]*|"") ! :;;
(*/*)  set "${1%%/*}" "${1#*/}"       ;;
(*)    set "$1" 
esac&& eval "printf '%s\n' $1${2+/\"\$2\"}"

Đây là hàm POSIX tương đương với câu trả lời Bash của Håkon Hægland

expand_tilde() {
    tilde_less="${1#\~/}"
    [ "$1" != "$tilde_less" ] && tilde_less="$HOME/$tilde_less"
    printf '%s' "$tilde_less"
}

Chỉnh sửa 2017-12-10: thêm '%s'mỗi @CharlesDuffy trong các bình luận.

Tại sao không đi thẳng vào việc lấy thư mục nhà của người dùng với getent?

$ getent passwd mike | cut -d: -f6
/users/mike

Chỉ để mở rộng câu trả lời của birryree cho các đường dẫn có khoảng trắng: Bạn không thể sử dụng evallệnh vì nó tách biệt đánh giá theo khoảng trắng. Một giải pháp là tạm thời thay thế khoảng trắng cho lệnh eval:

mypath="~/a/b/c/Something With Spaces"
expandedpath=${mypath// /_spc_}    # replace spaces 
eval expandedpath=${expandedpath}  # put spaces back
expandedpath=${expandedpath//_spc_/ }
echo "$expandedpath"    # prints e.g. /Users/fred/a/b/c/Something With Spaces"
ls -lt "$expandedpath"  # outputs dir content

Ví dụ này tất nhiên dựa vào giả định mypathkhông bao giờ chứa chuỗi char "_spc_".

Bạn có thể thấy điều này dễ dàng hơn để làm trong python.

(1) Từ dòng lệnh unix:

python -c 'import os; import sys; print os.path.expanduser(sys.argv[1])' ~/fred

Kết quả trong:

/Users/someone/fred

(2) Trong một tập lệnh bash là một lần - hãy lưu tập lệnh này dưới dạng test.sh:

#!/usr/bin/env bash

thepath=$(python -c 'import os; import sys; print os.path.expanduser(sys.argv[1])' $1)

echo $thepath

Chạy bash ./test.shkết quả trong:

/Users/someone/fred

(3) Là một tiện ích - lưu cái này expanduserở đâu đó trên đường dẫn của bạn, với quyền thực thi:

#!/usr/bin/env python

import sys
import os

print os.path.expanduser(sys.argv[1])

Điều này sau đó có thể được sử dụng trên dòng lệnh:

expanduser ~/fred

Hoặc trong một kịch bản:

#!/usr/bin/env bash

thepath=$(expanduser $1)

echo $thepath

Đơn giản nhất : thay thế 'ma thuật' bằng 'tiếng vang eval'.

$ eval echo "~"
/whatever/the/f/the/home/directory/is

Vấn đề: Bạn sẽ gặp vấn đề với các biến khác vì eval là xấu xa. Ví dụ:

$ # home is /Users/Hacker$(s)
$ s="echo SCARY COMMAND"
$ eval echo $(eval echo "~")
/Users/HackerSCARY COMMAND

Lưu ý rằng vấn đề tiêm không xảy ra trong lần mở rộng đầu tiên. Vì vậy, nếu bạn chỉ đơn giản là thay thế magicbằng eval echo, bạn sẽ ổn thôi. Nhưng nếu bạn làm thế echo $(eval echo ~), điều đó sẽ dễ bị tiêm.

Tương tự, nếu bạn làm eval echo ~thay vì eval echo "~", điều đó sẽ được tính là hai lần mở rộng và do đó có thể tiêm ngay lập tức.

Tôi đã thực hiện điều này với sự thay thế tham số biến sau khi đọc trong đường dẫn bằng cách sử dụng read -e (trong số những người khác). Vì vậy, người dùng có thể hoàn thành tab đường dẫn và nếu người dùng nhập một đường dẫn ~ thì nó sẽ được sắp xếp.

read -rep "Enter a path:  " -i "${testpath}" testpath 
testpath="${testpath/#~/${HOME}}" 
ls -al "${testpath}" 

Lợi ích bổ sung là nếu không có dấu ngã thì không có gì xảy ra với biến và nếu có dấu ngã nhưng không ở vị trí đầu tiên thì nó cũng bị bỏ qua.

(Tôi bao gồm -i để đọc vì tôi sử dụng điều này trong một vòng lặp để người dùng có thể sửa đường dẫn nếu có vấn đề.)