• 30 hours
  • Easy

Free online content available in this course.

course.header.alt.is_video

course.header.alt.is_certifying

Got it!

Last updated on 2/26/20

Collectez des données avec les tableaux

Log in or subscribe for free to enjoy all this course has to offer!

Message vocal du 0654321098

Salut, c'est Joe ! Merci pour l'estimation que tu m'as envoyée. En revanche, elle ne prend pas en compte ma grange. J'ai une grange qui peut contenir mes marchandises. Du coup je ne vais vendre mon blé, mon lait ou ma laine seulement lorsque la grange dépasse les 500 marchandises pour faire de la place.

Évidemment les jours où je vais vendre, je ne peux pas m'occuper du reste de la ferme.

Tu penses que c'est compliqué de prendre ça en compte ? Merci beaucoup pour ton aide !

Bon, il va y avoir du boulot !

Alors, allons-y !

Les collections

Pour mettre en place ces changements, il va nous falloir trouver un endroit dans notre programme où stocker le lait, le blé et la laine. Pour cela nous allons découvrir les collections !

Les collections en Swift sont un moyen de stocker plusieurs valeurs dans un même objet. Il en existe 3 différentes, chacune correspond à une logique de stockage différente :

Nom

Mot-clé Swift

Logique

Tableau

Array

Une liste ordonnée numériquement

Dictionnaire

Dictionary

Une liste ordonnée par clé

Ensemble

Set

Un ensemble de valeurs uniques non ordonnées

Nous allons tout de suite comprendre comment les tableaux nous permettent de créer la grange dans notre programme.

Les tableaux

Les tableaux sont donc des listes ordonnées numériquement. Concrètement ce sont donc des listes organisées par numéro. Par exemple, si on voulait stocker une liste de courses dans un tableau, cela ressemblerait à :

Les éléments sont donc rangés dans un ordre précis. Cet ordre est indiqué par un numéro. On appelle ce numéro l'index.

Syntaxe des tableaux

Voyons un peu ce que ça donne dans le code. Le tableau est un type qui se note  Array . Pour créer un tableau, il suffit d'utiliser les crochets :  []  et de noter les éléments séparer par des virgules :

[element1, element2, element3]

OK et qu'est-ce que je peux mettre dans un tableau ? 

Ce que vous voulez ! Des entiers, des décimaux, des chaînes de caractères, d'autres tableaux ! Bref, une collection comme une variable ça peut tout stocker. Car un tableau, c'est ni plus ni moins qu'une liste ordonnée de variables.

Vous n'avez qu'à essayer :

["bleu", "blanc", "rouge"]
[2, 4, 8, 16, 32, 64]

Copiez ça dans le Playground, en cliquant sur le petit oeil à droite vous constatez que le Playground vous donne des informations détaillées sur le tableau :

0 "bleu"
1 "blanc"
2 "rouge"

C'est bien beau tout ça, mais il y a des contraintes. Souvenez-vous, nos variables en ont aussi : elles ont toujours un type et ne peuvent pas changer de type. C'est la même chose pour les tableaux :

  • Un tableau qui contenait des  String ne peut pas ensuite contenir des  Bool .

  • On doit toujours connaître le type stocké par le tableau. 

  • Du coup, un tableau ne peut contenir qu'un seul type ! Un  Int , ne peut pas côtoyer un  Float par exemple !

Essayez d'écrire ceci :

["bleu", "blanc", "rouge"] // OK
["bleu", "blanc", "rouge", 12] // ERREUR

Le type tableau

Le type tableau est un type un peu particulier. Car contrairement aux autres types que vous connaissez comme  Bool ou  String , le type tableau est un type qui en contient un autre. Du coup, il se note avec des crochets et le nom du type stocké à l'intérieur comme ceci par exemple :  [Int] .

Pour déclarer une variable de type tableau qui va contenir des chaînes de caractères, on va donc pouvoir écrire :

var monTableauDeChaineDeCaracteres: [String]

Le cycle de vie d'une variable

Avec la déclaration précédente, si vous essayez d'accéder à la variable  monTableauDeChaineDeCaracteres , Swift va planter.

Mais je lui ai dit que c'était un tableau ! Que veut-il de plus ? 

L'initialisation ! Si vous écrivez par exemple :

var i: Int

On ne peut pas accéder à la variable  i ! Parce que la variable  i , comme la variable monTableauDeChaineDeCaracteres  , ne contient aucune valeur. On dit qu'elle n'est pas initialisé.

Cela me donne l'occasion de vous expliquer précisément le cycle de vie d'une variable en Swift. Une variable passe par 4 états différents :

  1. Déclaration

  2. Initialisation

  3. Modification

  4. Suppression

Un schéma vaudra mieux que de longues explications :

À l'étape de déclaration, la variable n'est pas encore initialisée. Donc on ne peut ni la modifier ni accéder à sa valeur, car elle n'en a pas !

Bien souvent la déclaration et l'initialisation ont lieu en même temps en écrivant ceci :

var i = 0       // Ici le type est déduit
var j: Int = 0  // Ici le type est explicite

Donc si on veut créer un tableau vide, il faut le déclarer puis l'initialiser. Pour cela, on va simplement utiliser les crochets :

var monTableauVide: [Int] 
monTableauVide = []

// ou en une ligne
var monTableauVide: [Int] = []

Vous noterez que nous devons préciser le type du tableau, car sa valeur  []  ne donne pas suffisamment d'informations sur son type. Si sa valeur avait été  [1] , on aurait pu se passer du type dans la déclaration.

On va voir d'ailleurs tout de suite comment initialiser un tableau vide sans préciser explicitement son type.

Initialiser les types

Il y a quelque chose que nous n’avons pas vu avec les types : on peut les initialiser en utilisant le nom du type suivi de parenthèses. Par exemple :

var s = String() // s contient ""
var i = Int()    // i contient 0
var f = Float()  // f contient 0.0
var d = Double() // d contient 0.0
var b = Bool()   // b contient false

Chaque initialisation renvoie une valeur par défaut. Nous reverrons cela plus en détail avec la programmation orientée objet. Mais sachez en tout cas que vous pouvez initialiser une variable comme ceci.

Du coup, cela fonctionne avec n'importe quel type ! Donc avec nos tableaux aussi. Donc on peut écrire :

var monTableauDeDecimaux = [Float]()

 monTableauDeDecimaux contient un tableau vide de type  Float . On a juste accolé les parenthèses  () au type désiré  [Float] .

La grange

La grange de Joe va être un tableau. Elle peut stocker trois types d'éléments différents que nous allons devoir compter : le lait, le blé et la laine.

Au début, nous allons partir du principe que la grange est vide. Donc nous allons décrire la grange comme ceci :

var barn = [0, 0, 0]

Le premier 0 représente le nombre de bidons de lait, le 2e le nombre de bottes de blé et le 3e le nombre de pelotes de laine. Vous copiez ce code en haut de notre programme.

Jouons avec les tableaux !

Oui je vous connais, parler, ça va 2 minutes. Vous êtes des personnes d'action !

Maintenant que les tableaux sont bien clairs pour vous, il nous reste seulement quelques petites choses à voir. 

Accéder et modifier les données

C'est très simple, on va utiliser l'index ! On va dire au programme : "Donne-moi l'élément qui se trouve à l'index 3". Pour cela, on va continuer à utiliser nos bons vieux crochets, comme ceci :

var notesDeLaClasse = [12, 18, 20, 16, 14, 14, 17, 19, 4]
notesDeLaclasse[2] // Le programme renvoie 20 !

Et pour modifier un élément dans un tableau, on va faire quasiment la même chose :

var notesDeLaClasse = [12, 18, 20, 16, 14, 14, 17, 19, 4]
// Le troisième éléve a triché ! Il mérite un 0...
notesDeLaclasse[2] = 0 // Et voilà ! Fallait pas tricher...

Mutabilité

Tout comme les variables, les tableaux peuvent être constants ou non. On parle de leur mutabilité. Et très simplement, on déclare un tableau modifiable avec  var  et un tableau constant avec  let .

var monTableauModifiable = [true, false, true]
let jeSuisConstant = [1, 1, 4]

Prenons 2 minutes pour comprendre ce que veut dire qu'un tableau est constant. Dans un tableau constant :

  • Les valeurs ne peuvent pas être modifiées.

  • La taille du tableau ne peut pas être modifiée. Autrement dit, on ne peut ajouter ni supprimer des éléments du tableau.

Ajouter et supprimer des éléments

Pour ajouter des éléments dans un tableau, il existe deux méthodes :

  •  append : permets d'ajouter un élément à la fin du tableau

  •  insert : permets d'ajouter un élément à l'index de son choix

Par exemple :

var courses = ["oeufs", "lait", "steak"]
courses.append("crème")         // ["oeufs", "lait", "steak", "crème"]
courses.insert("beurre", at: 0) // ["beurre", "oeufs", "lait", "steak", "crème"]

À la ligne 2, je rajoute "crème" à la fin du tableau. À la ligne 3, j'insère "beurre" à l'index 0 donc au début du tableau.

Pour supprimer des éléments, on utilise la méthode  remove  comme ceci :

// courses contient ["beurre", "oeufs", "lait", "steak", "crème"]
// En fait, j'ai du beurre dans mon frigo !
courses.remove(at: 0) // courses contient ["oeufs", "lait", "steak", "crème"]

On précise l'index de l'élément que l'on souhaite supprimer dans la méthode  remove .

Compter les éléments

Très souvent, on va avoir besoin de compter les éléments dans un tableau. Pour cela, on utilise la propriété  count  comme ceci :

var mesPoules = ["Rosette", "Lucienne", "Paquerette"]
mesPoules.count // Affiche 3

Parcourir un tableau

Parfois, il peut être utile de parcourir un tableau. C'est-à-dire faire le tour de tous les éléments du tableau. C'est-à-dire faire une boucle à l'intérieur du tableau. 

Euh une boucle, ça me dit quelque chose !  

Eh oui, on va utiliser une boucle for pour parcourir le tableau. C'est très simple, regardez :

var mesAmis = ["Pierre", "Paul", "Jacques"]
for unAmi in mesAmis {
    print("Salut \(unAmi) !")
}

Dans la console, vous verrez 

Salut Pierre !
Salut Paul !
Salut Jacques !

Nous avions vu l'utilisation de la boucle for avec les intervalles. Et bien on peut simplement faire la même chose avec les tableaux.

Dans cet exemple, la variable  unAmi contient à chaque tour de boucle un nouvel élément du tableau  mesAmis en suivant l'ordre du tableau. La boucle s'arrête lorsqu'on atteint la fin du tableau.

14906931642575_Exercice%20Banner.png

C'est l'heure d'un petit exercice ! Le tableau suivant contient les notes d'une classe pour un devoir.

var notesDeLaClasse = [18, 4, 14, 15, 17, 15, 9, 20, 19, 11, 12, 14]

 Fred a rendu sa copie en retard. Il a eu 13. Pouvez ajouter la note de Fred et calculer ensuite la moyenne de la classe ?

// Allez on ne triche pas !













































var notesDeLaClasse = [18, 4, 14, 15, 17, 15, 9, 20, 19, 11, 12, 14]

// On ajoute la note de Fred
notesDeLaClasse.append(13)

// On calcule la somme des notes
var somme = 0
for note in notesDeLaClasse {
    somme += note
}

// On calcule la moyenne
var moyenne = somme / notesDeLaClasse.count

La moyenne obtenue est  13 . Pas mal ! J'espère que vous avez eu 20 à l'exercice ;) !

Implémentation

Mettons tout ça en application avec la ferme de Joe.

Tout d'abord, nous allons modifier notre programme pour qu'à chaque jour de travail le résultat du travail de Joe ne soit pas converti en argent, mais ajouté à la grange. Je vous laisse essayer.

// A vous de jouer !
















































// La grange de Joe : [lait, blé, laine]
var barn = [0, 0, 0]

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

    if numberOfDay % 30 == 1 {
        // Joe moissonne
        barn[1] += 100
    } else if numberOfDay % 30 == 10 || numberOfDay % 30 == 20 {
        // Joe tond les moutons
        barn[2] += 30
    } else {
        // Joe trait les vaches
        barn[0] += 30
    }

    // On passe au jour suivant
    numberOfDay += 1
}

Maintenant il va falloir vendre quand la grange dépasse les 500 marchandises. Je vous laisse calculer la quantité de marchandises dans la grange chaque jour.

// Ne regardez pas !








































var barnSize = 0
for goods in barn {
    barnSize += goods
}

Maintenant nous allons appliquer le protocole, si la grange contient plus de 500 marchandises nous allons tout vendre.  

// Allez vous pouvez le faire !































// Le prix du voyage
let price = 1499.0

// L'argent de Joe
var money = 0.0

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

// La grange de Joe : [lait, blé, laine]
var barn = [0, 0, 0]

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

    // On calcule la taille de la grange
    var barnSize = 0
    for goods in barn {
        barnSize += goods
    }

    if barnSize >= 500 {
        // On vends !
        money += Double(barn[0]) * 0.50 // Le lait
        money += Double(barn[1]) * 0.30 // Le blé
        money += Double(barn[2]) * 1 // La laine
        
        // On vide la grange
        barn = [0, 0, 0]
    } else {
        // C'est une journée normale

        if numberOfDay % 30 == 1 {
            // Joe moissonne
            barn[1] += 100
        } else if numberOfDay % 30 == 10 || numberOfDay % 30 == 20 {
            // Joe tond les moutons
            barn[2] += 30
        } else {
            // Joe trait les vaches
            barn[0] += 30
        }
    }

    // On passe au jour suivant
    numberOfDay += 1
}

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

 La console affiche désormais :

Il aura fallu 135 jours à Joe pour économiser 1545.0 €

Si vous n'aviez pas réussi, aucun souci ! C'était l'un des travaux pratiques les plus difficiles ! N'hésitez pas à reprendre tranquillement le chapitre !

En Résumé

  • Swift propose trois types de collections :

    • Les tableaux

    • Les dictionnaires

    • Les ensembles

  • Les tableaux sont des listes ordonnées numériquement

  • Un tableau ne peut contenir que des valeurs d'un type unique et ne peut pas en changer. Le type se notant entre crochets :  [Int] . Il peut être déduit à partir des valeurs du tableau.

  • Pour déclarer un tableau vide, on utilise :

    •  [] si le type est connu

    •  [Int]() le type suivi de parenthèses sinon 

  • Pour accéder ou modifier le contenu d'un tableau, on utilise l'index entre crochets

    var fleurs = ["Rose", "Paquerette", "Marguerite"]
    fleurs[0] = "Iris"
  •  Pour ajouter ou supprimer des éléments, on utilise les fonctions :

    •  append pour ajouter un élément à la fin du tableau

    •  insert pour ajouter un élément à un index donné

    •  remove pour supprimer un élément à un index donné

  • La propriété  count permet d'obtenir la taille d'un tableau

  • On peut parcourir le contenu d'un tableau à l'aide d'une boucle for

  • Les variables évoluent selon un cycle de vie en 4 étapes :

    • Déclaration : La variable a un nom et un type et est constante ou non

    • Initialisation : La variable a une valeur

    • Modification : La valeur de la variable est modifiée

    • Suppression : La variable n'existe plus

  • On peut initialiser un type en utilisant le nom du type suivi de parenthèses :  Int() 

 

Example of certificate of achievement
Example of certificate of achievement