Bash'de özel bir değişkeni (örn: ~ tilde) manuel olarak genişletme

Bash betiğimde değeri şuna benzer bir değişken var:

~/a/b/c

Genişletilmemiş tilde olduğuna dikkat edin. Bu değişken üzerinde ls -lt yaptığımda (buna $ VAR deyin), böyle bir dizin alamıyorum. Bash'in bu değişkeni çalıştırmadan yorumlamasına / genişletmesine izin vermek istiyorum. Diğer bir deyişle, bash'in eval çalıştırmasını ancak değerlendirilen komutu çalıştırmamasını istiyorum. Bash'de bu mümkün mü?

Bunu genişletme olmadan betiğime nasıl aktarmayı başardım? Çevreleyen argümanı çift tırnakla geçtim.

Ne demek istediğimi görmek için bu komutu deneyin:

ls -lt "~"

Bu tam olarak içinde bulunduğum durum. Tilde'nin genişletilmesini istiyorum. Başka bir deyişle, bu iki komutu aynı yapmak için sihri neyle değiştirmeliyim:

ls -lt ~/abc/def/ghi

ve

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

~ / Abc / def / ghi'nin var olabileceğini veya olmayabileceğini unutmayın.

StackOverflow'un doğası gereği, bu cevabı kabul edilmeyecek hale getiremem, ancak bunu yayınladığımdan beri geçen 5 yıl içinde, kuşkusuz ilkel ve oldukça kötü cevabımdan çok daha iyi cevaplar oldu (gençtim, öldürme ben mi).

Bu konudaki diğer çözümler daha güvenli ve daha iyi çözümlerdir. Tercihen şu ikisinden biriyle giderim:

• Charle's Duffy'nin çözümü
• Håkon Hægland'ın çözümü

Tarihsel amaçlar için orijinal cevap (ancak lütfen bunu kullanmayın)

Eğer yanılmıyorsam, "~"bu şekilde bir bash betiği tarafından genişletilmeyecektir, çünkü birebir dizge olarak değerlendirilir "~". Bu şekilde genişlemeye zorlayabilirsiniz eval.

#!/bin/bash

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

Alternatif olarak, ${HOME}kullanıcının ana dizinini istiyorsanız sadece kullanın .

Değişken Eğer vargiriş kullanıcı tarafından ise, evalgerektiği değil kullanarak tilde genişletmek için kullanılabilir

eval var=$var  # Do not use this!

Nedeni şudur: kullanıcı tesadüfen (veya amaçla) olabilir, örneğin var="$(rm -rf $HOME/)" olası felaket sonuçlarla olabilir.

Daha iyi (ve daha güvenli) bir yol, Bash parametresi genişletmeyi kullanmaktır:

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

Önceki bir cevaptan kendimi rahatsız ediyorum ilişkili güvenlik riskleri olmadan bunu sağlam bir şekilde yapmakeval :

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%:}"
}

... olarak kullanıldı ...

path=$(expandPath '~/hello')

Alternatif olarak, evaldikkatlice kullanan daha basit bir yaklaşım :

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
}

Eval kullanmanın güvenli bir yolu "$(printf "~/%q" "$dangerous_path")". Bunun bash'a özgü olduğunu unutmayın.

#!/bin/bash

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

Bu soruyu görün bakın

Ayrıca, zsh altında bunun şu kadar basit olacağını unutmayın: echo ${~dangerous_path}

Buna ne dersin:

path=`realpath "$1"`

Veya:

path=`readlink -f "$1"`

Birryree'nin ve halloleo'nun cevaplarını genişletmek (kelime anlamı yoktur): Genel yaklaşım kullanmaktır eval, ancak bazı önemli uyarılarla, yani >değişkendeki boşluklar ve çıktı yeniden yönlendirmesi ( ) ile birlikte gelir. Aşağıdakiler benim için çalışıyor gibi görünüyor:

mypath="$1"

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

Aşağıdaki argümanların her biriyle deneyin:

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

açıklama

• İşlem sırasında bir dosyayı bozabilecek karakterleri ${mypath//>}çıkarır >.eval .
• eval echo ...Gerçek yaklaşık yorumlaması yaptığı iştir
• Bağımsız -edeğişken etrafındaki çift tırnak işaretleri , boşluk içeren dosya adlarını desteklemek içindir.

Belki daha zarif bir çözüm var, ama bulabildiğim şey buydu.

Bence aradığın bu

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

Örnek kullanım:

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

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

İşte benim çözümüm:

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

Sadece evaldoğru şekilde kullanın : doğrulama ile.

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

İşte Håkon Hægland'ın Bash cevabının POSIX işlevi karşılığı

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

2017-12-10 düzenlemesi: '%s'yorumlarda @CharlesDuffy başına ekleyin .

neden doğrudan getent ile kullanıcının ana dizinine ulaşmayasınız?

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

Birryree'nin boşluklu yollar için yanıtını genişletmek için: Değerlendirmeyi boşluklarla ayırdığı için evalkomutu olduğu gibi kullanamazsınız . Bir çözüm, eval komutu için boşlukları geçici olarak değiştirmektir:

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

Bu örnek, elbette mypath, char dizisini asla içermeyen varsayımına dayanmaktadır "_spc_".

Bunu python'da yapmayı daha kolay bulabilirsiniz.

(1) Unix komut satırından:

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

Sonuçlar:

/Users/someone/fred

(2) Tek seferlik bir bash komut dosyası içinde - bunu şu şekilde kaydedin test.sh:

#!/usr/bin/env bash

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

echo $thepath

Çalıştırılan bash ./test.shsonuçlar:

/Users/someone/fred

(3) Bir yardımcı program olarak - bunu farklı kaydedin expanduser yürütme izinleriyle yolunuzda bir yere kaydedin:

#!/usr/bin/env python

import sys
import os

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

Bu daha sonra komut satırında kullanılabilir:

expanduser ~/fred

Veya bir senaryoda:

#!/usr/bin/env bash

thepath=$(expanduser $1)

echo $thepath

En basit : 'magic'i' eval echo 'ile değiştirin.

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

Problem: eval kötü olduğu için diğer değişkenlerle ilgili sorunlarla karşılaşacaksınız. Örneğin:

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

Enjeksiyon sorununun ilk genişletmede olmadığını unutmayın. Sadece değiştirmek için eğer öyleyse magicile eval echo, iyi olmalıdır. Ama yaparsanecho $(eval echo ~) , o enjeksiyona yatkın olur.

Benzer şekilde, eval echo ~bunun yerine yaparsanız eval echo "~", bu iki kat genişletilmiş olarak sayılır ve bu nedenle enjeksiyon hemen mümkün olur.

Bunu, read -e kullanarak yolda okuduktan sonra değişken parametre ikamesi ile yaptım (diğerleri arasında). Böylece kullanıcı yolu sekme ile tamamlayabilir ve eğer kullanıcı bir ~ yola girerse sıralanır.

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

Eklenen fayda, eğer tilde yoksa değişkene hiçbir şey olmaz ve tilde varsa, ancak ilk konumda yoksa, bunun da göz ardı edilmesidir.

(Bunu bir döngüde kullandığım için okumak için -i ekledim, böylece kullanıcı bir sorun varsa yolu düzeltebilir.)