Recherche de site Web

Bash Scripting : Maîtriser les opérations arithmétiques

Les opérations arithmétiques sont un aspect fondamental des scripts bash, permettant aux scripts d’effectuer des calculs, d’automatiser des tâches et de prendre des décisions basées sur des données numériques. Bash fournit une variété de méthodes pour effectuer des opérations arithmétiques, de la simple addition et soustraction à des calculs plus complexes tels que les opérations en virgule flottante et la gestion des nombres scientifiques. Ce tutoriel vous guidera à travers différentes techniques et vous fournira des exemples pratiques pour améliorer vos compétences en matière de script bash.

Dans ce tutoriel, vous allez apprendre :

  • Opérations arithmétiques de base dans Bash
  • Utilisation d’outils externes pour des calculs avancés
  • Application de l’arithmétique dans les boucles et les instructions conditionnelles
  • Gestion des nombres à virgule flottante et de la notation scientifique

Comprendre les opérations arithmétiques Bash

Bash prend en charge diverses opérations arithmétiques. Nous commencerons par les opérations de base, puis nous passerons à des exemples plus avancés, démontrant comment Bash peut être utilisé pour des scripts efficaces et efficients.

  1. Ajout de base

    #!/bin/bash
a=10
b=5
sum=$((a + b))
echo "Sum: $sum"

    Ce script Bash effectue une opération arithmétique simple : l’addition. La première ligne a=10 attribue la valeur 10 à la variable a. De même, la deuxième ligne b=5 attribue la valeur 5 à la variable b. La troisième ligne sum=$ ((a + b)) calcule la somme des valeurs contenues dans a et b à l’aide de la syntaxe de développement arithmétique $ (( ))), et attribue le résultat à la variable somme. La dernière ligne echo « Somme : $sum » utilise la commande echo pour afficher le texte « Somme : " suivi de la valeur de la variable somme, affichant ainsi le résultat de l’addition (15 dans ce cas) sur la console. Ce script est un exemple de base de la façon d’utiliser des variables et de l’arithmétique dans Bash pour effectuer et afficher le résultat d’un calcul.

  2. soustraction

    #!/bin/bash
a=10
b=5
difference=$((a - b))
echo "Difference: $difference"

    Ce script Bash calcule la différence entre deux nombres. La ligne a=10 attribue la valeur 10 à la variable a. La ligne suivante b=5 attribue la valeur 5 à la variable b. Le script effectue ensuite une opération de soustraction avec difference=$ ((a - b)), qui soustrait la valeur de b de a et attribue le résultat (5 dans ce cas) à la variable difference.

    Enfin, le script utilise la commande echo dans echo « Différence : $difference » pour imprimer la phrase « Différence : " suivie de la différence calculée (5). Il s’agit d’un exemple simple d’exécution et d’affichage du résultat d’une opération arithmétique de base dans Bash.

  3. Multiplication

    #!/bin/bash
a=10
b=5
product=$((a * b))
echo "Product: $product"

    Ce script Bash calcule la différence entre deux nombres. La ligne a=10 attribue la valeur 10 à la variable a. La ligne suivante b=5 attribue la valeur 5 à la variable b. Le script effectue ensuite une opération de soustraction avec difference=$ ((a - b)), qui soustrait la valeur de b de a et attribue le résultat (5 dans ce cas) à la variable difference.

    Enfin, le script utilise la commande echo dans echo « Différence : $difference » pour imprimer la phrase « Différence : " suivie de la différence calculée (5). Il s’agit d’un exemple simple d’exécution et d’affichage du résultat d’une opération arithmétique de base dans Bash.

  4. Division

    #!/bin/bash
a=10
b=5
quotient=$((a / b))
echo "Quotient: $quotient"

    Ce script Bash calcule le quotient de deux nombres et affiche le résultat. Le script définit la valeur de a sur 10 et b sur 5. L’expression quotient=$ ((a/b)) effectue la division entière de a par b et attribue le résultat à la variable quotient. Étant donné que a et b sont tous deux des entiers, et que a est égal à 10 tandis que b est égal à 5, la division donne un quotient entier de 2.

    La dernière ligne echo « Quotient : $quotient » utilise la commande echo pour afficher le texte « Quotient : " suivi de la valeur de la variable quotient. Dans ce cas, il affiche « Quotient : 2 » sur la console. Ce script est un exemple simple de la façon d’effectuer une division dans Bash.

  5. Fonctionnement du module

    #!/bin/bash
a=15
b=4
modulus=$((a % b))
echo "Modulus: $modulus"

    Ce script Bash calcule le module (reste de la division) de deux nombres et affiche le résultat. La première ligne a=15 attribue la valeur 15 à la variable a. La deuxième ligne b=4 attribue la valeur 4 à la variable b. Le script effectue ensuite l’opération de module avec modulus=$ ((a % b)), qui calcule le reste lorsque a est divisé par b. Pour les valeurs données, le reste de la division de 15 par 4 est 3, il s’agit donc de la valeur attribuée au module.

    Le script renvoie le résultat à l’aide de echo « Modulus : $modulus », qui imprime la chaîne « Modulus : " suivie de la valeur de modulus (3 dans ce cas) sur la console. Cela démontre l’utilisation de l’opérateur de module dans Bash pour trouver le reste d’une opération de division.

  6. Incrémentation d’une variable

    #!/bin/bash
counter=0
((counter++))
echo "Incremented value: $counter"

    Ce script Bash montre comment incrémenter (augmenter d’une unité) la valeur d’une variable. Le script commence par définir counter à 0 avec counter=0. La ligne suivante, ((counter++)), est une expression arithmétique qui incrémente la valeur de counter. Dans ce contexte, ++ est un opérateur post-incrémentation, ce qui signifie qu’il augmente la valeur du compteur de 1.

    Après cette opération, la valeur de counter devient 1. Enfin, le script affiche la valeur incrémentée à l’aide de echo « Valeur incrémentée : $counter ». Cette commande imprime la chaîne « Valeur incrémentée : » suivie de la valeur actuelle de counter, qui est 1. Cet exemple est une démonstration simple de l’utilisation d’expressions arithmétiques pour incrémenter la valeur d’une variable dans Bash.

  7. Décrémentation d’une variable

    #!/bin/bash
counter=10
((counter--))
echo "Decremented value: $counter"

    Ce script Bash montre comment décrémenter (diminuer d’un) la valeur d’une variable. Le script initialise la variable compteur avec la valeur 10 à l’aide de counter=10. La ligne suivante, ((counter--)), utilise une expression arithmétique qui utilise l’opérateur post-décrémentation -- pour réduire la valeur de counter de 1. Après cette opération, la valeur du compteur devient 9.

    La dernière ligne du script, echo « Valeur décrémentée : $counter », utilise la commande echo pour afficher la chaîne « Valeur décrémentée : " suivie de la valeur mise à jour de compteur. Dans ce cas, il affiche « Valeur décrémentée : 9 » sur la console. Cet exemple illustre l’utilisation d’expressions arithmétiques dans Bash pour décrémenter la valeur d’une variable.

  8. Fonctionnement électrique

    #!/bin/bash
base=2
exponent=3
power=$((base**exponent))
echo "Power: $power"

    Ce script Bash calcule la puissance d’un nombre et affiche le résultat. Le script commence par attribuer la valeur 2 à la variable base et la valeur 3 à l’exposant variable en utilisant les lignes base=2 et exposant=3, respectivement. La ligne suivante, power=$ ((base**exponent)), effectue l’opération power : elle élève la base à l’exposant, qui dans ce cas calcule 2 élevé à la puissance 3.

    Le résultat de ce calcul, qui est de 8, est ensuite stocké dans la puissance variable. Enfin, le script renvoie ce résultat avec la commande echo « Power : $power », qui imprime la chaîne « Power : " suivie de la valeur power (8 dans ce cas) sur la console. Cet exemple montre comment effectuer une exponentiation dans un script Bash.

  9. Utilisation de expr pour l’addition

    #!/bin/bash
a=10
b=5
sum=$(expr $a + $b)
echo "Sum: $sum"

    Ce script Bash calcule la somme de deux nombres à l’aide de la commande expr, qui est un utilitaire externe pour effectuer des opérations arithmétiques de base. La première ligne a=10 attribue la valeur 10 à la variable a. La deuxième ligne b=5 attribue la valeur 5 à la variable b.

    L’opération clé est effectuée dans la ligne sum=$ (expr $a + $b). Ici, expr $a + $b calcule la somme des valeurs stockées dans a et b. La syntaxe $ (...) est la substitution de commande, qui capture la sortie de la commande expr et l’affecte à la variable somme. Par conséquent, sum aura la valeur 15, qui est le résultat de l’addition de 10 et 5.

    La dernière ligne echo « Sum : $sum » imprime le résultat à l’aide de la commande echo. Il affiche la chaîne « Somme : » suivie de la valeur de somme, affichant ainsi « Somme : 15 » sur la console. Ce script est un exemple pratique d’utilisation de la commande expr pour les opérations arithmétiques dans Bash.

  10. Comparaison de nombres dans des instructions conditionnelles

    #!/bin/bash
a=10
b=20
if ((a > b)); then
    echo "$a is greater than $b"
elif ((a < b)); then
    echo "$a is less than $b"
else
    echo "$a is equal to $b"
fi

    Ce script Bash montre comment utiliser des comparaisons arithmétiques au sein d’une structure conditionnelle if-elif-else pour comparer deux nombres. Le script commence par attribuer les valeurs 10 et 20 aux variables a et b, respectivement, en utilisant a=10 et b=20.

    L’instruction conditionnelle commence par if ((a > b)) ; then. Cela vérifie si a est supérieur à b. Étant donné que a (10) n’est pas supérieur à b (20), cette condition est évaluée à faux et le script n’exécute pas la commande echo « $a est supérieur à $b » à l’intérieur de ce bloc.

    Le script passe ensuite à l’elif ((a < b)), puis à la partie. Cela vérifie si a est inférieur à b. Dans ce cas, la condition est vraie (puisque 10 est inférieur à 20), donc le script exécute la commande echo « $a est inférieur à $b », qui affiche « 10 est inférieur à 20 » à la console.

    Si a avait été égal à b, ni les conditions si ni la condition elif n’auraient été remplies, et le script aurait exécuté le dernier bloc else, en imprimant « $a est égal à $b ».

    Le fi marque la fin de l’instruction conditionnelle. Ce script illustre efficacement la logique conditionnelle et la comparaison arithmétique dans Bash.

  11. Boucle avec opérations arithmétiques

    #!/bin/bash
for ((i = 1; i <= 5; i++)); do
    echo "Number $i"
done

    Ce script Bash illustre une boucle for qui effectue une itération à travers une séquence de nombres. La boucle est initialisée avec for ((i=1 ; i <= 5 ; i++)) ;, où i est défini pour commencer à 1, la condition i <= 5 garantit que la boucle continue tant que i est inférieur ou égal à 5, et i++ incrémente i de 1 à chaque itération. À l’intérieur de la boucle, la commande echo « Number $i » est exécutée, qui affiche la valeur actuelle de i préfixée par « Number ». La boucle itérera cinq fois, en imprimant « Numéro 1 », « Numéro 2 », ..., jusqu’à « Numéro 5 ». Après la cinquième itération, lorsque i devient 6, la condition i <= 5 devient fausse, mettant fin à la boucle.

  12. Arithmétique à virgule flottante avec bc

    #!/bin/bash
a=10.5
b=5.2
sum=$(echo "$a + $b" | bc)
echo "Sum: $sum"

    Ce script Bash calcule la somme de deux nombres à virgule flottante à l’aide de l’utilitaire bc, qui est une calculatrice en ligne de commande capable d’effectuer des calculs arithmétiques avec des nombres décimaux. Le script commence par attribuer les valeurs 10,5 et 5,2 aux variables a et b, respectivement, en utilisant a=10,5 et b=5,2.

    L’opération clé est sum=$ (echo « $a + $b » | bc). Cette ligne utilise echo pour envoyer l’expression « $a + $b » (qui se développe en « 10.5 + 5.2 ») à bc à travers un tube |. Le programme bc calcule ensuite la somme de ces nombres. Le résultat de ce calcul est capturé et attribué à la variable sum via la substitution de commande $ (...).

    Enfin, le script utilise echo « Sum : $sum » pour imprimer le résultat. Il affiche la chaîne « Somme : » suivie de la valeur de somme, affichant effectivement « Somme : 15,7 » sur la console. Cet exemple illustre comment gérer l’arithmétique en virgule flottante dans Bash à l’aide de la commande bc.

  13. Calcul de la racine carrée

    number=16
sqrt=$(echo "scale=2; sqrt($number)" | bc -l)
echo "Square root of $number: $sqrt"

    Ce script Bash calcule la racine carrée d’un nombre à l’aide de l’utilitaire bc, qui est une calculatrice en ligne de commande. Le script attribue la valeur 16 à la variable number avec number=16. L’opération clé, sqrt=$ (echo « scale=2 ; sqrt($number) » | bc -l), utilise echo pour envoyer la commande sqrt($number) (qui devient sqrt(16)) à bc, en spécifiant une échelle de 2 pour obtenir le résultat avec deux décimales. La commande bc -l appelle bc avec la bibliothèque mathématique standard, qui est nécessaire pour la fonction racine carrée. La racine carrée calculée, 4,00, est ensuite stockée dans la variable sqrt. Enfin, echo « Racine carrée de $number : $sqrt » imprime le résultat, affichant « Racine carrée de 16 : 4.00 ».

  14. Logarithme népérien avec bc

    #!/bin/bash
number=7
ln=$(echo "l($number)" | bc -l)
echo "Natural logarithm of $number: $ln"

    Ce script Bash calcule le logarithme népérien d’un nombre à l’aide de l’utilitaire bc, qui est amélioré avec l’option -l pour inclure la bibliothèque mathématique standard nécessaire aux calculs logarithmiques. Le script commence par attribuer la valeur 7 à la variable number à l’aide number=7. L’opération clé, ln=$ (echo « l($number) » | bc -l), envoie la commande l($number) (qui devient l(7)) à bc. Cette commande calcule le logarithme népérien (base e) de 7.

    Le résultat de ce calcul est capturé et stocké dans la variable ln à l’aide de la substitution de commande $ (...). Enfin, le script utilise echo « Logarithme népérien de $number : $ln » pour imprimer le résultat, affichant le logarithme népérien de 7, formaté sous la forme d’un nombre à virgule flottante.

  15. Gérer des nombres scientifiques avec awk

    #!/bin/bash
sum=$(awk 'BEGIN {print (1.23e2 + 3.45e3)}')
echo "Sum: $sum"

    Ce script Bash calcule la somme de deux nombres en notation scientifique à l’aide de awk, un puissant outil de traitement de texte et de calcul arithmétique. La commande sum=$ (awk 'BEGIN {print (1.23e2 + 3.45e3)}') utilise awk pour effectuer l'ajout de 1.23e2 (qui est 1.23×1021.23×102, ou 123) et 3. 45e3 (qui est 3.45×1033.45×103, soit 3450).

    Le bloc BEGIN de la commande awk garantit que le calcul est effectué immédiatement, sans qu’il soit nécessaire de le saisir. Le résultat de cet ajout, 3573, est ensuite capturé et stocké dans la somme de variables via la substitution de commande $ (...). Enfin, le script renvoie ce résultat à l’aide de echo « Sum : $sum », qui affiche la chaîne « Sum : " suivie de la valeur de sum (3573 dans ce cas) à la console. Cet exemple montre comment awk peut être utilisé pour les opérations arithmétiques, en particulier avec les nombres en notation scientifique.

  16. Calcul du nombre de lignes de fichier

    #!/bin/bash
file="example.txt"
line_count=$(wc -l < "$file")
echo "The file $file has $line_count lines."

    Ce script Bash compte le nombre de lignes d’un fichier et affiche le résultat. Le script définit le fichier variable sur le nom du fichier à traiter, « example.txt », en utilisant file="example.txt ». Il utilise ensuite la commande line_count=$ (wc -l < « $file ») pour compter les lignes.

    La commande wc -l compte le nombre de lignes dans le fichier, et la redirection < « $file » alimente le contenu du fichier dans wc. Le résultat de ce nombre de lignes est stocké dans la variable line_count. Enfin, le script affiche le nombre de lignes à l’aide de echo « Le fichier $file a $line_count lines. », affichant un message avec le nombre de lignes dans « example.txt ».

  17. Calcul de la surface

    #!/bin/bash
length=10
width=5
area=$((length * width))
echo "The area of the rectangle is ${area} square units"

    Ce script Bash calcule l’aire d’un rectangle et affiche le résultat. Le script attribue la valeur 10 à la variable length et 5 à width, représentant les dimensions du rectangle. La ligne area=$ ((longueur * largeur)) effectue une opération arithmétique pour calculer l’aire en multipliant la longueur et la largeur, en stockant le résultat (50 dans ce cas) dans l’aire variable.

    Enfin, le script utilise echo « L’aire du rectangle est $ {area} unités carrées » pour imprimer l’aire calculée. Ce message affiche « L’aire du rectangle est de 50 unités carrées », montrant effectivement le résultat de la multiplication comme l’aire du rectangle en unités carrées. Cet exemple illustre l’utilisation de base de l’arithmétique et des variables dans un scénario pratique dans Bash.

  18. Utilisation de let pour l’arithmétique

    #!/bin/bash
a=10
b=5
let sum=a+b
echo "Sum: $sum"

    Ce script Bash calcule la somme de deux nombres à l’aide de la commande let, une fonction intégrée pour les opérations arithmétiques. Le script définit les variables a et b à 10 et 5, respectivement, avec a=10 et b=5. La commande let sum=a+b effectue ensuite l’addition de a et b, en attribuant le résultat (15) à la variable somme. Enfin, le script utilise l’écho « Somme : $sum » pour imprimer la somme, en affichant « Somme : 15 » sur la console.

Conclusion

La maîtrise des opérations arithmétiques dans les scripts Bash ouvre un monde de possibilités pour l’automatisation des tâches et le traitement des données numériques. Que vous effectuiez des calculs simples ou des opérations complexes impliquant des nombres à virgule flottante et la notation scientifique, Bash fournit les outils et la flexibilité nécessaires à une création de scripts efficace. En incorporant ces exemples dans vos scripts, vous pouvez améliorer leur fonctionnalité et leur efficacité.

Foire aux questions : Principes fondamentaux de l’arithmétique Bash

  1. Qu’est-ce que le script Bash ? Le script Bash est une méthode permettant d’automatiser des tâches dans des systèmes d’exploitation de type Unix à l’aide du shell Bash.
  2. Comment effectuer des ajouts dans Bash ? Utilisez sum=$ ((a + b)) pour ajouter les variables a et b.
  3. Bash peut-il gérer l’arithmétique à virgule flottante ? Oui, en utilisant des outils externes comme bc ou awk.
  4. À quoi sert la commande expr ? La commande expr effectue des opérations arithmétiques de base telles que l’addition et la multiplication.
  5. Comment incrémenter une variable dans Bash ? Utilisez ((variable++)) pour incrémenter la valeur d’une variable.
  6. Que fait $ ((expression)) dans Bash ? Cette syntaxe effectue une expansion arithmétique avec l’expression donnée.
  7. Comment calculer le module dans Bash ? Utilisez module=$ ((a % b)) pour calculer le module.
  8. Est-il possible de calculer la puissance dans Bash ? Oui, utilisez power=$ ((base**exponent)) pour les calculs de puissance.
  9. Comment puis-je comparer deux numéros dans Bash ? Utilisez des instructions conditionnelles comme if ((a > b)) à des fins de comparaison.
  10. Bash peut-il effectuer des opérations de boucle avec l’arithmétique ? Oui, les boucles for peuvent incorporer des opérations arithmétiques, par exemple, for ((i=1 ; i <= 5 ; i++)).
  11. Comment calculer la racine carrée dans Bash ? Utilisez sqrt=$ (echo « scale=2 ; sqrt($number) » | bc -l) avec bc.
  12. Quel est le rôle de la commande let ? La commande let est utilisée pour les affectations arithmétiques dans Bash.
  13. Comment trouver le nombre de lignes dans un fichier ? Utilisez line_count=$ (wc -l < « $file ») pour compter les lignes dans un fichier.
  14. Comment calculer la superficie à Bash ? Utilisez area=$ ((longueur * largeur)) pour le calcul de la surface d’un rectangle.
  15. Le script Bash peut-il gérer la notation scientifique ? Oui, à l'aide d'outils comme awk, par exemple, awk 'BEGIN {print (1.23e2 + 3.45e3)}'.

Articles connexes: