Je suis confus au sujet d'un script bash.

J'ai le code suivant:

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

Je veux pouvoir créer un nom de variable contenant le premier argument de la commande et portant la valeur par exemple de la dernière ligne de ls.

Donc pour illustrer ce que je veux:

$ ls | tail -1
stack-overflow.txt

$ grep_search() open_box
stack-overflow.txt

Alors, comment définir / déclarer $magic_way_to_define_magic_variable_$1et comment l'appeler dans le script?

Je l' ai essayé eval, ${...}, \$${...}, mais je suis toujours confus.

Utilisez un tableau associatif, avec des noms de commandes comme clés.

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

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

Si vous ne pouvez pas utiliser de tableaux associatifs (par exemple, vous devez prendre en charge bash3), vous pouvez utiliser declarepour créer des noms de variables dynamiques:

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

et utilisez l'expansion indirecte des paramètres pour accéder à la valeur.

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

Voir BashFAQ: Indirection - Évaluation des variables indirectes / de référence .

J'ai cherché une meilleure façon de le faire récemment. Le tableau associatif me paraissait excessif. Regarde ce que j'ai trouvé:

suffix=bzz
declare prefix_$suffix=mystr

...puis...

varname=prefix_$suffix
echo ${!varname}

Au-delà des tableaux associatifs, il existe plusieurs façons d'obtenir des variables dynamiques dans Bash. Notez que toutes ces techniques présentent des risques, qui sont discutés à la fin de cette réponse.

Dans les exemples suivants, je suppose que i=37vous souhaitez aliaser la variable nommée var_37dont la valeur initiale est lolilol.

Méthode 1. Utilisation d'une variable «pointeur»

Vous pouvez simplement stocker le nom de la variable dans une variable d'indirection, un peu comme un pointeur C. Bash a alors une syntaxe pour lire la variable aliasée: se ${!name}développe à la valeur de la variable dont le nom est la valeur de la variable name. Vous pouvez le considérer comme une expansion en deux étapes: se ${!name}développe en $var_37, qui se développe en lolilol.

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

Malheureusement, il n'y a pas de syntaxe homologue pour modifier la variable aliasée. Au lieu de cela, vous pouvez réaliser une affectation avec l'une des astuces suivantes.

1a. Assigner aveceval

evalest le mal, mais c'est aussi le moyen le plus simple et le plus portable d'atteindre notre objectif. Vous devez soigneusement échapper au côté droit de la tâche, car elle sera évaluée deux fois . Une manière simple et systématique de le faire est d'évaluer le côté droit au préalable (ou de l'utiliser printf %q).

Et vous devriez vérifier manuellement que le côté gauche est un nom de variable valide, ou un nom avec index (et si c'était le cas evil_code #?). En revanche, toutes les autres méthodes ci-dessous l'appliquent automatiquement.

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

Inconvénients:

• ne vérifie pas la validité du nom de la variable.
• eval est le mal.
• eval est le mal.
• eval est le mal.

1b. Assigner avecread

Le readbuiltin vous permet d'assigner des valeurs à une variable dont vous donnez le nom, un fait qui peut être exploité en conjonction avec des chaînes ici:

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

La IFSpièce et l'option -rs'assurent que la valeur est attribuée telle quelle, tandis que l'option -d ''permet d'attribuer des valeurs multilignes. En raison de cette dernière option, la commande retourne avec un code de sortie différent de zéro.

Notez que, puisque nous utilisons une chaîne ici, un caractère de nouvelle ligne est ajouté à la valeur.

Inconvénients:

• quelque peu obscur;
• retourne avec un code de sortie différent de zéro;
• ajoute une nouvelle ligne à la valeur.

1c. Assigner avecprintf

Depuis Bash 3.1 (sorti en 2005), le printfbuiltin peut également affecter son résultat à une variable dont le nom est donné. Contrairement aux solutions précédentes, cela fonctionne, aucun effort supplémentaire n'est nécessaire pour échapper aux choses, pour éviter le fractionnement, etc.

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

Inconvénients:

• Moins portable (mais bon).

Méthode 2. Utilisation d'une variable «référence»

Depuis Bash 4.3 (sorti en 2014), le declarebuiltin a une option -npour créer une variable qui est une «référence de nom» à une autre variable, un peu comme les références C ++. Tout comme dans la méthode 1, la référence stocke le nom de la variable aliasée, mais chaque fois que la référence est accédée (que ce soit pour la lecture ou l'affectation), Bash résout automatiquement l'indirection.

En outre, Bash a une syntaxe spéciale et très déroutant pour obtenir la valeur de la référence elle - même, juge par vous - même: ${!ref}.

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

Cela n'évite pas les pièges expliqués ci-dessous, mais au moins cela rend la syntaxe simple.

Inconvénients:

• Pas portable.

Des risques

Toutes ces techniques d'aliasing présentent plusieurs risques. Le premier exécute du code arbitraire chaque fois que vous résolvez l'indirection (soit pour la lecture, soit pour l'affectation) . En effet, au lieu d'un nom de variable scalaire, comme var_37, vous pouvez aussi aliaser un indice de tableau, comme arr[42]. Mais Bash évalue le contenu des crochets à chaque fois que cela est nécessaire, donc l'alias arr[$(do_evil)]aura des effets inattendus ... Par conséquent, n'utilisez ces techniques que lorsque vous contrôlez la provenance de l'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)

Le deuxième risque est la création d'un alias cyclique. Comme les variables Bash sont identifiées par leur nom et non par leur portée, vous pouvez par inadvertance créer un alias pour elle-même (tout en pensant que cela alias une variable à partir d'une portée englobante). Cela peut se produire en particulier lors de l'utilisation de noms de variables communs (comme var). Par conséquent, n'utilisez ces techniques que lorsque vous contrôlez le nom de la variable aliasée .

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!

La source:

• BashFaq / 006: Comment puis-je utiliser des variables variables (variables indirectes, pointeurs, références) ou des tableaux associatifs?
• BashFAQ / 048: commande eval et problèmes de sécurité

L'exemple ci-dessous renvoie la valeur de $ name_of_var

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

Cela devrait fonctionner:

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"

Cela fonctionnera aussi

my_country_code="green"
x="country"

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

Dans ton cas

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

Selon BashFAQ / 006 , vous pouvez utiliser readavec ici la syntaxe de chaîne pour attribuer des variables indirectes:

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

Usage:

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

Utilisation declare

Il n'est pas nécessaire d'utiliser des préfixes comme sur les autres réponses, ni sur les tableaux. Utilisez seulement declare, guillemets doubles , et l' expansion des paramètres .

J'utilise souvent l'astuce suivante pour analyser les listes d' one to narguments contenant des arguments au format key=value otherkey=othervalue etc=etc, comme:

# 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

Mais en élargissant la liste argv comme

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

Conseils supplémentaires

# 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, la plupart de la syntaxe est horrible! Voici une solution avec une syntaxe plus simple si vous avez besoin de référencer indirectement des tableaux:

#!/bin/bash

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

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

Pour des cas d'utilisation plus simples, je recommande la syntaxe décrite dans le Advanced Bash-Scripting Guide .

Pour les tableaux indexés, vous pouvez les référencer comme suit:

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

Les tableaux associatifs peuvent être référencés de la même manière mais nécessitent l' -Aactivation au declarelieu de -a.

Une méthode supplémentaire qui ne dépend pas de la version de shell / bash dont vous disposez consiste à utiliser envsubst. Par exemple:

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

Je veux pouvoir créer un nom de variable contenant le premier argument de la commande

script.sh fichier:

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

Tester:

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

Selon help eval:

Exécutez des arguments en tant que commande shell.

Vous pouvez également utiliser l' ${!var}expansion indirecte de Bash , comme déjà mentionné, mais elle ne prend pas en charge la récupération d'index de tableau.

Pour plus d'informations ou des exemples, consultez BashFAQ / 006 sur l'indirection .

Nous n'avons connaissance d'aucune astuce qui puisse dupliquer cette fonctionnalité dans les shells POSIX ou Bourne eval, ce qui peut être difficile à faire en toute sécurité. Alors, considérez ceci comme une utilisation à vos risques et périls .

Cependant, vous devriez reconsidérer l'utilisation de l'indirection selon les notes suivantes.

Normalement, dans les scripts bash, vous n'avez pas du tout besoin de références indirectes. Généralement, les gens recherchent une solution lorsqu'ils ne comprennent pas ou ne connaissent pas les tableaux Bash ou n'ont pas pleinement pris en compte les autres fonctionnalités de Bash telles que les fonctions.

Mettre des noms de variables ou toute autre syntaxe bash à l'intérieur des paramètres est souvent fait de manière incorrecte et dans des situations inappropriées pour résoudre des problèmes qui ont de meilleures solutions. Cela viole la séparation entre le code et les données et, en tant que tel, vous met sur une pente glissante vers les bogues et les problèmes de sécurité. L'indirection peut rendre votre code moins transparent et plus difficile à suivre.

pour le varname=$prefix_suffixformat, utilisez simplement:

varname=${prefix}_suffix