Swift-6-

Structure de contrôle: Itération

On appelle Itération le fait d’exécuter une séquence d’instructions destinée à être exécutée plusieurs fois. Pour réaliser un itération dans notre langage algorithmique nous avons étudié 3 formes de Structures itératives:

  • Structure itérative TANTQUE permet de répéter un ensemble d’instructions tant qu’une condition reste vraie.
  • Structure itérative REPETER JUSQUA permet de répéter un ensemble d’instructions jusqu’à ce qu’une condition devienne fausse.
  • Structure itérative POUR permet de répéter de façon inconditionnelle un nombre de fois connu à priori un ensemble d’actions (ou instructions).

On retrouve les mêmes structures itératives adaptées pour le langage Swift sous de formes un peu différentes mais la notion d’itération reste valide. Swift propose les 4 formes d’itération suivantes:

  • for initialisation; condition; increment { instructions }
  • for element in collection { instructions }
  • while condition { instructions }
  • repeat { instructions } while condition
La boucle classique style C

for initialisation; condition; increment { instructions }

for var index = 0; index < 3; ++index {
    print("index is \(index)")
}

L’expression « initialisation » est évaluée une fois à l’entrée pour initialiser les variables necessaire à l’execution de la boucle. de la boucle. Si l’expression « condition » est évaluée à false la boucle de termine sinon le code entre accolades est exécuté. Lorsque toutes les instructions de la boucle sont exécutées la variable « increment », ici index, est incrémentée ou décrémentée suivant l’opérateur choisi — ou ++

Un paricularité de cette boucle « la boucle infinie »

for ;; {
   // Attention cette boucle ne se termine jamais    
   print ("Infinite loop ")
}

Si l’on veut utiliser cette boucle , ce qui est fortement déconseillé par les bonnes pratiques de programmation, il faut gérer le test de fin. En voici un exemple:

var curseur = 0
for ;;
{   ++curseur
    print ("Curseur = \(curseur)")
    if curseur >= 3 {break}
}

On utilise dans cet exemple l’instruction break qui permet de sortir d’un bloc d’instructions donc de la boucle.

La boucle for-in

for element in collection { instructions }

for index in 1...5 {
    print("\(index) fois sur 5 avec résultat = \(index * 5)")
}

On utilise cette boucle pour parcourir tous les éléments d’une collection d’éléments ou d’un intervalle de valeurs. Un vecteur (Array) est un exemple typique de collection ainsi que la table (Dictionary) ou l’ensemble (Set). La collection Dictionary et Set seront étudiés dans les prochains articles.

Dans l’exemple ci-dessus la collection est un intervalle de valeurs dont les éléments seront visités depuis l’indice 1 jusqu’à l’indice 5 inclus, ceci est conditionné par l’opérateur (…). L’exemple ci-dessous montre une boucle dite fermée avec l’opérateur (..<)

for index in 1..<5 {
    print("\(index) fois sur 5 avec resultat = \(index * 5)")
}

Dans le cas d’un collection de type « intervalle de valeurs » on peut ignorer la valeur de l’index si l’on n’en pas l’utilité dans le corps de la boucle. Il suffit de mentionner le symbole underscore ou tiret-bas en français.

let nombre = 3
let puissance = 4
var réponse = 1
for _ in 1...puissance {
    réponse *= nombre
}
print("\(nombre) élevé à la puissance \(puissance) est \(réponse)")

Un exemple de boucle dont la collection est un vecteur (Array)

let noms = ["Paul", "Carole", "Steve", "Laura"]
for nom in noms {
 print("Hello, \(nom)!")
}
La boucle while

while condition { instructions }

Cett boucle est utilisée principalement quant on ne connait pas à priori le nombre d’itérations à réaliser. le test de fin est conditionné par l’expression « condition », laquelle condition doit être gérée dans le corps de la boucle

var compteur = 0 
while compteur < 5 {
   print(compteur)
   compteur++
}

Un autre exemple:

var condition = 5
 while condition >= 0 {
 print(condition)
 condition--
 }

Utilisation de l’instruction break dans une boucle while.

L’exemple suivant permet d’extraire les nombres pairs d’une suite de nombres. La boucle continue jusqu’à la rencontre de l’instruction break conditionnée par un test. Ici la condition de la boucle est toujours vraie while true, c’est un boucle infinie, donc l’arrêt doit être codé à l’intérieur du corps de la boucle. Notons que cet exemple n’est pas un modèle de bonnes pratiques de programmation, à éviter donc puisque l’on peut faire beaucoup plus simple et beaucoup plus élégant pour arriver au même résultat.

var unNombre = 5
var compteurDeNombresPairs = 0
while true {
    if unNombre % 2 == 0 {
       print("Le nombre \(unNombre) est pair")
        compteurDeNombresPairs++
        if compteurDeNombresPairs == 3 {
            break
        }
    } else {
        print("Le nombre \(unNombre) est impair")
    }
    unNombre++
}

 

Dans l’exemple ci-dessous on utilise l’instruction continue qui permet de modifier le comportement d’un boucle différemment de l’instruction break. En effet, à la rencontre d’une instruction continue dans une boucle, l’itération courante est arrêtée mais la boucle poursuit l’exécution vers l’itération suivante. L’exemple suivant imprime uniquement les nombres impairs de la suite des 10 premiers nombres.

for nombre in 0...10 {
   // Si le nombre est pair retour au début de la boucle
   if (nombre % 2) == 0 {
      continue
   }
   print("Le nombre \(nombre) est impair")
}
La boucle repeat – while

repeat { instructions } while condition

Cette boucle est l’équivalent de la boucle Répéter- jusqu’à vue dans la partie algorithmique Structures Itératives

var taille = 10
repeat {
    taille++
    print(taille)
} while taille < 16
var compteur = 0 
repeat  {
   print(compteur)
   compteur++
} while compteur < 5