Sono confuso su uno script bash.

Ho il codice seguente:

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

Voglio essere in grado di creare un nome di variabile contenente il primo argomento del comando e recante ad esempio il valore dell'ultima riga di ls.

Quindi per illustrare ciò che voglio:

$ ls | tail -1
stack-overflow.txt

$ grep_search() open_box
stack-overflow.txt

Quindi, come devo definire / dichiarare $magic_way_to_define_magic_variable_$1e come dovrei chiamarlo all'interno dello script?

Ho cercato eval, ${...}, \$${...}, ma io sono ancora confuso.

Utilizzare un array associativo, con i nomi dei comandi come chiavi.

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

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

Se non è possibile utilizzare array associativi (ad esempio, è necessario supportare bash3), è possibile utilizzare declareper creare nomi di variabili dinamici:

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

e utilizzare l'espansione dei parametri indiretti per accedere al valore.

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

Vedi BashFAQ: Indirection - Valutazione delle variabili indirette / di riferimento .

Ho cercato un modo migliore per farlo di recente. L'array associativo mi è sembrato eccessivo. Guardate cosa ho trovato:

suffix=bzz
declare prefix_$suffix=mystr

...e poi...

varname=prefix_$suffix
echo ${!varname}

Oltre agli array associativi, ci sono diversi modi per ottenere variabili dinamiche in Bash. Si noti che tutte queste tecniche presentano rischi, che sono discussi alla fine di questa risposta.

Negli esempi seguenti assumerò che i=37e che si desidera alias della variabile denominata il var_37cui valore iniziale è lolilol.

Metodo 1. Utilizzo di una variabile "puntatore"

Puoi semplicemente memorizzare il nome della variabile in una variabile indiretta, non diversamente da un puntatore C. Bash ha quindi una sintassi per leggere la variabile con alias: si ${!name}espande al valore della variabile il cui nome è il valore della variabile name. Puoi pensarlo come un'espansione in due fasi: si ${!name}espande in $var_37, che si espande in lolilol.

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

Sfortunatamente, non esiste sintassi di controparte per la modifica la variabile con alias. Invece, puoi ottenere un incarico con uno dei seguenti trucchi.

1 bis. Assegnare coneval

evalè malvagio, ma è anche il modo più semplice e portatile per raggiungere il nostro obiettivo. Devi scappare con cura dal lato destro dell'incarico, poiché verrà valutato due volte . Un modo semplice e sistematico per farlo è quello di valutare in anticipo il lato destro (o di usarloprintf %q ).

E dovresti verificare manualmente che il lato sinistro sia un nome di variabile valido o un nome con indice (e se fosse evil_code #?). Al contrario, tutti gli altri metodi seguenti lo applicano automaticamente.

# 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”

Svantaggi:

• non verifica la validità del nome della variabile.
• eval è malvagio.
• eval è malvagio.
• eval è malvagio.

1b. Assegnare conread

Il readbuiltin ti consente di assegnare valori a una variabile di cui dai il nome, un fatto che può essere sfruttato insieme alle stringhe qui:

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

La IFSparte e l'opzione -rassicurano che il valore sia assegnato così com'è, mentre l'opzione -d ''consente di assegnare valori multilinea. A causa di quest'ultima opzione, il comando restituisce con un codice di uscita diverso da zero.

Si noti che, poiché stiamo usando una stringa qui, un valore di nuova riga viene aggiunto al valore.

Svantaggi:

• un po 'oscuro;
• ritorna con un codice di uscita diverso da zero;
• aggiunge una nuova riga al valore.

1 quater. Assegnare conprintf

A partire da Bash 3.1 (rilasciato nel 2005), l' printfintegrato può anche assegnare il suo risultato a una variabile il cui nome è dato. Contrariamente alle soluzioni precedenti, funziona, non è necessario alcuno sforzo aggiuntivo per sfuggire alle cose, prevenire la scissione e così via.

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

Svantaggi:

• Meno portatile (ma, bene).

Metodo 2. Utilizzo di una variabile di "riferimento"

Dalla versione 4.3 di Bash (rilasciata nel 2014), l' declareintegrato ha un'opzione -nper creare una variabile che è un "riferimento al nome" per un'altra variabile, proprio come i riferimenti C ++. Proprio come nel Metodo 1, il riferimento memorizza il nome della variabile con alias, ma ogni volta che si accede al riferimento (sia per la lettura che per l'assegnazione), Bash risolve automaticamente il riferimento indiretto.

Inoltre, Bash ha un particolare e sintassi molto confusa per ottenere il valore del riferimento stesso, giudice da soli: ${!ref}.

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

Questo non evita le insidie ​​spiegate di seguito, ma almeno rende la sintassi semplice.

Svantaggi:

• Non portatile.

rischi

Tutte queste tecniche di aliasing presentano diversi rischi. Il primo esegue il codice arbitrario ogni volta che si risolve l'indirizzamento indiretto (per la lettura o l'assegnazione) . In effetti, invece di un nome di variabile scalare, come var_37, puoi anche alias un indice di array, come arr[42]. Ma Bash valuta il contenuto delle parentesi quadre ogni volta che è necessario, quindi l'aliasing arr[$(do_evil)]avrà effetti inaspettati ... Di conseguenza, usi queste tecniche solo quando controlli la provenienza dell'alias .

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)

Il secondo rischio è la creazione di un alias ciclico. Poiché le variabili di Bash sono identificate dal loro nome e non dal loro ambito, è possibile che inavvertitamente si crei un alias su se stesso (pensando che sarebbe alias di una variabile da un ambito racchiuso). Ciò può accadere in particolare quando si utilizzano nomi di variabili comuni (come var). Di conseguenza, utilizzare queste tecniche solo quando si controlla il nome della variabile con alias .

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!

Fonte:

• BashFaq / 006: Come posso usare variabili variabili (variabili indirette, puntatori, riferimenti) o array associativi?
• BashFAQ / 048: comando eval e problemi di sicurezza

L'esempio seguente restituisce un valore di $ name_of_var

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

Questo dovrebbe funzionare:

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"

Funzionerà anche questo

my_country_code="green"
x="country"

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

Nel tuo caso

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

Come da BashFAQ / 006 , è possibile utilizzare readcon la sintassi della stringa qui per assegnare variabili indirette:

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

Uso:

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

Uso declare

Non è necessario utilizzare prefissi come su altre risposte, né su array. Usa solo declare, virgolette doppie ed espansione dei parametri .

Uso spesso il seguente trucco per analizzare gli elenchi di one to nargomenti contenenti argomenti formattati come key=value otherkey=othervalue etc=etcLike:

# 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

Ma espandendo la lista argv piace

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

Suggerimenti extra

# 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

Caspita, la maggior parte della sintassi è orribile! Ecco una soluzione con una sintassi più semplice se è necessario fare riferimento indirettamente alle matrici:

#!/bin/bash

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

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

Per casi d'uso più semplici, consiglio la sintassi descritta nella Guida avanzata di script Bash .

Per le matrici indicizzate, puoi fare riferimento in questo modo:

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

Le matrici associative possono essere referenziate in modo simile ma è necessario -Aattivare declareinvece di -a.

Un metodo aggiuntivo che non si basa su quale versione shell / bash hai è usando envsubst. Per esempio:

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

Voglio essere in grado di creare un nome di variabile contenente il primo argomento del comando

script.sh file:

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

Test:

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

Secondo help eval:

Eseguire argomenti come comando shell.

È inoltre possibile utilizzare ${!var}l'espansione indiretta di Bash , come già accennato, tuttavia non supporta il recupero di indici di array.

Per ulteriori informazioni o esempi, consultare BashFAQ / 006 su Indirection .

Non siamo a conoscenza di alcun trucco che possa duplicare quella funzionalità senza POSIX o Bourne shell eval, il che può essere difficile da eseguire in sicurezza. Quindi, considera questo un uso a tuo rischio e pericolo .

Tuttavia, è necessario riconsiderare l'utilizzo dell'indirizzamento come indicato nelle note seguenti.

Normalmente, negli script bash, non avrai bisogno di riferimenti indiretti. In genere, le persone cercano questa soluzione quando non comprendono o non conoscono gli array Bash o non hanno preso in considerazione altre funzionalità di Bash come le funzioni.

Inserire nomi di variabili o qualsiasi altra sintassi bash all'interno dei parametri viene spesso eseguito in modo errato e in situazioni inadeguate per risolvere problemi con soluzioni migliori. Viola la separazione tra codice e dati e, come tale, ti mette in una situazione scivolosa verso bug e problemi di sicurezza. L'indirizzamento può rendere il codice meno trasparente e più difficile da seguire.

per il varname=$prefix_suffixformato, basta usare:

varname=${prefix}_suffix