Ich bin verwirrt über ein Bash-Skript.

Ich habe folgenden Code:

function grep_search() {
    magic_way_to_define_magic_variable_$1=`ls | tail -1`
    echo $magic_variable_$1
}

Ich möchte in der Lage sein, einen Variablennamen zu erstellen, der das erste Argument des Befehls enthält und den Wert von z. B. der letzten Zeile von trägt ls.

Um zu veranschaulichen, was ich will:

$ ls | tail -1
stack-overflow.txt

$ grep_search() open_box
stack-overflow.txt

Wie soll ich also definieren / deklarieren $magic_way_to_define_magic_variable_$1und wie soll ich es im Skript aufrufen?

Ich habe versucht eval, ${...}, \$${...}, aber ich bin immer noch verwirrt.

Verwenden Sie ein assoziatives Array mit Befehlsnamen als Schlüssel.

# Requires bash 4, though
declare -A magic_variable=()

function grep_search() {
    magic_variable[$1]=$( ls | tail -1 )
    echo ${magic_variable[$1]}
}

Wenn Sie keine assoziativen Arrays verwenden können (z. B. müssen Sie bash3 unterstützen), können Sie declaredynamische Variablennamen erstellen:

declare "magic_variable_$1=$(ls | tail -1)"

und verwenden Sie die indirekte Parametererweiterung, um auf den Wert zuzugreifen.

var="magic_variable_$1"
echo "${!var}"

Siehe BashFAQ: Indirektion - Auswertung indirekter / Referenzvariablen .

Ich habe in letzter Zeit nach einer besseren Möglichkeit gesucht. Assoziatives Array klang für mich wie ein Overkill. Schau mal was ich gefunden habe:

suffix=bzz
declare prefix_$suffix=mystr

...und dann...

varname=prefix_$suffix
echo ${!varname}

Neben assoziativen Arrays gibt es in Bash verschiedene Möglichkeiten, dynamische Variablen zu erzielen. Beachten Sie, dass alle diese Techniken Risiken bergen, die am Ende dieser Antwort erläutert werden.

In den folgenden Beispielen gehe ich davon aus, dass i=37und dass Sie die benannte Variable mit dem var_37Anfangswert aliasisieren möchten lolilol.

Methode 1. Verwenden einer Zeigervariablen

Sie können den Namen der Variablen einfach in einer Indirektionsvariablen speichern, ähnlich wie bei einem C-Zeiger. Bash hat dann eine Syntax zum Lesen der Alias-Variablen: Erweitert ${!name}sich auf den Wert der Variablen, deren Name der Wert der Variablen ist name. Sie können sich das als zweistufige Erweiterung ${!name}vorstellen : erweitert sich zu $var_37, erweitert sich zu lolilol.

name="var_$i"
echo "$name"         # outputs “var_37”
echo "${!name}"      # outputs “lolilol”
echo "${!name%lol}"  # outputs “loli”
# etc.

Leider gibt es keine Gegenstücksyntax für Ändern der Alias-Variablen. Stattdessen können Sie die Zuordnung mit einem der folgenden Tricks erreichen.

1a. Zuweisen miteval

evalist böse, aber auch der einfachste und tragbarste Weg, um unser Ziel zu erreichen. Sie müssen die rechte Seite der Aufgabe vorsichtig verlassen, da sie zweimal ausgewertet wird . Eine einfache und systematische Möglichkeit besteht darin, die rechte Seite vorher zu bewerten (oder zu verwenden printf %q).

Und Sie sollten manuell überprüfen, ob die linke Seite ein gültiger Variablenname oder ein Name mit Index ist (was wäre, wenn dies der Fall wäre evil_code #?). Im Gegensatz dazu erzwingen alle anderen unten aufgeführten Methoden dies automatisch.

# check that name is a valid variable name:
# note: this code does not support variable_name[index]
shopt -s globasciiranges
[[ "$name" == [a-zA-Z_]*([a-zA-Z_0-9]) ]] || exit

value='babibab'
eval "$name"='$value'  # carefully escape the right-hand side!
echo "$var_37"  # outputs “babibab”

Nachteile:

• überprüft nicht die Gültigkeit des Variablennamens.
• eval ist böse
• eval ist böse
• eval ist böse

1b. Zuweisen mitread

Mit dem integrierten readProgramm können Sie einer Variablen, deren Namen Sie geben, Werte zuweisen. Diese Tatsache kann in Verbindung mit Here-Strings ausgenutzt werden:

IFS= read -r -d '' "$name" <<< 'babibab'
echo "$var_37"  # outputs “babibab\n”

Das IFSTeil und die Option -rstellen sicher, dass der Wert unverändert zugewiesen wird, während die Option -d ''das Zuweisen mehrzeiliger Werte ermöglicht. Aufgrund dieser letzten Option wird der Befehl mit einem Exit-Code ungleich Null zurückgegeben.

Beachten Sie, dass, da wir eine Here-Zeichenfolge verwenden, ein Zeilenumbruchzeichen an den Wert angehängt wird.

Nachteile:

• etwas dunkel;
• kehrt mit einem Exit-Code ungleich Null zurück;
• Hängt eine neue Zeile an den Wert an.

1c. Zuweisen mitprintf

Seit Bash 3.1 (veröffentlicht 2005) kann das printfeingebaute Ergebnis auch einer Variablen zugewiesen werden, deren Name angegeben ist. Im Gegensatz zu den vorherigen Lösungen funktioniert es einfach, es ist kein zusätzlicher Aufwand erforderlich, um den Dingen zu entkommen, eine Aufteilung zu verhindern und so weiter.

printf -v "$name" '%s' 'babibab'
echo "$var_37"  # outputs “babibab”

Nachteile:

• Weniger tragbar (aber gut).

Methode 2. Verwenden einer Referenzvariablen

Seit Bash 4.3 (veröffentlicht 2014) verfügt das integrierte declareProgramm über eine Option -nzum Erstellen einer Variablen, die eine „Namensreferenz“ zu einer anderen Variablen darstellt, ähnlich wie C ++ - Referenzen. Genau wie in Methode 1 speichert die Referenz den Namen der Alias-Variablen, aber jedes Mal, wenn auf die Referenz zugegriffen wird (entweder zum Lesen oder zum Zuweisen), löst Bash die Indirektion automatisch auf.

Darüber hinaus verfügt Bash über eine spezielle und sehr verwirrende Syntax, um den Wert der Referenz selbst zu ermitteln ${!ref}.

declare -n ref="var_$i"
echo "${!ref}"  # outputs “var_37”
echo "$ref"     # outputs “lolilol”
ref='babibab'
echo "$var_37"  # outputs “babibab”

Dies vermeidet nicht die unten erläuterten Fallstricke, macht aber zumindest die Syntax einfach.

Nachteile:

• Nicht tragbar.

Risiken

Alle diese Aliasing-Techniken bergen verschiedene Risiken. Der erste führt jedes Mal beliebigen Code aus, wenn Sie die Indirektion auflösen (entweder zum Lesen oder zum Zuweisen) . Anstelle eines skalaren Variablennamens wie var_37können Sie auch einen Array-Index wie verwenden arr[42]. Bash wertet den Inhalt der eckigen Klammern jedoch jedes Mal aus, wenn er benötigt wird, sodass Aliasing arr[$(do_evil)]unerwartete Auswirkungen hat. Verwenden Sie diese Techniken daher nur, wenn Sie die Herkunft des Alias ​​steuern .

function guillemots() {
  declare -n var="$1"
  var="«${var}»"
}

arr=( aaa bbb ccc )
guillemots 'arr[1]'  # modifies the second cell of the array, as expected
guillemots 'arr[$(date>>date.out)1]'  # writes twice into date.out
            # (once when expanding var, once when assigning to it)

Das zweite Risiko besteht darin, einen zyklischen Alias ​​zu erstellen. Da Bash-Variablen durch ihren Namen und nicht durch ihren Bereich identifiziert werden, können Sie versehentlich einen Alias ​​für sich selbst erstellen (während Sie denken, dass dies eine Variable aus einem umschließenden Bereich alias wäre). Dies kann insbesondere bei Verwendung allgemeiner Variablennamen (wie var) geschehen . Als Folge verwendet nur diese Techniken , wenn Sie den Namen des Alias - Variable steuern .

function guillemots() {
  # var is intended to be local to the function,
  # aliasing a variable which comes from outside
  declare -n var="$1"
  var="«${var}»"
}

var='lolilol'
guillemots var  # Bash warnings: “var: circular name reference”
echo "$var"     # outputs anything!

Quelle:

• BashFaq / 006: Wie kann ich Variablenvariablen (indirekte Variablen, Zeiger, Referenzen) oder assoziative Arrays verwenden?
• BashFAQ / 048: Auswertungsbefehls- und Sicherheitsprobleme

Das folgende Beispiel gibt den Wert von $ name_of_var zurück

var=name_of_var
echo $(eval echo "\$$var")

Das sollte funktionieren:

function grep_search() {
    declare magic_variable_$1="$(ls | tail -1)"
    echo "$(tmpvar=magic_variable_$1 && echo ${!tmpvar})"
}
grep_search var  # calling grep_search with argument "var"

Das wird auch funktionieren

my_country_code="green"
x="country"

eval z='$'my_"$x"_code
echo $z                 ## o/p: green

In deinem Fall

eval final_val='$'magic_way_to_define_magic_variable_"$1"
echo $final_val

Wie pro BashFAQ / 006 , können Sie readmit hier String - Syntax für die Zuordnung von indirekten Variablen:

function grep_search() {
  read "$1" <<<$(ls | tail -1);
}

Verwendung:

$ grep_search open_box
$ echo $open_box
stack-overflow.txt

Verwenden declare

Es ist nicht erforderlich, Präfixe wie bei anderen Antworten oder Arrays zu verwenden. Verwenden Sie nur declare, doppelte Anführungszeichen und Parameter Expansion .

Ich verwende oft den folgenden Trick, um Argumentlisten zu analysieren, die Argumente enthalten , die wie folgt one to nformatiert key=value otherkey=othervalue etc=etcsind:

# brace expansion just to exemplify
for variable in {one=foo,two=bar,ninja=tip}
do
  declare "${variable%=*}=${variable#*=}"
done
echo $one $two $ninja 
# foo bar tip

Aber die argv liste erweitern wie

for v in "$@"; do declare "${v%=*}=${v#*=}"; done

Zusätzliche Tipps

# parse argv's leading key=value parameters
for v in "$@"; do
  case "$v" in ?*=?*) declare "${v%=*}=${v#*=}";; *) break;; esac
done
# consume argv's leading key=value parameters
while (( $# )); do
  case "$v" in ?*=?*) declare "${v%=*}=${v#*=}";; *) break;; esac
  shift
done

Wow, der größte Teil der Syntax ist schrecklich! Hier ist eine Lösung mit einer einfacheren Syntax, wenn Sie indirekt auf Arrays verweisen müssen:

#!/bin/bash

foo_1=("fff" "ddd") ;
foo_2=("ggg" "ccc") ;

for i in 1 2 ;
do
    eval mine=( \${foo_$i[@]} ) ;
    echo ${mine[@]} ;
done ;

Für einfachere Anwendungsfälle empfehle ich die im Advanced Bash-Scripting Guide beschriebene Syntax .

Für indizierte Arrays können Sie sie wie folgt referenzieren:

foo=(a b c)
bar=(d e f)

for arr_var in 'foo' 'bar'; do
    declare -a 'arr=("${'"$arr_var"'[@]}")'
    # do something with $arr
    echo "\$$arr_var contains:"
    for char in "${arr[@]}"; do
        echo "$char"
    done
done

Assoziative Arrays können in ähnlicher Weise angesprochen werden , sondern müssen den -ASchalter auf declarestatt -a.

Eine zusätzliche Methode, die nicht von der Shell- / Bash-Version abhängt, ist die Verwendung envsubst. Beispielsweise:

newvar=$(echo '$magic_variable_'"${dynamic_part}" | envsubst)

Ich möchte in der Lage sein, einen Variablennamen zu erstellen, der das erste Argument des Befehls enthält

script.sh Datei:

#!/usr/bin/env bash
function grep_search() {
  eval $1=$(ls | tail -1)
}

Prüfung:

$ source script.sh
$ grep_search open_box
$ echo $open_box
script.sh

Wie folgt help eval:

Führen Sie Argumente als Shell-Befehl aus.

Sie können ${!var}, wie bereits erwähnt, auch die indirekte Bash- Erweiterung verwenden, sie unterstützt jedoch nicht das Abrufen von Array-Indizes.

Weitere Informationen oder Beispiele finden Sie in BashFAQ / 006 zur Indirektion .

Uns ist kein Trick bekannt, mit dem diese Funktionalität in POSIX- oder Bourne-Shells ohne dupliziert werden kann eval, was sicher schwierig sein kann. Also, halten dies für eine Nutzung auf eigene Gefahr Hack .

Sie sollten jedoch die Verwendung der Indirektion gemäß den folgenden Hinweisen erneut in Betracht ziehen.

Normalerweise benötigen Sie beim Bash-Scripting überhaupt keine indirekten Verweise. Im Allgemeinen suchen Benutzer nach einer Lösung, wenn sie Bash-Arrays nicht verstehen oder nicht kennen oder andere Bash-Funktionen wie Funktionen nicht vollständig berücksichtigt haben.

Das Einfügen von Variablennamen oder anderer Bash-Syntax in Parameter erfolgt häufig falsch und in unangemessenen Situationen, um Probleme mit besseren Lösungen zu lösen. Es verstößt gegen die Trennung zwischen Code und Daten und bringt Sie als solche auf einen rutschigen Hang zu Fehlern und Sicherheitsproblemen. Indirektion kann dazu führen, dass Ihr Code weniger transparent und schwerer zu befolgen ist.

varname=$prefix_suffixVerwenden Sie für das Format einfach:

varname=${prefix}_suffix