Come espandere manualmente una variabile speciale (es: ~ tilde) in bash

Ho una variabile nel mio script bash il cui valore è qualcosa del genere:

~/a/b/c

Si noti che è una tilde non espansa. Quando faccio ls -lt su questa variabile (lo chiamo $ VAR), non ottengo tale directory. Voglio lasciare bash interpretare / espandere questa variabile senza eseguirla. In altre parole, voglio che bash esegua eval ma non esegua il comando valutato. È possibile in bash?

Come sono riuscito a passare questo nel mio script senza espansione? Ho superato l'argomento circondandolo con doppie virgolette.

Prova questo comando per vedere cosa intendo:

ls -lt "~"

Questa è esattamente la situazione in cui mi trovo. Voglio che la tilde si espanda. In altre parole, con cosa dovrei sostituire la magia per rendere identici questi due comandi:

ls -lt ~/abc/def/ghi

e

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

Si noti che ~ / abc / def / ghi potrebbe esistere o meno.

A causa della natura di StackOverflow, non posso semplicemente rendere questa risposta non accettata, ma negli ultimi 5 anni da quando l'ho pubblicata ci sono state risposte di gran lunga migliori della mia risposta dichiaratamente rudimentale e piuttosto cattiva (ero giovane, non uccidere me).

Le altre soluzioni in questo thread sono soluzioni più sicure e migliori. Preferibilmente, andrei con uno di questi due:

• La soluzione di Charle's Duffy
• La soluzione di Håkon Hægland

Risposta originale per scopi storici (ma per favore non usare questo)

Se non sbaglio, "~"non verrà espanso da uno script bash in quel modo perché viene trattato come una stringa letterale "~". Puoi forzare l'espansione in evalquesto modo.

#!/bin/bash

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

In alternativa, utilizzare solo ${HOME}se si desidera la home directory dell'utente.

Se la variabile varviene inserita dall'utente, noneval deve essere utilizzata per espandere la tilde mediante

eval var=$var  # Do not use this!

Il motivo è: l'utente potrebbe accidentalmente (o di proposito) digitare ad esempio var="$(rm -rf $HOME/)"con possibili conseguenze disastrose.

Un modo migliore (e più sicuro) è usare l'espansione dei parametri di Bash:

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

Plagarando me stesso da una risposta precedente , per farlo in modo robusto senza i rischi per la sicurezza associati a 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%:}"
}

...usato come...

path=$(expandPath '~/hello')

In alternativa, un approccio più semplice che utilizza evalcon attenzione:

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
}

Un modo sicuro per usare eval è "$(printf "~/%q" "$dangerous_path")". Nota che è specifico per bash.

#!/bin/bash

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

Vedi questa domanda per i dettagli

Inoltre, nota che sotto zsh questo sarebbe semplice come echo ${~dangerous_path}

Cosa ne pensi di questo:

path=`realpath "$1"`

O:

path=`readlink -f "$1"`

Espandere (nessun gioco di parole previsto) sulle risposte di birryree e halloleo: l'approccio generale è usare eval, ma viene fornito con alcuni avvertimenti importanti, vale a dire gli spazi e il reindirizzamento dell'output ( >) nella variabile. Quanto segue sembra funzionare per me:

mypath="$1"

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

Provalo con ciascuno dei seguenti argomenti:

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

Spiegazione

• Il ${mypath//>}strisce fuori >i caratteri che potrebbe massacravano un file durante il eval.
• La eval echo ...è quello che esegue l'espansione tilde effettivo
• Le doppie virgolette intorno -eall'argomento servono per supportare nomi di file con spazi.

Forse c'è una soluzione più elegante, ma è quello che sono riuscito a trovare.

Credo che questo sia quello che stai cercando

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

Esempio di utilizzo:

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

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

Ecco la mia soluzione:

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

Basta usare evalcorrettamente: con validazione.

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

Ecco l'equivalente della funzione POSIX della risposta Bash di Håkon Hægland

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

10-12-2017 modifica: aggiungi '%s'per @CharlesDuffy nei commenti.

perché non approfondire direttamente su come ottenere la home directory dell'utente con getent?

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

Solo per estendere la risposta di birryree per i percorsi con spazi: non è possibile utilizzare il evalcomando così com'è perché separa la valutazione dagli spazi. Una soluzione è sostituire temporaneamente gli spazi per il comando 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

Questo esempio si basa ovviamente sul presupposto che mypathnon contiene mai la sequenza di caratteri "_spc_".

Potresti trovare questo più facile da fare in Python.

(1) Dalla riga di comando unix:

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

Risultati in:

/Users/someone/fred

(2) All'interno di uno script bash come una tantum - salvalo come test.sh:

#!/usr/bin/env bash

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

echo $thepath

Esecuzione bash ./test.shrisultati in:

/Users/someone/fred

(3) Come utility - salvalo come expanduserda qualche parte sul tuo percorso, con autorizzazioni di esecuzione:

#!/usr/bin/env python

import sys
import os

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

Questo potrebbe quindi essere utilizzato sulla riga di comando:

expanduser ~/fred

O in una sceneggiatura:

#!/usr/bin/env bash

thepath=$(expanduser $1)

echo $thepath

Più semplice : sostituisci "magia" con "eval echo".

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

Problema: incontrerai problemi con altre variabili perché eval è malvagio. Per esempio:

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

Si noti che il problema dell'iniezione non si verifica alla prima espansione. Quindi, se si dovesse sostituire semplicemente magiccon eval echo, si dovrebbe essere a posto. Ma se lo faiecho $(eval echo ~) , sarebbe suscettibile all'iniezione.

Allo stesso modo, se lo fai eval echo ~invece di eval echo "~"quello, verrebbe conteggiato come due volte espanso e quindi l'iniezione sarebbe possibile immediatamente.

L'ho fatto con la sostituzione di parametri variabili dopo aver letto il percorso usando read -e (tra gli altri). In questo modo l'utente può completare il tab in modo completo e se l'utente immette un percorso ~ viene ordinato.

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

Il vantaggio aggiunto è che se non c'è tilde non succede nulla alla variabile, e se c'è una tilde ma non nella prima posizione, viene anche ignorato.

(Includo -i per la lettura poiché lo uso in un ciclo in modo che l'utente possa correggere il percorso in caso di problemi.)