9.3. Substitution de paramètres

Manipuler et/ou étendre les variables

${parametre}

Identique à $parametre, c'est-à-dire la valeur de la variable parametre. Dans certains contextes, seule la forme la moins ambiguë, ${parametre}, fonctionne.

Peut être utilisé pour concaténer des variables avec des suites de caractères (strings).

votre_id=${USER}-sur-${HOSTNAME}
echo "$votre_id"
#
echo "Ancien \$PATH = $PATH"
PATH=${PATH}:/opt/bin  #Ajoute /opt/bin à $PATH pour toute la durée du script.
echo "Nouveau \$PATH = $PATH"

${parametre-defaut}, ${parametre:-defaut}

Si parametre n'est pas initialisé, utilise defaut.

echo ${nom_utilisateur-`whoami`}
# Affichez le résultat de `whoami`, si la variable $nom_utilisateur n'est
toujours pas initialisée.

Note

${parametre-defaut} et ${parametre:-defaut} sont pratiquement équivalents. Le caractère : supplémentaire fait une différence seulement lorsque parametre a été déclaré mais est nul.

&paramsub;

La construction du paramètre par défaut a pour principale utilité de fournir les arguments « manquants » de la ligne de commande des scripts.

NOM_FICHIER_PAR_DEFAUT=donnees.generiques
nom_fichier=${1:-$NOM_FICHIER_PAR_DEFAUT}
#  S'il n'est pas spécifié, l'ensemble de commandes suivantes opère sur le
#  fichier "donnees.generiques".
#
#  Les commandes suivent.

Voir aussi l'Exemple 3.4, « Sauvegarde de tous les fichiers modifiés dans les dernières 24 heures », l'Exemple 28.2, « Créer un fichier de swap en utilisant /dev/zero » et l'Exemple A.6, « Séries de Collatz ».

Comparez cette méthode avec l'utilisation d'une liste ET pour fournir un argument par défaut à la ligne de commande.

${parametre=defaut}, ${parametre:=defaut}

Si le paramètre n'est pas initialisé, alors initialisation à la valeur par défaut.

Les deux formes sont pratiquement équivalentes. Le caractère : fait une différence seulement lorsque $parametre a été déclaré et est nul, ^[41] comme ci-dessus.

echo ${nom_utilisateur=`whoami`}
# La variable "nom_utilisateur" est maintenant initialisée à `whoami`.

${parametre+valeur_alt}, ${parametre:+valeur_alt}

Si le paramètre est déclaré, utilisez valeur_alt, sinon utilisez la chaîne de caractères vide.

Les deux formes sont pratiquement équivalentes. Le caractère : fait la différence seulement lorsque parametre a été déclaré nul, voir plus bas.

echo "###### \${parametre+valeur_alt} ########"
echo

a=${param1+xyz}
echo "a = $a"      # a =

param2=
a=${param2+xyz}
echo "a = $a"      # a = xyz

param3=123
a=${param3+xyz}
echo "a = $a"      # a = xyz

echo
echo "###### \${parametre:+valeur_alt} ########"
echo

a=${param4:+xyz}
echo "a = $a"      # a =

param5=
a=${param5:+xyz}
echo "a = $a"      # a =
# Résultats différents pour a=${param5+xyz}

param6=123
a=${param6:+xyz}
echo "a = $a"      # a = xyz

${parametre?msg_err}, ${parametre:?msg_err}

Si le paramètre est initialisé, l'utilise, sinon affiche msg_err.

Les deux formes sont pratiquement équivalentes. Le caractère : fait la différence seulement lorsque parametre a été déclaré nul, comme ci-dessus.

Longueur de variables / Suppression d'un sous-ensemble d'une suite de caractères

${#var}

Longueur de la suite de caractères (ou nombre de caractères dans $var). Pour un tableau, ${#tableau} est la longueur du premier élément dans le tableau.

Note

Exceptions :

• ${#*} et ${#@} donnent le nombre de paramètres de position.

• Pour un tableau, ${#tableau[*]} et ${#tableau[@]} donnent le nombre d'éléments dans le tableau.

Exemple 9.18. Longueur d'une variable

&length;

${var#Modele}, ${var##Modele}

${var#Modele} Supprime à partir de $var la plus courte partie de $Modele qui correspond au début de $var.

${var##Modele} Supprime de $var la plus longue partie de $Modele qui correspond au début de $var.

Un exemple d'usage à partir de l'Exemple A.7, « days-between : Calculer le nombre de jours entre deux dates » :

# Fonction provenant de l'exemple "days-between.sh"
# Supprimer les zéros du début à partir de l'argument donné.

supprimer_les_zeros_du_debut () # Supprime les zéros éventuels au début
{                     # à partir des arguments donnés.
  return=${1#0}       # Le "1" correspond à "$1", argument donné.
                      # Le "0" correspond à ce qui doit être supprimé de "$1".
}

Une version plus élaborée par Manfred Schwarb :

supprimer_les_zeros_du_debut_2 () # Supprimer les zéros du début, car sinon
{                      # Bash interprétera de tels numéros en valeurs octales.
  shopt -s extglob     # Active le globbing local.
  local val=${1##+(0)} # Utilise une variable locale, série correspondante la
                       # plus longue avec des 0.
  shopt -u extglob     # Désactive le globbing local.
  _strip_leading_zero2=${val:-0}
                       # Si l'entrée était 0, renvoie 0 au lieu de "".
}

Un autre exemple d'usage :

echo `basename $PWD`        # Base du nom du répertoire courant.
echo "${PWD##*/}"           # Base du nom du répertoire actuel.
echo
echo `basename $0`          # Nom du script.
echo $0                     # Nom du script.
echo "${0##*/}"             # Nom du script.
echo
filename=test.data
echo "${filename##*.}"      # données
                            # Extension du fichier.

${var%Modele}, ${var%%Modele}

${var%Modele} Supprime de $var la plus courte partie de $Modele qui s'ajuste à la fin de $var.

${var%%Modele} Supprime de $var la plus longue partie de $Modele qui s'ajuste à la fin de $var.

Expansion de variables / Remplacement de sous-chaînes

Ces constructions proviennent de ksh.

${var:pos}

La variable var étendue, commençant à la position pos.

${var:pos:len}

Augmentation d'un maximum de len caractères de la variable var, à partir de la position pos. Voir l'Exemple A.13, « password: Générer des mots de passe aléatoires de 8 caractères » pour un exemple d'utilisation particulièrement intéressante de cet opérateur.

${var/Modele/Remplacement}

Première occurrence de Modele, à l'intérieur de var remplacé par Remplacement.

Si Remplacement est omis, alors la première occurrence de Modele est remplacé par rien, c'est-à-dire qu'il est supprimé.

${var//Modele/Remplacement}

Remplacement global. Toutes les occurrences de Modele, à l'intérieur de var sont remplacées par Remplacement.

Comme ci-dessus, si Remplacement est omis, alors toutes les occurrences de Modele sont remplacées par rien, c'est-à-dire supprimées.

Exemple 9.21. Utiliser la concordance de modèles pour analyser des chaînes de caractères diverses

&ex7;

${var/#Modele/Remplacement}

Si le préfixe de var correspond à Modele, alors Remplacement remplace Modele.

${var/%Modele/Remplacement}

Si le suffixe de var correspond à Modele, alors Remplacement remplace Modele.

Exemple 9.22. Modèles correspondant au préfixe ou au suffixe d'une chaîne de caractères

&varmatch;

${!varprefixe*}, ${!varprefixe@}

Établit une correspondance des noms de toutes les variables déjà déclarées commençant par varprefixe.

# Ceci est une
                      variation sur la référence indirecte, mais avec
                      un * ou un @.
# Cette fonctionnalité a été ajoutée dans la version 2.04 de Bash.

xyz23=quelquechose
xyz24=

a=${!xyz*}      # Se développe en les *noms* des variables précédemment déclarées
# ^ ^   ^       #+ qui commencent par "xyz".
echo "a = $a"   # a = xyz23 xyz24
a=${!xyz@}      # Même chose que ci-dessus.
echo "a = $a"   # a = xyz23 xyz24

echo "---"

abc23=quelquechose_dautre
b=${!abc*}
echo "b = $b"      #  b = abc23 
c=${!b}            #  à présent, une référence indirecte d'un genre plus familier
echo $c            #  quelquechose_dautre