Fil d'Ariane
Mis à jour le mercredi 4 octobre 2017
  • 30 heures
  • Facile

Ce cours est visible gratuitement en ligne.

Ce cours est en vidéo.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

J'ai tout compris !

Utilisez la boucle while

Connectez-vous ou inscrivez-vous pour bénéficier de toutes les fonctionnalités de ce cours !

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

Bah, c'est-à-dire que...

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é 1499€. Bien sûr, on pourrait avoir une approximation avec le nombre de mois nécessaire. 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  !

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 le 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".

14906931642575_Exercice%20Banner.png

Rien de mieux que la mise en pratique ! Créez un programme qui affiche :

Nous sommes en 1950. Je ne suis pas né !
Nous sommes en 1951. Je ne suis pas né !
.
.
.
Nous sommes en 1991. Je ne suis pas né !
Nous sommes en 1992. Je suis né !

Le programme s'arrête l'année de votre naissance pour déclarer votre venue sur terre ! À vous de jouer !

// Pas de triche !














































var year = 1950
var dateOfBirth = 1992

while year < dateOfBirth {
    print("Nous sommes en \(year). Je ne suis pas né !")
    year += 1
}

print("Nous sommes en \(year). Je suis né !")

 Vous aviez réussi ? Oui ?! Félicitations ! Réessayez avec la correction sinon. L'essentiel est que vous compreniez ce que vous faites.

 C'est tout pour la boucle while !

La boucle while
La boucle while

Changeons le programme

Nous allons pouvoir changer notre programme pour utiliser la boucle while. Nous allons essayer d'obtenir quelque chose qui ressemble à ceci :

TANT QUE l'argent est inférieur à 1499€:
    Ajoute une journée
    Ajoute l'argent gagnée pendant cette journée

Affiche le nombre de jours total

Allez, je vous laisse faire !

// Essayez !






































// Le prix du voyage
let price = 1499.0

// Le nombre de jours pendant lesquels Joe doit économiser
var numberOfDay = 0

// L'argent de Joe
var money = 0.0

while money < price {
    // Joe nourrit les vaches tous les jours
    money -= 4

    if numberOfDay == 1 {
        // Joe moissonne
        money += 100 * 0.30
    } else if numberOfDay == 10 || numberOfDay == 20 {
        // Joe tonds les moutons
        money += 30 * 1
    } else {
        // Joe vends son lait
        money += 30 * 0.50
    }
    
    // On passe au jour suivant
    numberOfDay += 1
}

print("Il aura fallu \(numberOfDay) jours à Joe pour économiser \(money) €")

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és ! :D

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

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 tonds 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. 

Division Euclidienne
Division euclidienne

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.

14906931642575_Exercice%20Banner.png

Maintenant, je vous propose un petit exercice. En bouclant sur 30 jours, affichez :

  • "Super c'est le week-end !" Si le jour est un samedi ou un dimanche.

  • "Allez au travail !" Les autres jours de la semaine.

Les 30 jours commencent un lundi. Pour ce programme, je vous impose d'utiliser une boucle while. C'est à vous !

// Ne trichez pas !















































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

while day < 30 {
    if day % 7 == 5 || day % 7 == 6 {
        // C'est le 6e ou 7e jour de la semaine
        print("Super c'est le week-end !")
    } else {
        print("Allez au travail !")
    }
    day += 1
}

Cet exercice était un peu plus dur donc ne vous inquiétez pas si vous n'avez pas réussi. 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 :

0

1

2

3

4

5

6

Lundi

Mardi

Mercredi

Jeudi

Vendredi

Samedi

Dimanche

Cela vaut pour la première semaine. Mais pour la semaine suivante, 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 ?

Avec l'opérateur modulo, nous allons pouvoir changer notre programme. Je vous laisse le changer pour obtenir tous les 1ers, 10 et 20 du mois !

// A vous de jouer !








































if numberOfDay % 30 == 1 {
    // Joe moissonne
} else if numberOfDay % 30 == 10 || numberOfDay % 30 == 20 {
    // Joe tonds les moutons
} else {
    // Joe vends son lait
}

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

Structure de contrôle

Ce chapitre clos 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).

Exemple de vue d'un programme selon son flux
Exemple de vue d'un programme selon son flux

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

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 3 structures de contrôles sur les 4 existantes en Swift :

    • Les boucles  for  et  while 

    • Les instructions  if / else if / else 

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

Exemple de certificat de réussite
Exemple de certificat de réussite