En programmation le terme boucle fait référence à l’exécution répétitive d’une ou plusieurs instruction. Une boucle répétitive est une structure de contrôle qui permet de répéter l’exécution d’une séquence d’instructions. Elle comporte obligatoirement
- Un bloc d’instructions qui est exécuté à chaque itération
- Une instruction d’arrêt, grâce à laquelle la boucle s’arrête
- Un itérateur qui est le moyen par lequel on réalise la répétition
L’itération, couramment utilisé en programmation, est un processus qui consiste à répéter une séquence d’instructions afin de produire le résultat souhaité. La plupart des langages de programmation impérative implémente l’itération comme une boucle for ou une boucle while
Pour établir une boucle on met en œuvre un itérateur, il défini la manière de parcourir séquentiellement une collection d’éléments.
On dispose de plusieurs techniques pour mettre en œuvre un itérateur :
- Le compteur: il est placé à l’intérieur de la boucle, il compte le nombre d’itération.
- Une expression booléenne: la boucle s’arrête quand la valeur de l’expression booléenne qui contrôle la boucle est Faux .
- Le parcours d’une collection d’éléments: la boucle s’arrête lorsque le dernier élément de la collection est atteint.
- Un nombre entier: la boucle est répétée autant de fois que la valeur du nombre.
- Un intervalle: la boucle est répétée autant de fois qu’il ys d’éléménts dans l’intervalle.
Note: Une boucle sans itérateur est par définition une boucle infinie. Le seul moyen de l’arrêter est d’utiliser une instruction de sortie de boucle.
En Schema, un itération est guidée par une condition booléenne, un nombre, un ensemble ou un booléen
L’itération se décline sous quatre formes
- Itération bornée ,elle permet d’effectuer un traitement un nombre de fois déterminé soit par un entier soit par un intervalle compris entre une borne de départ et de bornes d’arrivée.
- Itération conditionnelle, elle permet d’effectuer un traitement de zéro à plusieurs fois suivant qu’une expression booléenne est Vrai ou Faux.
- Itération de parcours, elle consiste à énumérer séquentiellement chaque élément d’une structure de données.
- Itération booléenne, elle dépend des deux seules valeurs booléenne Vrai ou Faux
Modèle itératif de Schema
Une itération est constituée d’une expression itérable suivie d’une ou plusieurs instructions, terminée par le mot réservé Fin
Expression_Itérable
séquence d’instructions
Fin
Chaque expression itérable peut être suivie d’un séparateur : suivi d’un identificateur. Cette forme d’itérateur permet d’accéder à chaque élément ou index lors de l’itération.
Expression_Itérable : Element
séquence d’instructions
Fin
Les expressions itérables correspondant à chaque forme d’itération sont
- Conditionnelle, l’expression itérable est une expression booléenne
- Bornée, l’expression itérable est un nombre ou un intervalle
- Parcours, l’expression itérable est une collection d’éléments
- Booléen l’expression itérable est Vrai ou Faux ‘
Itération conditionnelle
Dans la plupart des langages de programmation on implémente une itération conditionnelle avec l’expression while condition. Le langage Schema, ne défini pas de mot réservé équivalent à while à celui de en Python ou Swift.
l’instruction conditionnelle de Schema commence toujours par une expression booléenne. La valeur de l’expression est évaluée avant l’exécution des instructions à répéter. Il est possible la que la séquence d’instruction ne soient jamais exécutées si la condition est initialisée à Faux avant d »entrer dans la boucle.
Pour que la boucle se termine Il faut que dans a liste des instructions une instruction au moins évalue la condition à faux au bout d’un temps fini.
Prenons l’exemple de calcul de la somme des 3 premiers nombres entiers.
SommeDesTroisPremiersNombreEntier -> Entier
somme <- 0
index <- 0
somme <= 3
index = index + 1
somme <- somme + nombre
Afficher index #index
Afficher somme #somme
Fin
<- somme
Fin
Itération bornée par un nombre
l’expression itérable est un nombre entier.
Si l’on veut afficher 3 fois “hello Steve“ on écrira , l’algorithme:
helloSteve 3 Afficher hello Steve Fin
Dans le cas d’un bloc d’instructions
helloSteve 3 Afficher hello Steve Afficher have a nice day Fin Fin
Pour accéder à la valeur de l’index de boucle que l’on appellera nombre on écrit
helloSteve 3 : nombre Afficher hello Steve #nombre fois Afficher have a nice day Fin Fin
SommeDesTroisPremiersNombreEntier -> Entier somme <- 0 3 : nombre somme <- somme + nombre Afficher somme #somme Fin <- somme Fin
Itération bornée par un intervalle
l’expression itérable est un intervalle sur l’ensemble des nombres entier
Si l’on veut afficher 3 fois “hello Steve“ on écrira , l’algorithme:
L’intervalle est noté borneInférieure -> borneSupérieure
helloSteve
3 -> 5 Afficher hello Steve
Fin
Dans le cas d’un bloc d’instructions
helloSteve 3 -> 5 Afficher hello Steve Afficher have a nice day Fin Fin
Pour accéder à la valeur de l’index de boucle que l’on appellera nombre on écrit:
helloSteve 3 -> 5 : nombre Afficher hello Steve #nombre fois Afficher have a nice day Fin Fin
SommeDesTroisPremiersNombreEntier -> Entier somme <- 0 1 -> 3 : nombre somme <- somme + nombre Afficher somme #somme Fin <- somme Fin
Itération de parcours
Prenons l’exemple d’une collection de caractères dans un texte. L’expression itérable est l’identificateur d’un collection d’éléments. Un élément de type Texte est une expression itérable pour Schema. L’algorithme pour énumérer tous les caractères de la chaine s’écrit:
ParcoursTexte texte >- “HelloSteve“ texte : caractère Afficher caractère Fin
Ou sur plusieurs ligne
ParcoursTexte -> Entier texte >- “HelloSteve“ longueur <- 0 texte : caractère longueur <- longueur + 1 Afficher caractère Fin <- longueur Fin
Parcours d’un esnemble de nombre s entiers
SommeDesTroisPremiersNombreEntier -> Entier
ensemble >- [1 2 3]
somme <- 0
ensemble : nombre
somme <- somme + nombre
Afficher nombre #nombre
Afficher somme #somme
Fin
<- somme
Fin
Itération booléenne
L’expression itérable est représentée par les booléens Vrai ou Faux
C’est par définition une boucle infinie si aucune condition d’arrêt n’est spécifiée. Au moins une instruction particulière Sortie permet de provoquer l’arrêt immédiat de l’itération.
Les particularités de cette boucle: On ne l’utilise pratiquement jamais
- On peut simuler un boucle TantQue, l’instruction Sortie se trouve en début du bloc d’instructions à itérer
- On peut simuler une boucle Faire-Jusqua, l’instruction Sortie se trouve en fin de bloc d’instructions
- On peut exécuter tout ou partie d’un bloc d’instruction, les instructions Sortie sont placées dans le bloc d’instructions.
BoucleInfinie
Vrai Afficher infinite loop
Fin
La même boucle infinie avec la négation de Faux
BoucleInfinie Non Faux : index Afficher infinité loop Afficher itération #index Fin Fin
la version boucle de helloSteve avec une instruction de Sortie. Elle se termine quand le compteur index est supérieur ou égal à 3
helloSteve Vrai : index Afficher hello Steve #nombre fois Afficher have a nice day Sortie index <= 3 Fin Fin
Note: l’instruction de Schema Sortie conditionnelle marque la fin de la boucle.
SommeDesTroisPremiersNombreEntier -> Entier somme <- 0 nombre <- 0 Vrai nombre <- nombre + 1 somme <- somme + nombre Afficher nombre #nombre Afficher somme #somme Sortie somme > 3 Fin <- somme Fin
Traduction Swift
Itération Conditionnelle
func SommeDesTroisPremiersNombreEntier() -> Int {
var somme = 0
var index = 0
while somme <= 3 {
index = index + 1
somme = somme + index
print("index \(index)")
print("somme \(somme)")
}
return somme
}
Itération bornée par un nombre
func SommeDesTroisPremiersNombreEntier() -> Int {
var somme = 0
for nombre in 1...3 {
somme = somme + nombre
print("somme \(somme)")
}
return somme
}
Itération bornée par un intervalle
func SommeDesTroisPremiersNombreEntier() -> Int {
var somme = 0
for nombre in 1...3 {
somme = somme + nombre
print("somme \(somme)")
}
return somme
}
Itération de parcours
func ParcoursTexte() {
let texte = “HelloSteve“
for caractère in texte { print("caractère = \(caractère)") }
}
le même algorithme sur plusieurs lignes
func ParcoursTexte() -> Int {
let texte = “HelloSteve“
var longueur = 0
for caractère in texte {
longueur = longueur + 1
print("caractère = \(caractère)")
}
return longueur
}
La somme des 3 premiers nombres entiers peut aussi être calculée en parcourant l’ensemble des nombres entiers. ( File_Elements(1,2,3) déclare un ensemble d’entiers).
func SommeDesTroisPremiersNombreEntier() -> Int {
let ensemble = File_Elements(1,2,3)
var somme = 0
for nombre in ensemble {
somme = somme + nombre
print("nombre \(nombre)")
print("somme \(somme)")
}
return somme
}
Itération booléenne
La condition d’arrêt de cette boucle est implémentée avec l’instruction break
func SommeDesTroisPremiersNombreEntier() -> Int {
var somme = 0
var nombre = 0
while true {
nombre = nombre + 1
somme = somme + nombre
print("nombre \(nombre)")
print("somme \(somme)")
if somme > 3 { break}
}
return somme
}
Traduction Python
def SommeDesTroisPremiersNombreEntier():
somme = 0
index = 0
while somme <= 3 :
index = index + 1
somme = somme + index
print("index " + str(index))
print("somme " + str(somme))
return somme
def SommeDesTroisPremiersNombreEntier():
somme = 0
for nombre in range(3):
somme = somme + nombre
print("somme" + str(somme))
return somme
def SommeDesTroisPremiersNombreEntier():
somme = 0
for nombre in range(1,4):
somme = somme + nombre
print("somme" + str(somme))
return somme
def ParcoursTexte():
texte = "HelloSteve"
for caractère in texte :
print("caractère = " + str(caractère))
def SommeDesTroisPremiersNombreEntier():
ensemble = (1,2,3)
somme = 0
for nombre in ensemble:
somme = somme + nombre
print("nombre " + str(nombre))
print("somme " + str(somme))
return somme
def SommeDesTroisPremiersNombreEntier():
somme = 0
nombre = 0
while True:
nombre = nombre + 1
somme = somme + nombre
print("nombre " + str(nombre))
print("somme " + str(somme))
if somme > 3 : break
return somme
copyright A rchitectures A pplicatives A vancées A3-Soft