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}

var1=1
var2=2
# var3 n'est pas initialisée.

echo ${var1-$var2}   # 1
echo ${var3-$var2}   # 2
            ^          Remarquez le préfixe $.


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}
#  Si rien n'est spécifié, l'ensemble de commandes suivant opère sur le
#+ fichier "donnees.generiques".
#  Debut-Bloc-Commandes
#  ...
#  ...
#  ...
#  Fin-Bloc-Commandes


#  Exemple tiré de "hanoi2.bash" :
DISQUES=${1:-E_NOPARAM}   # Il faut préciser le nombre de disques
#  Affecter la valeur $1 (le paramètre de ligne de commande) à
#+ $DISQUES, ou $E_NOPARAM si $1 n'est pas
#+ initialisée.]]</programlisting>
                </para>

                <para>Voir aussi l'<xref linkend="ex58"/>, l'<xref
                  linkend="ex73"/> et l'<xref linkend="collatz"/>.</para>

                <para>Comparez cette méthode avec <link
                  linkend="anddefault">l'utilisation d'une <firstterm>liste
                  ET</firstterm> pour fournir un argument par défaut à la ligne
                  de commande</link>.</para>

                </listitem>
              </varlistentry>

              <varlistentry>
                <term><userinput>${parametre=defaut}</userinput></term>
                <term><userinput>${parametre:=defaut}</userinput></term>
                <listitem id="defparam">
                <para>Si le paramètre n'est pas initialisé, alors initialisation
                  à la valeur par <firstterm>défaut</firstterm>.</para>

                <para>Les deux formes sont pratiquement équivalentes. Le
                  caractère <token>:</token> fait une différence seulement
                  lorsque <varname>$parametre</varname> a été déclaré et est nul,
                    <footnote>
                    <para>Si $parametre est nul dans un script non interactif,
                      il se terminera avec un <link linkend="exitcodesref">code
                      de retour <returnvalue>127</returnvalue></link> (le code
                      d'erreur de Bash pour <quote>commande introuvable</quote>).
                      </para>
                      </footnote>
                  comme ci-dessus.
                    </para>

                <para><programlisting><![CDATA[echo ${var=abc}   # abc
echo ${var=xyz}   # abc
# $var avait déjà été initialisée à abc, donc aucun changement.

${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'utiliser, sinon afficher msg_err et interrompre le script avec un code de sortie de 1.

Ces 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 10.9. 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 le(s) zéro(s) du début à partir de l'argument donné.

supprimer_les_zeros_du_debut () # Supprime les zéros éventuels du 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 10.12. 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 10.13. 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