Jak ręcznie rozwinąć specjalną zmienną (np. ~ Tyldę) w bash

Mam zmienną w moim skrypcie bash, której wartość jest mniej więcej taka:

~/a/b/c

Zwróć uwagę, że jest to nierozwinięta tylda. Kiedy robię ls -lt na tej zmiennej (nazwij ją $ ​​VAR), nie otrzymuję takiego katalogu. Chcę pozwolić bashowi zinterpretować / rozszerzyć tę zmienną bez jej wykonywania. Innymi słowy, chcę, aby bash uruchamiał eval, ale nie uruchamiał ocenianego polecenia. Czy to możliwe w bash?

Jak udało mi się przekazać to do mojego skryptu bez rozszerzenia? Przekazałem argument, otaczając go podwójnymi cudzysłowami.

Wypróbuj to polecenie, aby zobaczyć, co mam na myśli:

ls -lt "~"

Dokładnie w takiej sytuacji jestem. Chcę, aby tylda została rozszerzona. Innymi słowy, czym powinienem zastąpić magię, aby te dwa polecenia były identyczne:

ls -lt ~/abc/def/ghi

i

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

Zauważ, że ~ / abc / def / ghi może istnieć lub nie.

Ze względu na naturę StackOverflow nie mogę po prostu uczynić tej odpowiedzi nieakceptowaną, ale w ciągu ostatnich 5 lat, odkąd to opublikowałem, pojawiły się o wiele lepsze odpowiedzi niż moja, co prawda, szczątkowa i całkiem zła odpowiedź (byłem młody, nie zabijaj mnie).

Pozostałe rozwiązania w tym wątku są bezpieczniejsze i lepsze. Najlepiej wybrałbym jedną z tych dwóch:

• Rozwiązanie Charle's Duffy'ego
• Rozwiązanie Håkona Hæglanda

Oryginalna odpowiedź do celów historycznych (ale nie używaj jej)

Jeśli się nie mylę, "~"nie zostanie w ten sposób rozwinięty przez skrypt bash, ponieważ jest traktowany jako dosłowny ciąg "~". W ten sposób możesz wymusić ekspansję eval.

#!/bin/bash

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

Alternatywnie, po prostu użyj, ${HOME}jeśli chcesz katalog domowy użytkownika.

Jeśli zmienna varjest wprowadzany przez użytkownika, evalpowinien nie być stosowany w celu rozszerzenia za pomocą tyldy

eval var=$var  # Do not use this!

Powód jest taki: użytkownik może przez przypadek (lub celowo) typ, na przykład var="$(rm -rf $HOME/)"z możliwymi katastrofalnymi konsekwencjami.

Lepszym (i bezpieczniejszym) sposobem jest użycie rozszerzenia parametrów Bash:

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

Plagarowanie się na podstawie wcześniejszej odpowiedzi , aby zrobić to solidnie bez zagrożeń bezpieczeństwa związanych z 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%:}"
}

...użyty jako...

path=$(expandPath '~/hello')

Alternatywnie, prostsze podejście, które wykorzystuje evalostrożnie:

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
}

Bezpiecznym sposobem korzystania z eval jest "$(printf "~/%q" "$dangerous_path")". Zauważ, że jest to specyficzne dla basha.

#!/bin/bash

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

Zobacz to pytanie, aby uzyskać szczegółowe informacje

Zwróć też uwagę, że w przypadku zsh byłoby to tak proste, jak echo ${~dangerous_path}

Co powiesz na to:

path=`realpath "$1"`

Lub:

path=`readlink -f "$1"`

Rozszerzanie (gra słów nie jest zamierzona) na odpowiedziach birryree i halloleo: Ogólne podejście polega na użyciu eval, ale wiąże się z kilkoma ważnymi zastrzeżeniami, a mianowicie spacjami i przekierowaniem wyjścia ( >) w zmiennej. Wydaje mi się, że działa dla mnie:

mypath="$1"

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

Spróbuj z każdym z następujących argumentów:

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

Wyjaśnienie

• ${mypath//>}Wycina >znaków, które mogłyby sprać plik czasie eval.
• To eval echo ...jest to, co robi faktyczna ekspansja tyldy
• Podwójne cudzysłowy wokół -eargumentu służą do obsługi nazw plików ze spacjami.

Być może jest bardziej eleganckie rozwiązanie, ale to właśnie udało mi się wymyślić.

Myślę, że właśnie tego szukasz

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

Przykładowe użycie:

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

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

Oto moje rozwiązanie:

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

Po prostu używaj evalpoprawnie: z walidacją.

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

Najprostsze : zamień „magię” na „eval echo”.

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

Problem: Będziesz mieć problemy z innymi zmiennymi, ponieważ eval jest zły. Na przykład:

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

Zauważ, że problem z wtryskiem nie występuje przy pierwszym rozszerzeniu. Więc jeśli były po prostu zastąpić magicz eval echo, powinno być w porządku. Ale jeśli to zrobisz echo $(eval echo ~), będzie to podatne na zastrzyk.

Podobnie, jeśli to zrobisz eval echo ~zamiast tego eval echo "~", liczy się to jako dwukrotne rozwinięcie, a zatem wstrzyknięcie będzie możliwe od razu.

Oto funkcja równoważna z POSIX Hakon Hægland za bash odpowiedź

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

2017-12-10 edycja: dodaj '%s'w komentarzach @CharlesDuffy.

dlaczego nie zagłębić się bezpośrednio w pobieranie katalogu domowego użytkownika za pomocą getent?

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

Wystarczy rozszerzyć odpowiedź birryree na ścieżki o spacje: Nie można użyć evalpolecenia w takiej postaci, w jakiej jest, ponieważ oddziela ocenę spacjami. Jednym z rozwiązań jest tymczasowe zastąpienie spacji dla polecenia 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

Ten przykład opiera się oczywiście na założeniu, że mypathnigdy nie zawiera sekwencji znaków "_spc_".

Może się to wydawać łatwiejsze w Pythonie.

(1) Z wiersza poleceń unixa:

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

Prowadzi do:

/Users/someone/fred

(2) W ramach skryptu bash jednorazowo - zapisz to jako test.sh:

#!/usr/bin/env bash

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

echo $thepath

Uruchamianie bash ./test.shwyników w:

/Users/someone/fred

(3) Jako narzędzie - zapisz to expandusergdzieś na swojej ścieżce, z uprawnieniami do wykonywania:

#!/usr/bin/env python

import sys
import os

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

Można to następnie użyć w wierszu poleceń:

expanduser ~/fred

Lub w scenariuszu:

#!/usr/bin/env bash

thepath=$(expanduser $1)

echo $thepath

Zrobiłem to z podstawieniem parametrów zmiennych po wczytaniu ścieżki za pomocą read -e (między innymi). Dzięki temu użytkownik może uzupełnić ścieżkę za pomocą tabulatora, a jeśli użytkownik wprowadzi ścieżkę ~, zostanie ona posortowana.

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

Dodatkową korzyścią jest to, że jeśli nie ma tyldy, nic się nie dzieje ze zmienną, a jeśli istnieje tylda, ale nie na pierwszej pozycji, jest ona również ignorowana.

(Dołączam -i do odczytu, ponieważ używam tego w pętli, aby użytkownik mógł naprawić ścieżkę, jeśli wystąpi problem).