So erweitern Sie eine spezielle Variable (z. B. ~ tilde) manuell in bash

Ich habe eine Variable in meinem Bash-Skript, deren Wert ungefähr so ​​lautet:

~/a/b/c

Beachten Sie, dass es sich um eine nicht erweiterte Tilde handelt. Wenn ich ls -lt für diese Variable mache (nenne es $ VAR), bekomme ich kein solches Verzeichnis. Ich möchte bash diese Variable interpretieren / erweitern lassen, ohne sie auszuführen. Mit anderen Worten, ich möchte, dass bash eval ausführt, aber den ausgewerteten Befehl nicht ausführt. Ist das in Bash möglich?

Wie habe ich es geschafft, dies ohne Erweiterung in mein Skript zu übertragen? Ich habe das Argument bestanden, indem ich es mit doppelten Anführungszeichen umgeben habe.

Versuchen Sie diesen Befehl, um zu sehen, was ich meine:

ls -lt "~"

Dies ist genau die Situation, in der ich mich befinde. Ich möchte, dass die Tilde erweitert wird. Mit anderen Worten, durch was soll ich Magie ersetzen, um diese beiden Befehle identisch zu machen:

ls -lt ~/abc/def/ghi

und

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

Beachten Sie, dass ~ / abc / def / ghi möglicherweise existiert oder nicht.

Aufgrund der Natur von StackOverflow kann ich diese Antwort nicht einfach nicht akzeptieren, aber in den letzten 5 Jahren, seit ich dies gepostet habe, gab es weitaus bessere Antworten als meine zugegebenermaßen rudimentäre und ziemlich schlechte Antwort (ich war jung, töte nicht mich).

Die anderen Lösungen in diesem Thread sind sicherere und bessere Lösungen. Am liebsten würde ich mit einem dieser beiden gehen:

• Charles Duffys Lösung
• Die Lösung von Håkon Hægland

Ursprüngliche Antwort für historische Zwecke (aber bitte nicht verwenden)

Wenn ich mich nicht irre, "~"wird es auf diese Weise nicht durch ein Bash-Skript erweitert, da es als Literalzeichenfolge behandelt wird "~". Sie können die Erweiterung auf evaldiese Weise erzwingen .

#!/bin/bash

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

Alternativ können Sie auch einfach verwenden, ${HOME}wenn Sie das Home-Verzeichnis des Benutzers möchten.

Wenn die Variable varvom Benutzer eingegeben wird, evalsollte sie nicht zum Erweitern der Tilde mit verwendet werden

eval var=$var  # Do not use this!

Der Grund ist: Der Benutzer könnte versehentlich (oder absichtlich) tippen, zum Beispiel var="$(rm -rf $HOME/)"mit möglichen katastrophalen Folgen.

Eine bessere (und sicherere) Möglichkeit ist die Verwendung der Bash-Parametererweiterung:

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

Ich plagarisiere mich von einer vorherigen Antwort , um dies ohne die Sicherheitsrisiken zu tun, die mit Folgendem verbunden sind 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%:}"
}

...benutzt als...

path=$(expandPath '~/hello')

Alternativ ein einfacherer Ansatz, der evalsorgfältig verwendet:

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
}

Ein sicherer Weg, eval zu verwenden, ist "$(printf "~/%q" "$dangerous_path")". Beachten Sie, dass dies bash-spezifisch ist.

#!/bin/bash

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

Siehe diese Frage für Details

Beachten Sie auch, dass dies unter zsh so einfach wie wäre echo ${~dangerous_path}

Wie wäre es damit:

path=`realpath "$1"`

Oder:

path=`readlink -f "$1"`

Erweitern (kein Wortspiel beabsichtigt) der Antworten von Birryree und Halloleo: Der allgemeine Ansatz ist die Verwendung eval, enthält jedoch einige wichtige Einschränkungen, nämlich Leerzeichen und Ausgabeumleitung ( >) in der Variablen. Folgendes scheint für mich zu funktionieren:

mypath="$1"

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

Versuchen Sie es mit jedem der folgenden Argumente:

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

Erläuterung

• Die ${mypath//>}Streifen aus >Zeichen , die eine Datei während des clobber könnte eval.
• Das eval echo ...ist es, was die eigentliche Tilde-Erweiterung bewirkt
• Die doppelten Anführungszeichen um das -eArgument dienen zur Unterstützung von Dateinamen mit Leerzeichen.

Vielleicht gibt es eine elegantere Lösung, aber das konnte ich mir einfallen lassen.

Ich glaube, das ist es, wonach du suchst

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

Anwendungsbeispiel:

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

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

Hier ist meine Lösung:

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

Einfach evalrichtig verwenden: mit Validierung.

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

Hier ist das POSIX-Funktionsäquivalent zu Håkon Hæglands Bash- Antwort

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

2017-12-10 bearbeiten: '%s'per @CharlesDuffy in den Kommentaren hinzufügen .

Warum nicht gleich mit getent in das Home-Verzeichnis des Benutzers eintauchen?

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

Nur um die Antwort von birryree für Pfade mit Leerzeichen zu erweitern: Sie können den evalBefehl nicht unverändert verwenden , da er die Auswertung nach Leerzeichen trennt. Eine Lösung besteht darin, Leerzeichen für den Befehl eval vorübergehend zu ersetzen:

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

Dieses Beispiel basiert natürlich auf der Annahme, dass mypathdie Zeichenfolge niemals enthalten ist "_spc_".

Möglicherweise ist dies in Python einfacher.

(1) Über die Unix-Befehlszeile:

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

Ergebnisse in:

/Users/someone/fred

(2) Innerhalb eines Bash-Skripts als einmalig - speichern Sie dies als test.sh:

#!/usr/bin/env bash

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

echo $thepath

Laufende bash ./test.shErgebnisse in:

/Users/someone/fred

(3) Als Dienstprogramm - speichern Sie dies als expanduserirgendwo auf Ihrem Pfad mit Ausführungsberechtigungen:

#!/usr/bin/env python

import sys
import os

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

Dies könnte dann in der Kommandozeile verwendet werden:

expanduser ~/fred

Oder in einem Skript:

#!/usr/bin/env bash

thepath=$(expanduser $1)

echo $thepath

Am einfachsten : Ersetzen Sie "Magie" durch "Eval Echo".

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

Problem: Sie werden auf Probleme mit anderen Variablen stoßen, weil die Bewertung böse ist. Zum Beispiel:

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

Beachten Sie, dass das Problem der Injektion bei der ersten Erweiterung nicht auftritt. Also , wenn Sie sind einfach ersetzen magicmit eval echo, sollten Sie in Ordnung sein. Wenn Sie dies jedoch tun echo $(eval echo ~), ist dies anfällig für Injektionen.

Wenn Sie dies eval echo ~stattdessen tun eval echo "~", würde dies als doppelt erweitert gelten und daher wäre eine Injektion sofort möglich.

Ich habe dies mit variabler Parameterersetzung getan, nachdem ich den Pfad unter anderem mit read -e eingelesen habe. So kann der Benutzer den Pfad auf der Registerkarte vervollständigen, und wenn der Benutzer einen ~ -Pfad eingibt, wird dieser sortiert.

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

Der zusätzliche Vorteil besteht darin, dass mit der Variablen nichts passiert, wenn keine Tilde vorhanden ist. Wenn eine Tilde vorhanden ist, sich jedoch nicht an der ersten Position befindet, wird sie ebenfalls ignoriert.

(Ich füge das -i zum Lesen ein, da ich es in einer Schleife verwende, damit der Benutzer den Pfad korrigieren kann, wenn ein Problem auftritt.)