Como expandir manualmente uma variável especial (ex: ~ til) no bash

Eu tenho uma variável no meu script bash cujo valor é algo como isto:

~/a/b/c

Observe que é um til não expandido. Quando eu faço ls -lt nessa variável (chame-a de $ VAR), não recebo esse diretório. Eu quero deixar o bash interpretar / expandir essa variável sem executá-la. Em outras palavras, quero que o bash execute eval, mas não execute o comando avaliado. Isso é possível no bash?

Como consegui passar isso para o meu script sem expansão? Passei o argumento entre aspas duplas.

Tente este comando para ver o que quero dizer:

ls -lt "~"

Esta é exatamente a situação em que estou. Quero que o til seja expandido. Em outras palavras, com o que devo substituir a magia para tornar esses dois comandos idênticos:

ls -lt ~/abc/def/ghi

e

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

Observe que ~ / abc / def / ghi pode ou não existir.

Devido à natureza do StackOverflow, não posso apenas tornar essa resposta inaceitável, mas nos cinco anos seguintes que publiquei isso houve respostas muito melhores do que a minha resposta admitidamente rudimentar e muito ruim (eu era jovem, não mate mim).

As outras soluções neste segmento são melhores e mais seguras. De preferência, eu iria com um destes dois:

• A solução de Charle's Duffy
• A solução de Håkon Hægland

Resposta original para fins históricos (mas não use isso)

Se não me engano, "~"não será expandido por um script bash dessa maneira porque é tratado como uma string literal "~". Você pode forçar a expansão evaldessa maneira.

#!/bin/bash

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

Como alternativa, basta usar ${HOME}se você quiser o diretório inicial do usuário.

Se a variável varfor inserida pelo usuário, nãoeval deve ser usado para expandir o til usando

eval var=$var  # Do not use this!

O motivo é: o usuário pode acidentalmente (ou por objetivo) digitar, por exemplo, var="$(rm -rf $HOME/)"com possíveis conseqüências desastrosas.

Uma maneira melhor (e mais segura) é usar a expansão do parâmetro Bash:

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

Plagar-me a partir de uma resposta anterior , para fazer isso de maneira robusta, sem os riscos de segurança associados 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%:}"
}

...usado como...

path=$(expandPath '~/hello')

Como alternativa, uma abordagem mais simples que use com evalcuidado:

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
}

Uma maneira segura de usar eval é "$(printf "~/%q" "$dangerous_path")". Observe que é específico do bash.

#!/bin/bash

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

Veja esta pergunta para detalhes

Observe também que, no zsh, isso seria tão simples quanto echo ${~dangerous_path}

Que tal agora:

path=`realpath "$1"`

Ou:

path=`readlink -f "$1"`

Expandir (sem trocadilhos) as respostas de birryree e halloleo: A abordagem geral é usar eval, mas vem com algumas advertências importantes, como espaços e redirecionamento de saída ( >) na variável. O seguinte parece funcionar para mim:

mypath="$1"

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

Experimente com cada um dos seguintes argumentos:

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

Explicação

• O ${mypath//>}retira >personagens que poderia espancar um arquivo durante a eval.
• O eval echo ...que é a expansão de til atual
• As aspas duplas ao redor do -eargumento são para suporte de nomes de arquivos com espaços.

Talvez exista uma solução mais elegante, mas foi isso que consegui encontrar.

Eu acredito que é isso que você está procurando

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

Exemplo de uso:

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

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

Aqui está a minha solução:

#!/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 usar evalcorretamente: com validação.

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

Aqui está a função POSIX equivalente à resposta Bash de Håkon Hægland

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

10-12-2017 editar: adicione '%s'por @CharlesDuffy nos comentários.

por que não investigar diretamente o diretório home do usuário com o getent?

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

Apenas para estender a resposta da birryree para caminhos com espaços: Você não pode usar o evalcomando como está, porque ele separa a avaliação por espaços. Uma solução é substituir espaços temporariamente pelo 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

Este exemplo depende, é claro, da suposição de que mypathnunca contém a sequência de caracteres "_spc_".

Você pode achar isso mais fácil de fazer em python.

(1) Na linha de comando do unix:

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

Resulta em:

/Users/someone/fred

(2) Dentro de um script bash como único - salve-o como test.sh:

#!/usr/bin/env bash

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

echo $thepath

bash ./test.shResultados em execução :

/Users/someone/fred

(3) Como um utilitário - salve-o como expanduserum local no seu caminho, com permissões de execução:

#!/usr/bin/env python

import sys
import os

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

Isso poderia ser usado na linha de comando:

expanduser ~/fred

Ou em um script:

#!/usr/bin/env bash

thepath=$(expanduser $1)

echo $thepath

Mais simples : substitua 'magic' por 'eval echo'.

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

Problema: você terá problemas com outras variáveis ​​porque avaliar é mau. Por exemplo:

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

Observe que o problema da injeção não ocorre na primeira expansão. Então, se você tivesse que substituir simplesmente magiccom eval echo, você deve estar bem. Mas se você fizer echo $(eval echo ~)isso, seria suscetível à injeção.

Da mesma forma, se você fizer isso eval echo ~, em vez de eval echo "~", que contam como duas vezes ampliada e, portanto, a injeção seria possível de imediato.

Eu fiz isso com a substituição de parâmetro variável depois de ler no caminho usando read -e (entre outros). Assim, o usuário pode preencher com tabulação o caminho e, se o usuário digitar um ~ caminho, será classificado.

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

O benefício adicional é que, se não houver til, nada acontece à variável e, se houver um til, mas não na primeira posição, ele também será ignorado.

(Incluo o -i para leitura, pois o uso em loop, para que o usuário possa corrigir o caminho se houver algum problema.)