Apprenez les fondamentaux de Swift

Bon, il n'y a pas quelque chose qui vous chiffonne ?

N'en dites pas plus, je le savais ! Quel est l'intérêt de calculer sur 30 jours l'argent gagné ? Ce qui nous intéresse, c'est de savoir au bout de combien de temps notre fermier a économisé 1 499 €. Bien sûr, on pourrait avoir une approximation avec le nombre de mois nécessaires. Mais des billets d'avion, c'est au jour près ! Donc il va falloir trouver une solution !

Et la solution, c'est la boucle  while  !

Découvrez la boucle  while

Un peu d'anglais tout d'abord ! While veut dire "tant que".

La boucle while est un peu un intermédiaire entre la boucle for et l'instruction if. La boucle while est une boucle, donc elle permet de répéter des instructions comme la boucle for. Non pas à partir d'un intervalle, mais à partir d'une condition comme l'instruction if.

Voici ce que ça donne :

while expressionlogique {
   instruction1
   instruction2
   instruction3
   ...
}

On peut le lire comme "Tant que l'expression logique est vraie, effectue les instructions suivantes".

Voilà comment ça fonctionne dans le détail :

1. Le programme vérifie que  expressionlogique  est vraie.

2. Si elle est fausse :  les instructions entre accolades  {}  sont ignorées. On passe à la suite du programme.

3. Si elle est vraie : les instructions entre accolades  {}  sont exécutées.

4. Une fois les instructions exécutées, on revient au point 1.

Prenons un exemple pour essayer :

var nombreDeMoutons = 0

while nombreDeMoutons < 10 {
   nombreDeMoutons += 1
   print("Je compte \(nombreDeMoutons) moutons")
}

print("Je me suis endormi")

Copiez ceci dans votre Playground. La console affiche :

Je compte 1 moutons Je compte 2 moutons Je compte 3 moutons Je compte 4 moutons 
Je compte 5 moutons Je compte 6 moutons Je compte 7 moutons Je compte 8 moutons 
Je compte 9 moutons Je compte 10 moutons Je me suis endormi

À chaque tour de boucle, on incrémente de 1 la variable nombreDeMoutons  .  Lorsque la variable atteint la valeur  10  , la condition  nombreDeMoutons < 10   n'est plus vraie. Donc on sort de la boucle et l’on passe à la suite du programme. Il affiche donc : "Je me suis endormi".

Rien de mieux que la mise en pratique ! Essayez d'utiliser la boucle  while  avec cet exercice qui se trouve dans le dossier Github P2C3.1.

1. Ouvrez un nouveau Playground Xcode.

2. Copiez le contenu du fichier “main.swift” dans votre Playground.

3. Suivez les instructions.

while true {
   print("Je ne fais que me répéter !")
}

C'est tout pour la boucle  while  !

Utilisez la boucle  repeat-while

La boucle repeat-while est similaire à la boucle while, avec une différence clé. Le corps de la boucle repeat-while est exécuté une fois avant que l'expression de test ne soit vérifiée.

Pour vous faire une idée, la syntaxe de la boucle  repeat-while  s’écrit :

repeat {
  // corps de la boucle
} while (condition)

Voilà comment ça fonctionne dans le détail :

• Ici, le corps de la boucle est exécuté en premier. Ensuite, la condition est évaluée.

• Si la condition est vraie, le code dans la boucle dans l'instruction repeat est de nouveau exécuté.

• Puis, la condition est à nouveau évaluée.

• Ce processus se poursuit jusqu'à ce que la condition devienne fausse. Puis la boucle s'arrête.

Prenons un exemple pour essayer :

var nombreDeMoutons = 0

// Le corps de la boucle repeat s’exécute en premier, sans vérifier la condition de la boucle
repeat {
 print("Je compte \(nombreDeMoutons) moutons")
nombreDeMoutons += 1
if (nombreDeMoutons > 10 ) {
print("Je me suis endormi")
} // Ensuite, on vérifie la condition de la boucle et on répète le corps de la boucle jusqu’à que la condition devienne fausse
} while (nombreDeMoutons <= 10 )

C'est tout pour la boucle  repeat-while  , variante de la boucle  while  !

Nous allons pouvoir changer notre programme pour utiliser la boucle  while  . Le contenu de l’exercice se trouve dans le dossier Github P2C3.2.

1. Ouvrez un nouveau Playground Xcode.

2. Copiez le contenu du fichier “main.swift” dans votre Playground.

3. Suivez les instructions.

Ce qui donne la phrase :

Il aura fallu 133 jours à Joe pour économiser 1508.0 €

Vous avez quelque chose d'approchant ? Parfait ! Sinon, il y a deux raisons :

1. Vous vous êtes trompé ! 

2. Vous avez déjà remarqué que ce programme n'était pas tout à fait juste. Dans ce cas, bravo ! 

Découvrez l'opérateur modulo

Eh oui, il n'est pas juste. Le programme exécute 133 jours. Soit plus de 3 mois ! Or tel que notre programme est écrit, Joe moissonne le jour 1 / 133, et tond les moutons les jours 20 et 30 / 133. Donc une seule fois en trois mois pour la moisson, et 2 fois en trois mois pour les moutons. Il faut donc modifier notre programme pour qu'il prenne en compte la notion de mois.

Pour cela, nous allons découvrir un nouvel opérateur !

L'opérateur modulo est un opérateur pour le type  Int  uniquement, qui s'écrit  %   .

Pour bien comprendre ce que c'est précisément, il faut comprendre ce qu'est la division euclidienne. C'est la division d'un entier par un autre qui donne deux entiers : le quotient et le reste. 

Essayez de taper   14 / 4    dans votre Playground : vous obtenez 3. La division entière en Swift donne le quotient.

Maintenant, essayez de taper   14 % 4   . Vous obtenez 2. L'opérateur modulo donne le reste.

Si vous n'êtes pas très à l'aise avec la division euclidienne, essayez de trouver le quotient et le reste des divisions euclidiennes suivantes :

• 3 par 2.

• 14 par 7.

• 65 par 11.

Utilisez le Playground pour obtenir la correction.

À vous de jouer

Le contenu de l’exercice se trouve dans le dossier Github P2C3.3.

1. Ouvrez un nouveau Playground Xcode.

2. Copiez le contenu du fichier “main.swift” dans votre Playground

3. Suivez les instructions.

Décortiquons un peu.

Il y a tout d'abord une boucle while sur 30 jours :

var day = 0 // Le 0 c'est donc lundi

while day < 30 {
   day += 1
}

Jusque-là, ça doit aller. Sinon reprenez tranquillement la partie sur la boucle while. Et ensuite, on évalue le jour avec :

if day % 7 == 5 || day % 7 == 6 {

Expliquons-nous. Si le 0 est un lundi, les jours de la semaine sont donc répartis comme suit :

Cela vaut pour la première semaine. Mais pour les semaines suivantes, le samedi sera le jour 12, puis le 19, puis le 26.

Et si l’on fait la division euclidienne de 5, 12, 19 et 26 par 7, on a :

• 5 = 7 x 0 + 5

• 12 = 7 x 1 + 5

• 19 = 7 x 2 + 5

• 26 = 7 x 3 + 5

Le reste est toujours 5 ! Autrement dit, si on écrit   day % 7 == 5   , on obtient tous les samedis. Pour obtenir les dimanches, c'est la même chose avec   day % 7 == 6   .

Prenez le temps de bien vous familiariser avec cet opérateur un peu spécial si cela n'est pas complètement clair pour vous.

Et dans notre programme ?

Le contenu de l’exercice se trouve dans le dossier Github P2C3.4.

1. Ouvrez un nouveau Playground Xcode.

2. Copiez le contenu du fichier “main.swift” dans votre Playground.

3. Suivez les instructions.

 Vous aviez trouvé. Bravo ! Au passage, Joe a gagné 13 jours d'économie avec notre changement. Ça valait le coup de passer quelques dizaines de minutes pour apprendre l'opérateur modulo  !

Récapitulons les structures de contrôle

Ce chapitre clôt la partie sur les structures de contrôle en Swift. Et je vous propose de prendre un peu de hauteur sur ce que nous venons d'apprendre.

Nous avons appris à nous servir de :

• Deux boucles : la boucle for et la boucle while.

• L'instruction if / else if / else.

Ces trois éléments sont des structures de contrôle, c'est-à-dire qu'elles ont toutes les trois pour rôle de contrôler l'avancement du programme, soit en le divisant en plusieurs cas, soit en le faisant se répéter avec les boucles.

Vous pouvez donc imaginer votre programme comme une rivière, et ces trois structures de contrôle en influencent le cours. D'ailleurs, en anglais on appelle cela le control flow (flux de contrôle).

L'essentiel dans un programme, c'est de bien comprendre où vous êtes dans le flux pour ne pas faire n'importe quoi !

Il existe en Swift une autre structure de contrôle :  le  switch  , que nous verrons plus tard dans de prochains cours sur le développement iOS. Nous n'en avons pas besoin pour le moment avec Joe !

En résumé

• Nous avons découvert la boucle while qui permet de répéter des instructions tant qu'une condition est vraie.

while condition {
   // Instructions
}

• Nous avons découvert l'opérateur modulo, noté   %    : 

  • Il permet d'obtenir le reste d'une division euclidienne.

  • Par définition, il n'est applicable que sur des nombres de type  Int  . 

• Nous connaissons désormais 6 structures de contrôle sur les 9 existantes en Swift :

  • Les boucles   for in  ,  while  et repeat-while   .

  • Les instructions  if  /  else if   / else   .

• Un programme, c'est comme une rivière !

Dorénavant, on ne pourra plus vous faire tourner en rond si facilement ! ;)

Et si je vous disais que dans le prochain chapitre, vous alliez être capable de manipuler tout un tas de données, et que vous alliez découvrir un nouveau type ?  :o Cliquez sur ‘J'AI TERMINÉ CE CHAPITRE ET JE PASSE AU SUIVANT’, et n’oubliez pas de faire le quiz !