Dans les scripts shell, quand utilisons-nous {}pour développer des variables?

Par exemple, j'ai vu ce qui suit:

var=10        # Declare variable

echo "${var}" # One use of the variable
echo "$var"   # Another use of the variable

Y a-t-il une différence significative, ou est-ce simplement du style? Est-ce que l'un est préféré à l'autre?

Dans cet exemple particulier, cela ne fait aucune différence. Cependant, l' {}en ${}sont utiles si vous souhaitez étendre la variable foodans la chaîne

"${foo}bar"

puisque "$foobar"développerait plutôt la variable identifiée par foobar.

Les accolades sont également nécessaires sans condition lorsque:

• expansion des éléments du tableau, comme dans ${array[42]}
• en utilisant des opérations d'expansion de paramètres, comme dans ${filename%.*}(supprimer l'extension)
• extension des paramètres de position au-delà de 9: "$8 $9 ${10} ${11}"

Faire cela partout, au lieu de simplement dans des cas potentiellement ambigus, peut être considéré comme une bonne pratique de programmation. C'est à la fois pour la cohérence et pour éviter les surprises comme $foo_$bar.jpg, où il n'est pas évident visuellement que le trait de soulignement fasse partie du nom de la variable.

Les variables sont déclarées et affectées sans $et sans {}. Vous devez utiliser

var=10

assigner. Pour lire à partir de la variable (en d'autres termes, "développer" la variable), vous devez utiliser $.

$var      # use the variable
${var}    # same as above
${var}bar # expand var, and append "bar" too
$varbar   # same as ${varbar}, i.e expand a variable called varbar, if it exists.

Cela m'a parfois dérouté - dans d'autres langues, nous nous référons à la variable de la même manière, qu'elle se trouve à gauche ou à droite d'une affectation. Mais le shell-scripting est différent, $var=10ne fait pas ce que l'on pourrait penser!

Vous utilisez {}pour le regroupement. Les accolades sont nécessaires pour déréférencer les éléments du tableau. Exemple:

dir=(*)           # store the contents of the directory into an array
echo "${dir[0]}"  # get the first entry.
echo "$dir[0]"    # incorrect

Vous pouvez également effectuer une manipulation de texte à l'intérieur des accolades:

STRING="./folder/subfolder/file.txt"
echo ${STRING} ${STRING%/*/*}

Résultat:

./folder/subfolder/file.txt ./folder

ou

STRING="This is a string"
echo ${STRING// /_}

Résultat:

This_is_a_string

Vous avez raison dans "les variables régulières" ne sont pas nécessaires ... Mais c'est plus utile pour le débogage et pour lire un script.

La fin du nom de la variable est généralement indiquée par un espace ou une nouvelle ligne. Mais que se passe-t-il si nous ne voulons pas d'espace ou de nouvelle ligne après avoir imprimé la valeur de la variable? Les accolades indiquent à l'interpréteur shell où se trouve la fin du nom de la variable.

Exemple classique 1) - variable shell sans espace de fin

TIME=10

# WRONG: no such variable called 'TIMEsecs'
echo "Time taken = $TIMEsecs"

# What we want is $TIME followed by "secs" with no whitespace between the two.
echo "Time taken = ${TIME}secs"

Exemple 2) Chemin de classe Java avec des fichiers JAR versionnés

# WRONG - no such variable LATESTVERSION_src
CLASSPATH=hibernate-$LATESTVERSION_src.zip:hibernate_$LATEST_VERSION.jar

# RIGHT
CLASSPATH=hibernate-${LATESTVERSION}_src.zip:hibernate_$LATEST_VERSION.jar

(La réponse de Fred le dit déjà mais son exemple est un peu trop abstrait)

Les accolades sont toujours nécessaires pour accéder aux éléments du tableau et effectuer l'expansion des accolades.

Il est bon de ne pas être trop prudent et d'utiliser {}pour l'expansion des variables shell même lorsqu'il n'y a pas de place pour l'ambiguïté.

Par exemple:

dir=log
prog=foo
path=/var/${dir}/${prog}      # excessive use of {}, not needed since / can't be a part of a shell variable name
logfile=${path}/${prog}.log   # same as above, . can't be a part of a shell variable name
path_copy=${path}             # {} is totally unnecessary
archive=${logfile}_arch       # {} is needed since _ can be a part of shell variable name

Il est donc préférable d'écrire les trois lignes comme suit:

path=/var/$dir/$prog
logfile=$path/$prog.log
path_copy=$path

ce qui est certainement plus lisible.

Puisqu'un nom de variable ne peut pas commencer par un chiffre, le shell n'a pas besoin de {}variables numérotées (comme $1, $2etc.) à moins qu'une telle expansion ne soit suivie d'un chiffre. C'est trop subtil et cela rend l'utilisation explicite {}dans de tels contextes:

set app      # set $1 to app
fruit=$1le   # sets fruit to apple, but confusing
fruit=${1}le # sets fruit to apple, makes the intention clear

Voir:

• Caractères autorisés dans les noms de variables d'environnement Linux

Suite à la suggestion de SierraX et de Peter concernant la manipulation de texte, des accolades {}sont utilisées pour passer une variable à une commande, par exemple:

Disons que vous avez un fichier sposi.txt contenant la première ligne d'un roman italien bien connu:

> sposi="somewhere/myfolder/sposi.txt"
> cat $sposi

Sortie: quel ramo del lago di como che volge a mezzogiorno

Créez maintenant deux variables:

# Search the 2nd word found in the file that "sposi" variable points to
> word=$(cat $sposi | cut -d " " -f 2)

# This variable will replace the word
> new_word="filone"

Maintenant, remplacez le mot variable content par celui de new_word , dans le fichier sposi.txt

> sed -i "s/${word}/${new_word}/g" $sposi
> cat $sposi

Sortie: quel filone del lago di como che volge a mezzogiorno

Le mot "ramo" a été remplacé.