Cara memperluas variabel khusus secara manual (mis: ~ tilde) di bash

Saya memiliki variabel dalam skrip bash saya yang nilainya seperti ini:

~/a/b/c

Perhatikan bahwa ini adalah tilde yang tidak dikembangkan. Ketika saya melakukan ls -lt pada variabel ini (sebut saja $ VAR), saya tidak mendapatkan direktori seperti itu. Saya ingin membiarkan bash menafsirkan / memperluas variabel ini tanpa menjalankannya. Dengan kata lain, saya ingin bash menjalankan eval tetapi tidak menjalankan perintah yang dievaluasi. Apakah ini mungkin di bash?

Bagaimana saya bisa meneruskan ini ke skrip saya tanpa ekspansi? Saya melewati argumen di sekitarnya dengan tanda kutip ganda.

Coba perintah ini untuk melihat apa yang saya maksud:

ls -lt "~"

Ini persis situasi saya. Saya ingin tilde diperluas. Dengan kata lain, apa yang harus saya ganti dengan sihir untuk membuat kedua perintah ini identik:

ls -lt ~/abc/def/ghi

dan

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

Perhatikan bahwa ~ / abc / def / ghi mungkin ada atau tidak ada.

Karena sifat StackOverflow, saya tidak bisa hanya membuat jawaban ini tidak dapat diterima, tetapi dalam 5 tahun sejak saya memposting ini, ada jawaban yang jauh lebih baik daripada jawaban saya yang dianggap sederhana dan sangat buruk (saya masih muda, jangan bunuh saya).

Solusi lain di utas ini adalah solusi yang lebih aman dan lebih baik. Lebih disukai, saya akan memilih salah satu dari dua ini:

• Solusi Charle's Duffy
• Solusi Håkon Hægland

Jawaban asli untuk tujuan bersejarah (tapi tolong jangan gunakan ini)

Jika saya tidak salah, "~"tidak akan diperluas dengan skrip bash dengan cara itu karena diperlakukan sebagai string literal "~". Anda dapat memaksa ekspansi melalui evalseperti ini.

#!/bin/bash

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

Atau, gunakan saja ${HOME}jika Anda ingin direktori home pengguna.

Jika variabel vardimasukkan oleh pengguna, evalsebaiknya tidak digunakan untuk memperluas tilde menggunakan

eval var=$var  # Do not use this!

Alasannya adalah: pengguna dapat secara tidak sengaja (atau sengaja) mengetik misalnya var="$(rm -rf $HOME/)"dengan kemungkinan konsekuensi yang membahayakan.

Cara yang lebih baik (dan lebih aman) adalah dengan menggunakan ekspansi parameter Bash:

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

Merencanakan diri saya dari jawaban sebelumnya , untuk melakukan ini dengan kuat tanpa risiko keamanan yang terkait dengan 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%:}"
}

...digunakan sebagai...

path=$(expandPath '~/hello')

Sebagai alternatif, pendekatan yang lebih sederhana yang menggunakan evaldengan hati-hati:

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
}

Cara aman untuk menggunakan eval adalah "$(printf "~/%q" "$dangerous_path")". Perhatikan bahwa spesifik bash.

#!/bin/bash

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

Lihat pertanyaan ini untuk detailnya

Juga, perhatikan bahwa di bawah zsh ini akan sesederhana echo ${~dangerous_path}

Bagaimana dengan ini:

path=`realpath "$1"`

Atau:

path=`readlink -f "$1"`

Memperluas (no pun intended) pada jawaban birryree dan halloleo: Pendekatan umum adalah menggunakan eval, tetapi ia datang dengan beberapa peringatan penting, yaitu spasi dan redirection output ( >) dalam variabel. Sepertinya ini bekerja untuk saya:

mypath="$1"

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

Cobalah dengan masing-masing argumen berikut:

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

Penjelasan

• The ${mypath//>}strip keluar >karakter yang bisa mengkritik file selama eval.
• Inilah eval echo ...yang dilakukan ekspansi tilde yang sebenarnya
• Kutipan ganda di sekitar -eargumen adalah untuk mendukung nama file dengan spasi.

Mungkin ada solusi yang lebih elegan, tapi ini yang bisa saya lakukan.

Saya percaya ini yang Anda cari

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

Contoh penggunaan:

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

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

Inilah solusi saya:

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

Cukup gunakan evaldengan benar: dengan validasi.

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

Berikut adalah fungsi POSIX yang setara dengan jawaban Bash Håkon Hægland

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

Sunting 2017-12-10: tambahkan '%s'per @CharlesDuffy di komentar.

mengapa tidak menggali langsung ke direktori home pengguna dengan getent?

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

Hanya untuk memperpanjang jawaban birryree untuk jalur dengan spasi: Anda tidak dapat menggunakan evalperintah apa adanya karena memisahkan evaluasi dengan spasi. Salah satu solusinya adalah mengganti spasi sementara untuk perintah 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

Contoh ini tentu saja bergantung pada asumsi yang mypathtidak pernah berisi urutan char "_spc_".

Anda mungkin menemukan ini lebih mudah dilakukan dengan python.

(1) Dari baris perintah unix:

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

Hasil dalam:

/Users/someone/fred

(2) Dalam skrip bash sebagai satu kali - simpan ini sebagai test.sh:

#!/usr/bin/env bash

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

echo $thepath

Menjalankan bash ./test.shhasil dalam:

/Users/someone/fred

(3) Sebagai utilitas - simpan ini di expandusersuatu tempat di jalur Anda, dengan menjalankan izin:

#!/usr/bin/env python

import sys
import os

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

Ini kemudian dapat digunakan pada baris perintah:

expanduser ~/fred

Atau dalam naskah:

#!/usr/bin/env bash

thepath=$(expanduser $1)

echo $thepath

Sederhana : ganti 'ajaib' dengan 'eval echo'.

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

Masalah: Anda akan mengalami masalah dengan variabel lain karena eval itu jahat. Misalnya:

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

Perhatikan bahwa masalah injeksi tidak terjadi pada ekspansi pertama. Jadi jika Anda hanya menggantinya magicdengan eval echo, Anda harus baik-baik saja. Tetapi jika Anda melakukannya echo $(eval echo ~), itu akan rentan terhadap injeksi.

Demikian pula, jika Anda melakukannya eval echo ~bukan eval echo "~", itu akan dihitung sebagai dua kali diperluas dan oleh karena itu injeksi akan segera mungkin dilakukan.

Saya telah melakukan ini dengan substitusi parameter variabel setelah membaca di jalan menggunakan read -e (antara lain). Jadi pengguna dapat melakukan tab-melengkapi path, dan jika pengguna memasukkan ~ path itu akan diurutkan.

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

Manfaat tambahan adalah bahwa jika tidak ada tilde tidak ada yang terjadi pada variabel, dan jika ada tilde tetapi tidak di posisi pertama itu juga diabaikan.

(Saya menyertakan -i untuk dibaca karena saya menggunakan ini dalam satu lingkaran sehingga pengguna dapat memperbaiki jalur jika ada masalah.)