Cómo expandir manualmente una variable especial (ej: ~ tilde) en bash

Tengo una variable en mi script bash cuyo valor es algo como esto:

~/a/b/c

Tenga en cuenta que es tilde sin expandir. Cuando hago ls -lt en esta variable (lo llamo $ VAR), no obtengo tal directorio. Quiero dejar que bash interprete / expanda esta variable sin ejecutarla. En otras palabras, quiero que bash ejecute eval pero no ejecute el comando evaluado. ¿Es esto posible en bash?

¿Cómo logré pasar esto a mi script sin expansión? Pasé el argumento rodeándolo con comillas dobles.

Prueba este comando para ver a qué me refiero:

ls -lt "~"

Esta es exactamente la situación en la que estoy. Quiero que se expanda la tilde. En otras palabras, ¿con qué debería reemplazar la magia para hacer que estos dos comandos sean idénticos:

ls -lt ~/abc/def/ghi

y

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

Tenga en cuenta que ~ / abc / def / ghi puede o no existir.

Debido a la naturaleza de StackOverflow, no puedo simplemente hacer que esta respuesta sea inaceptable, pero en los 5 años transcurridos desde que publiqué esto, ha habido respuestas mucho mejores que mi respuesta ciertamente rudimentaria y bastante mala (era joven, no mate yo).

Las otras soluciones en este hilo son soluciones más seguras y mejores. Preferiblemente, iría con cualquiera de estos dos:

• La solución de Charle Duffy
• La solución de Håkon Hægland

Respuesta original para fines históricos (pero no use esto)

Si no me equivoco, "~"un script bash no lo expandirá de esa manera porque se trata como una cadena literal "~". Puede forzar la expansión de evalesta manera.

#!/bin/bash

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

Alternativamente, solo use ${HOME}si desea el directorio de inicio del usuario.

Si la variable vares de entrada por el usuario, evaldebe no ser utilizado para expandir el tilde usando

eval var=$var  # Do not use this!

La razón es: el usuario podría escribir por accidente (o por propósito), por ejemplo, var="$(rm -rf $HOME/)"con posibles consecuencias desastrosas.

Una forma mejor (y más segura) es usar la expansión de parámetros Bash:

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

Plagarme de una respuesta anterior , para hacer esto de manera robusta sin los riesgos de seguridad asociados con 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')

Alternativamente, un enfoque más simple que utiliza con 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
}

Una forma segura de usar eval es "$(printf "~/%q" "$dangerous_path")". Tenga en cuenta que es bash específico.

#!/bin/bash

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

Ver esta pregunta para más detalles

Además, tenga en cuenta que bajo zsh esto sería tan simple como echo ${~dangerous_path}

Qué tal esto:

path=`realpath "$1"`

O:

path=`readlink -f "$1"`

Ampliación (sin juego de palabras) en las respuestas de birryree y halloleo: el enfoque general es usar eval, pero viene con algunas advertencias importantes, a saber, espacios y redirección de salida ( >) en la variable. Lo siguiente parece funcionar para mí:

mypath="$1"

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

Pruébelo con cada uno de los siguientes argumentos:

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

Explicación

• La ${mypath//>}excluye los >caracteres que podrían Clobber un archivo durante el eval.
• Esto eval echo ...es lo que hace la expansión tilde real
• Las comillas dobles alrededor del -eargumento son para soportar nombres de archivos con espacios.

Quizás haya una solución más elegante, pero esto es lo que pude encontrar.

Creo que esto es lo que estás buscando.

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

Ejemplo de uso:

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

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

Aquí está mi solución:

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

Solo use evalcorrectamente: con validación.

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

Aquí está la función POSIX equivalente a la respuesta Bash de Håkon Hægland

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

2017-12-10 edit: agregar '%s'por @CharlesDuffy en los comentarios.

¿por qué no profundizar directamente en obtener el directorio de inicio del usuario con getent?

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

Solo para extender la respuesta de birryree para rutas con espacios: No puede usar el evalcomando tal como está porque separa la evaluación por espacios. Una solución es reemplazar espacios temporalmente para el 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 ejemplo se basa, por supuesto, en el supuesto de que mypathnunca contiene la secuencia de caracteres "_spc_".

Puede encontrar esto más fácil de hacer en Python.

(1) Desde la línea de comando de Unix:

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

Resultados en:

/Users/someone/fred

(2) Dentro de un script bash como único: guarde esto 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 en ejecución en:

/Users/someone/fred

(3) Como una utilidad: guarde esto como en expanduseralgún lugar de su ruta, con permisos de ejecución:

#!/usr/bin/env python

import sys
import os

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

Esto podría usarse en la línea de comando:

expanduser ~/fred

O en un guión:

#!/usr/bin/env bash

thepath=$(expanduser $1)

echo $thepath

Más simple : reemplace 'magia' con 'eval echo'.

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

Problema: Te encontrarás con problemas con otras variables porque eval es malo. Por ejemplo:

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

Tenga en cuenta que el problema de la inyección no ocurre en la primera expansión. Entonces, si simplemente reemplazaras magiccon eval echo, deberías estar bien. Pero si lo hace echo $(eval echo ~), eso sería susceptible a la inyección.

Del mismo modo, si lo hace en eval echo ~lugar de eval echo "~", eso contaría como dos veces expandido y, por lo tanto, la inyección sería posible de inmediato.

He hecho esto con la sustitución de parámetros variables después de leer en la ruta usando read -e (entre otros). Por lo tanto, el usuario puede completar la ruta con pestañas, y si el usuario ingresa una ruta ~ se ordena.

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

El beneficio adicional es que si no hay tilde no pasa nada a la variable, y si hay una tilde pero no en la primera posición, también se ignora.

(Incluyo el -i para leer, ya que lo uso en un bucle para que el usuario pueda corregir la ruta si hay un problema).