HOWTO · Linux
Comment effectuer une opération d'augmentation et de diminution en Bash
Pour effectuer l'incrémentation et la décrémentation des variables en Bash, nous pouvons utiliser les opérateurs + et - ou les opérateurs += et -=. Nous pouvons également effectuer l'incrémentation et la décrémentation en Bash en utilisant des opérateurs unnaires : ++ et --.
Sur cette page
Les opérations d’incrémentation et de décrémentation modifient une variable entière d’une quantité fixe. Dans Bash, l’expansion arithmétique, les commandes arithmétiques, let, les affectations composées et les opérateurs unaires permettent toutes ces mises à jour. Choisissez la forme qui rend les quantités et les valeurs utilisées ensuite les plus faciles à comprendre.
Incrémentation et décrémentation avec + et -
L’expansion arithmétique, écrite $((...)), produit une valeur que vous pouvez affecter à une variable ou afficher. Une commande arithmétique, ((...)), évalue une expression et peut mettre directement à jour des variables. La commande intégrée let évalue elle aussi des expressions arithmétiques ; mettez son expression entre guillemets afin que le shell la transmette comme un seul argument.
Exécutez cet exemple. Les libellés x, y et z affichés par celui-ci restent en anglais.
x=3
y=3
z=3
x=$((x + 1))
((y = y + 1))
let "z=z+1"
printf 'x: %s\ny: %s\nz: %s\n' "$x" "$y" "$z"
x=$((x - 1))
((y = y - 1))
let "z=z-1"
Les trois premières mises à jour ajoutent une unité à l’aide de formes arithmétiques différentes ; les trois dernières en soustraient une. L’expansion arithmétique est utile lorsqu’il faut récupérer la valeur d’une expression, tandis que les commandes arithmétiques et let sont pratiques pour effectuer des mises à jour. L’arithmétique de Bash utilise des valeurs entières.
Utiliser += et -= pour les mises à jour arithmétiques
Les affectations composées x+=amount et x-=amount ajoutent à la variable de gauche l’entier indiqué à droite, ou l’en soustraient. Elles correspondent à x=x+amount et x=x-amount ; utilisez-les lorsque la quantité à ajouter ou à soustraire est supérieure à un, ou lorsque vous voulez qu’elle soit immédiatement visible.
Dans l’exemple, les libellés affichés, notamment after adding 3 et after subtracting 2, restent en anglais.
count=10
((count += 3))
printf 'after adding 3: %s\n' "$count"
((count -= 2))
printf 'after subtracting 2: %s\n' "$count"
Ces expressions modifient count directement. Le statut d’une commande arithmétique dépend du fait que son expression s’évalue ou non à zéro ; évitez donc de vous fier à ce statut pour déterminer si une mise à jour a réussi.
Utiliser ++ et -- pour modifier une valeur d’une unité
Les opérateurs unaires ++ et -- ajoutent ou soustraient exactement une unité. Comme commandes arithmétiques autonomes, ((count++)), ((++count)), ((count--)) et ((--count)) mettent la variable à jour.
Lorsque la valeur de l’opérateur est utilisée dans une expression, les formes préfixée et postfixée diffèrent : ++count met d’abord la variable à jour, puis fournit la nouvelle valeur ; count++ fournit l’ancienne valeur, puis effectue la mise à jour. Le même ordre s’applique à --. Si seule la valeur finale de la variable importe, placez la mise à jour dans sa propre instruction pour éviter toute ambiguïté.
Dans l’exemple, les libellés affichés, notamment old, count et new, restent en anglais.
count=4
old=$((count++))
printf 'old: %s, count: %s\n' "$old" "$count"
new=$((++count))
printf 'new: %s, count: %s\n' "$new" "$count"
Utiliser les incréments et décréments dans les boucles
La condition d’une boucle détermine quand elle s’arrête, et sa mise à jour rapproche le compteur de cette limite. Veillez à ce que ces deux éléments concordent : un compteur croissant nécessite une condition de borne supérieure, tandis qu’un compteur décroissant nécessite une condition de borne inférieure. Les exemples affichent d’abord la suite 1, 2, 3, puis la suite 3, 2, 1.
Le code et les libellés ou sorties affichés dans cette section restent en anglais.
for ((count = 1; count <= 3; count++)); do
printf '%s\n' "$count"
done
count=3
while ((count >= 1)); do
printf '%s\n' "$count"
((count--))
done
La boucle for regroupe l’initialisation, la condition et l’incrément dans son en-tête. La boucle while teste sa condition avant le corps et effectue la décrémentation dans celui-ci. Assurez-vous que chaque mise à jour finisse par rendre la condition fausse.
Limites de l’arithmétique de Bash et questions fréquentes
L’arithmétique de Bash repose sur les entiers et ne prend pas en charge nativement les calculs en virgule flottante. Pour effectuer des calculs décimaux, utilisez une calculatrice externe adaptée ou un langage prenant en charge les nombres à virgule flottante, et tenez compte de cet outil comme d’une dépendance distincte.
++ et += 1 augmentent tous deux une variable d’une unité. La forme unaire est concise ; l’affectation composée rend la quantité explicite et convient aussi aux mises à jour plus importantes. Les formes préfixée et postfixée ne font une différence que lorsque la valeur de l’expression est utilisée, comme indiqué plus haut.
Une commande arithmétique renvoie le statut 1 lorsque son expression s’évalue à zéro, et le statut 0 dans le cas contraire. Pour ((count--)), l’expression utilise la valeur avant la décrémentation : faire passer count de 1 à 0 renvoie le statut 0, tandis qu’en partant de 0, le statut renvoyé est 1, même si la variable devient -1. Pour ((--count)) et ((count -= 1)), l’expression utilise la valeur après la décrémentation ; faire passer la variable de 1 à 0 renvoie donc le statut 1. Cette différence compte lorsqu’une commande arithmétique sert de condition à if ou while, ou est exécutée comme commande simple avec set -e, car un statut non nul peut influer sur le flux de contrôle. Dans la boucle décroissante présentée plus haut, ((count--)) renvoie le statut 0 lors de la mise à jour de 1 à 0 ; la condition explicite suivante, ((count >= 1)), met fin à la boucle.