355 lines
11 KiB
Plaintext
355 lines
11 KiB
Plaintext
======C18 : Bash : Structures conditionnelles, boucles et calculs======
|
||
|
||
=====Objectifs :=====
|
||
* Savoir réaliser des opérations simples en bash
|
||
* Être capable d’utiliser dans vos scripts les instructions IF, WHILE et FOR
|
||
|
||
=====Cours=====
|
||
|
||
==== 1 - Arithmétique en bash ====
|
||
===Introduction===
|
||
Soyons clairs tout de suite :
|
||
|
||
__**Bash n'est PAS un langage pensé pour manipuler des nombres !**__ (vous vous rappellerez peut-être que je vous avais indiqué que, pour Bash, **toute variable est une chaine de caractères** ?)
|
||
|
||
Ceci étant dit, vouloir coder n’importe quoi d’un peu évolué sans jamais utiliser de nombres est une illusion, aussi va-t-il falloir apprendre comment ça marche.
|
||
|
||
Si vous tapez :
|
||
<code bash>
|
||
echo 1+2
|
||
</code>
|
||
Vous obtiendrez
|
||
<code bash>
|
||
1+2
|
||
</code>
|
||
|
||
Eh oui, par défaut, **tout est une chaine de caractère en bas**h, et donc ma belle opération ne s’exécute pas. Il s'agit pour le langage d'une suite de caractères comme n'importe laquelle.
|
||
|
||
===Syntaxe pour effectuer des calculs===
|
||
|
||
Si vous voulez que bash fasse un calcul, il faut l’entourer de **doubles parenthèses**.
|
||
|
||
Par exemple, si je tape :
|
||
<code bash>
|
||
((3+4))
|
||
</code>
|
||
|
||
Il ne s’affiche rien. Rien, mais **pas non plus d’erreur**, ce qui serait arrivé si vous aviez tapé :
|
||
<code bash>
|
||
3+4
|
||
</code>
|
||
|
||
Et en effet, quand vous avez tapé %%((3+4))%%, tout s’est bien passé. Votre **commande** a été bien comprise par l'interpréteur.
|
||
|
||
C’est juste que par défaut, **l’opérateur %%((%%** n’affiche rien sur la sortie standard. Si vous voulez récupérer la valeur de votre opération, ce qui sera souvent le cas, alors il faut mettre un **$ devant les doubles parenthèses**, ce qui vous donne par exemple :
|
||
<code bash>
|
||
$ echo $((1+2))
|
||
3
|
||
</code>
|
||
Et là c’est merveilleux, vous avez réussi votre première opération en bash.
|
||
|
||
Ça fonctionne de la même façon pour vos **quatre opérations de base** : + ; - ; * ; /
|
||
|
||
Toutefois, j’attire votre attention sur le fait que, si bash n’est guère fait pour manipuler des nombres, il n’est définitivement **pas pensé pour gérer les nombres réels** (vous savez, ces choses avec des virgules).
|
||
|
||
Donc si vous vous lancez dans des divisions, **soyez certains de l’intérêt**, et il vaudrait mieux que ça tombe sur des nombres entiers sinon vous allez au-devant de surprises (essayez, vous verrez !).
|
||
===Syntaxe avancée===
|
||
En plus des opérations classiques, vous avez accès à tout un tas d’opérateurs, et ne vous servirez sans doute jamais ou presque d’une majorité d’entre eux. Mais bon, si vous cherchez quelque chose de précis un jour :
|
||
|
||
|
||
* [[promo_2026:bloc1_sys_reseau:bash_operateurs | Bash : opérateurs de calcul]]
|
||
|
||
Pour vous, dans la pratique, ça devrait se limiter à ceci (exemples ci-dessous, avec deux variables a et b) :
|
||
* Addition : %%((a+b))%%
|
||
* Soustraction : %%((a-b))%%
|
||
* Multiplication : %%((a*b))%%
|
||
* Division entière : %%((a/b))%%
|
||
* Reste de la division : %%((a%b))%%
|
||
* Mise en exposant (de la 2e variable) : %%((a**b))%%
|
||
* Incrémentation : %%((a++))%% (ajoute 1 à la valeur de a)
|
||
|
||
<code bash>
|
||
# Affectation des valeurs 4 et 5 aux variables a et b
|
||
sio@demo:~$ a=4
|
||
sio@demo:~$ b=5
|
||
# Exemple d'affiche du résultat d'opérations
|
||
sio@demo:~$ echo $((a+b))
|
||
9
|
||
sio@demo:~$ echo $((a-b))
|
||
-1
|
||
sio@demo:~$ echo $((a*b))
|
||
20
|
||
sio@demo:~$ echo $((a/b))
|
||
0
|
||
sio@demo:~$ echo $((a%b))
|
||
4
|
||
sio@demo:~$ echo $((a**b))
|
||
1024
|
||
sio@demo:~$ echo $((b++))
|
||
6
|
||
# Comme l'on vient d'augmenter la valeur de b :
|
||
sio@demo:~$ echo $b
|
||
6
|
||
# Calcul avec un opérateur d'affectation (affecte le résultat à la première variable du calcul) :
|
||
sio@demo:~$ ((a*=b))
|
||
sio@demo:~$ echo $a
|
||
24
|
||
</code>
|
||
|
||
==== 2 - Structures conditionnelles ====
|
||
Comme tout langage de programmation, Bash dispose de structures de contrôle. La première que nous allons voire est la commande if. Au premier abord, la syntaxe est simple :
|
||
<code bash>
|
||
if condition ; then
|
||
instructions
|
||
else
|
||
instructions
|
||
fi
|
||
</code>
|
||
|
||
Vous pouvez également utiliser elif pour else if (si condition de if non validée, deuxième condition) :
|
||
<code bash>
|
||
if condition ;then
|
||
instructions
|
||
elif condition ; then
|
||
instructions
|
||
else
|
||
instructions
|
||
fi
|
||
</code>
|
||
|
||
On peut enchainer plusieurs elif si besoin, mais ayez bien conscience que **si une condition est validée, les suivantes ne seront pas vérifiées**. Il faut donc bien réfléchir à l’ordre dans le cas des conditions multiples.
|
||
|
||
Il doit y avoir **exactement un fi par if**, pas besoin de mettre de fi pour un elif.
|
||
|
||
**Après chaque condition**, il doit y avoir un **then**. Il n’est absolument pas obligatoire d’inclure de clauses else ou elif.
|
||
|
||
:!:Il faut bien écrire if, then, else, elif, et fi en minuscules.:!:
|
||
|
||
C’est pour les conditions que les choses se compliquent un peu. Il faut séparer deux cas :
|
||
|
||
===A – Conditions sur les entiers===
|
||
Si vos conditions portent sur des **nombres entiers**, elles doivent être e**ntourées de double parenthèses** comme pour tout calcul, comme on a vu précédemment. Cela donne par exemple ceci :
|
||
<code bash>
|
||
read number
|
||
if (( $number >= 50 )) ; then
|
||
echo "nombre saisi supérieur ou égal à 50"
|
||
fi
|
||
</code>
|
||
|
||
Les opérateurs utilisables sur les nombres sont les suivants :
|
||
|Egal |==|
|
||
|Différent |!=|
|
||
|Strictement supérieur |>|
|
||
|Strictement inférieur|<|
|
||
|Supérieur ou égal|>=|
|
||
|Inférieur ou égal|<=|
|
||
Attention, **pas de $ devant ces doubles parenthèses-ci**, ce qui vous intéresse n’est pas la valeur de votre calcul mais le code de retour de l’expression, qui déclenchera la validation ou non du test IF.
|
||
===B – Autres conditions===
|
||
Si ce que vous voulez tester n’est pas à proprement parler un calcul sur des nombres entiers (comme tout ce qu’on a fait jusque-là), alors il faudra utiliser les **doubles crochets**.
|
||
|
||
:!:Des doubles crochets doivent être **séparés de la condition à évaluer par un espace**, sans quoi rien ne marche.:!:
|
||
|
||
Ca donne par exemple des choses comme ça :
|
||
Script :
|
||
<code bash>
|
||
#!/bin/bash
|
||
read text
|
||
if [[ $text < "o" ]] ;then
|
||
echo "ce texte commence par une des 13 premières lettres de l'alphabet
|
||
else
|
||
echo "ce texte commence par une des 13 dernières lettres de l'alphabet
|
||
fi
|
||
</code>
|
||
|
||
Les opérateurs utilisables sur les nombres sont les suivants :
|
||
|Egal |==|
|
||
|Différent |!=|
|
||
|Postérieur dans l’ordre alphabétique |>|
|
||
|Antérieur dans l’ordre alphabétique |<|
|
||
:!:Les opérateurs de comparaison de chaines doivent être encadrés par des espaces, sans quoi des choses étonnantes se produisent.:!:
|
||
==== 3 - Les boucles ====
|
||
En programmation, une boucle est une structure logique définissant la **répétition d’instructions** jusqu’à **validation d’une condition.**
|
||
===A – Boucle WHILE===
|
||
La boucle **while** (« tant que ») permet de répéter une série d’instructions tant qu’une **condition** vérifiée entre chaque exécution n’est **pas validée**. Sa structure est la suivante :
|
||
<code bash>
|
||
while condition
|
||
do
|
||
instructions
|
||
done
|
||
</code>
|
||
|
||
Les conditions marchent **exactement pareil que pour if**. Par exemple :
|
||
Script :
|
||
<code bash>
|
||
#!/bin/bash
|
||
i=0
|
||
while (( $i < 4 ))
|
||
do
|
||
((i++))
|
||
echo "Et de $i !"
|
||
done
|
||
</code>
|
||
Exécution :
|
||
<code bash>
|
||
Et de 1 !
|
||
Et de 2 !
|
||
Et de 3 !
|
||
Et de 4 !
|
||
</code>
|
||
|
||
Au passage, notez **l’instruction %%((i++))%%**. C’est ce que l’on appelle une **incrémentation** : on augmente la valeur de la variable i de +1 à chaque fois que cette instruction est répétée (cela aurait pu s’écrire %%((i=$i+1))%% mais c’est plus long).
|
||
|
||
Les incrémentations sont à la base de la logique qui régit la majorité des boucles : on fait évoluer une variable / un compteur jusqu’à ce que la condition posée soit validée.
|
||
|
||
===B – Boucle FOR===
|
||
La boucle for (« jusqu’à ce que ») permet de répéter une série un **nombre défini de foi**s, la plupart du temps **via un compteur**. En bash, toutefois, elle est un peu spéciale. Contrairement à la plupart des autres langages, une boucle for va donner à son compteur les valeurs contenues dans une **liste de mots successifs**.
|
||
Sa structure est la suivante :
|
||
<code bash>
|
||
for i in listedemots
|
||
do
|
||
instructions
|
||
done
|
||
</code>
|
||
|
||
Par exemple, ce script :
|
||
<code bash>
|
||
for i in "a" "b" "c" "d" "e"
|
||
do
|
||
echo $i
|
||
done
|
||
</code>
|
||
Donnera ceci :
|
||
<code bash>
|
||
a
|
||
b
|
||
c
|
||
d
|
||
e
|
||
</code>
|
||
(Au passage, il n’est pas impératif de mettre vos mots entre guillemets)
|
||
|
||
Il est bien entendu possible de faire des boucles for davantage similaires aux autres langages, en proposant à la place de la liste de mots un **intervalle d’entiers** dont la syntaxe sera **{a..b} SANS ESPACES**.
|
||
|
||
Ainsi, on aura pour ce script :
|
||
<code bash>
|
||
for i in {1..4}
|
||
do
|
||
echo $i
|
||
done
|
||
</code>
|
||
Cette exécution :
|
||
<code bash>
|
||
1
|
||
2
|
||
3
|
||
4
|
||
</code>
|
||
Vous pouvez bien sûr utiliser des substitutions de commandes là-dedans :
|
||
<code bash>
|
||
for i in $(ls)
|
||
do
|
||
echo $i
|
||
done
|
||
</code>
|
||
Ainsi, ce script va lister le contenu du dossier courant. Pratique !
|
||
<code bash>
|
||
file1
|
||
dir1
|
||
dir2
|
||
</code>
|
||
===C - Pour aller plus loin===
|
||
A noter que les **boucles** peuvent être utilisées pour **parcourir des fichiers** et effectuer ainsi des opérations plus complexes, ou en tout cas plus lisibles, qu'avec des suites de pipe. Pour plus d'infos :
|
||
|
||
* [[promo_2026:bloc1_sys_reseau:shell_scripting | Shell : Scripts]]
|
||
|
||
=====Diaporama=====
|
||
|
||
==== 1 - Arithmétique en bash ====
|
||
===Introduction===
|
||
__**Bash n'est PAS un langage pensé pour manipuler des nombres !**__ .
|
||
===== =====
|
||
===Syntaxe pour effectuer des calculs===
|
||
|
||
Si vous voulez que bash fasse un calcul, il faut l’entourer de **doubles parenthèses**.
|
||
===== =====
|
||
===Syntaxe avancée===
|
||
Multitude d’opérateurs :
|
||
|
||
|
||
* [[promo_2026:bloc1_sys_reseau:bash_operateurs | Bash : opérateurs de calcul]]
|
||
|
||
Pour vous, dans la pratique, ça devrait se limiter à ceci :
|
||
* Addition : %%((a+b))%%
|
||
* Soustraction : %%((a-b))%%
|
||
* Multiplication : %%((a*b))%%
|
||
* Division entière : %%((a/b))%%
|
||
* Reste de la division : %%((a%b))%%
|
||
* Mise en exposant (de la 2e variable) : %%((a**b))%%
|
||
* Incrémentation : %%((a++))%% (ajoute 1 à la valeur de a)
|
||
===== =====
|
||
==== 2 - Structures conditionnelles ====
|
||
|
||
<code bash>
|
||
if condition ; then
|
||
instructions
|
||
else
|
||
instructions
|
||
fi
|
||
</code>
|
||
===== =====
|
||
Vous pouvez également utiliser elif pour else if :
|
||
<code bash>
|
||
if condition ;then
|
||
instructions
|
||
elif condition ; then
|
||
instructions
|
||
else
|
||
instructions
|
||
fi
|
||
</code>
|
||
===== =====
|
||
|
||
===A – Conditions sur les entiers===
|
||
**Nombres entiers** = conditions **entourées de double parenthèses**
|
||
===== =====
|
||
Les opérateurs utilisables sur les nombres sont les suivants :
|
||
|Egal |==|
|
||
|Différent |!=|
|
||
|Strictement supérieur |>|
|
||
|Strictement inférieur|<|
|
||
|Supérieur ou égal|>=|
|
||
|Inférieur ou égal|<=|
|
||
===== =====
|
||
===B – Autres conditions===
|
||
**doubles crochets** pour tout ce qui n'est pas nombres entiers
|
||
===== =====
|
||
|
||
Les opérateurs utilisables sur les nombres sont les suivants :
|
||
|Egal |==|
|
||
|Différent |!=|
|
||
|Postérieur dans l’ordre alphabétique |>|
|
||
|Antérieur dans l’ordre alphabétique |<|
|
||
===== =====
|
||
==== 3 - Les boucles ====
|
||
===A – Boucle WHILE===
|
||
<code bash>
|
||
while condition
|
||
do
|
||
instructions
|
||
done
|
||
</code>
|
||
===== =====
|
||
|
||
===B – Boucle FOR===
|
||
Un peu spéciale : liste de **"mots" successifs** plutôt qu'un compteur :
|
||
<code bash>
|
||
for i in listedemots
|
||
do
|
||
instructions
|
||
done
|
||
</code>
|
||
===== =====
|
||
===C - Pour aller plus loin===
|
||
A noter que les **boucles** peuvent être utilisées pour **parcourir des fichiers** et effectuer ainsi des opérations plus complexes, ou en tout cas plus lisibles, qu'avec des suites de pipe. Pour plus d'infos :
|
||
|
||
* [[promo_2026:bloc1_sys_reseau:shell_scripting | Shell : Scripts]] |