Tableau ou array en Swift

Tableau ou array

Les tableaux en Swift sont comme des boîtes qui vous aident à organiser et à manipuler vos données. Vous pouvez les remplir, ajouter ou retirer des choses, et même parcourir tous les éléments. C'est un outil puissant pour travailler avec des listes d'informations dans vos programmes.

Les tableaux sont des listes ordonnées numériquement composés d'éléments du même type. Cela signifie qu'un tableau qui contient des chaînes de caractères de type String ne peut pas ensuite contenir des entiers de type Int.

Déclarer un tableau

Il est très simple de déclarer un tableau grâce à l'inférence de type implicite qui permet au compilateur Swift de déduire automatiquement le type de données en fonction de la valeur attribuée à la variable. Il suffit juste de mettre les valeurs entre crochets et de les séparer par une virgule :

var fruits = ["Pomme", "Banane", "Orange"]

Déclarer le type d'un tableau

L'annotation de type spécifie le type de données que votre tableau contiendra :

// Annotation de type explicite
var fruits: [String] = ["Pomme", "Banane", "Orange"]

Dans cet exemple, fruits est un tableau de type String. Cela signifie qu'il ne peut contenir que des chaînes de caractères de type String.

Déclarer un tableau vide

Il est possible de déclarer un tableau vide en utilisant soit l'interference de type soit l'annotation de type :

// Déclaration d'un tableau vide avec annotation de type explicite
// qui contiendra des chaînes de caractères 
var tableauVide: [String] = []

// Déclaration d'un tableau vide avec inférence de type implicite
// qui contiendra des entiers
var autreTableauVide = [Int]()

Ces deux déclarations créent un tableau vide prêt à être rempli ultérieurement avec des éléments. Notez qu'on doit toujours connaître le type stocké par le tableau.

Un tableau stocke des valeurs du même type dans une liste ordonnée mais une même valeur peut apparaître dans un tableau plusieurs fois à différentes positions.

Itération d'un tableau

Itérer un tableau, c'est passer en revue chaque élément d'une liste. Pour faire simple, c'est comme vérifier chaque objet dans une boîte et décider quoi en faire. Prenons un exemple concret pour mieux comprendre. On utilise la boucle for pour l'itération :

let fruits = ["Pomme", "Banane", "Orange"]

for fruit in fruits {
    print(fruit)
}

// Cela affichera :
// Pomme
// Banane
// Orange

Dans l'exemple ci-dessus, on indique à Swift de regarder chaque élément un par un. La boucle effectuera donc 3 tours, la constante fruits (au pluriel) contient 3 valeurs. On assignera temporairement, à chaque tour de boucle, chacune de ces valeurs à la variable fruit (au singulier). Cette variable fruit (au singulier) est crée lors de la déclaration de la boucle for et est accessible uniquement dans cette boucle, entre les accolades. Enfin, on affichera cette variable à chaque tour de boucle.

Si vous avez des difficultés à comprendre cette boucle, je vous conseille de faire un petit tour en arrière, au chapitre précédent sur la boucle for pour rafraichir vos souvenirs.

Manipulation d'un tableau

Maintenant que nous savons comment déclarer un tableau, lui assigner des valeurs et le parcourir, découvrons comment le manipuler et interagir avec à travers différents exemples.

Concaténation de tableaux du même type

Pour concaténer plusieurs tableaux, ou les assembler, il faut impérativement que ces tableaux soient du même type. Un tableau ne pouvant contenir que des éléments du même type, assembler un tableau de type String avec un tableau de type Int provoquerait un crash de votre code.

let viande = ["boeuf", "veau", "poulet", "porc"]
let poisson = ["loup", "dorade", "maquereau", "sardine"]

let nourriture = viande + poisson

Le tableau nourriture contient 8 éléments : boeuf, veau, poulet, porc, loup, dorade, maquereau, sardine.

Compter le nombre d'éléments d'un tableau

On utilise la méthode count pour connaitre le nombre d'éléments que possède un tableau :

let viande = ["boeuf", "veau", "poulet", "porc"]

let compteur = viande.count

print("Le tableau contient \(compteur) éléments")
// Le tableau contient 4 éléments

Pour vérifier si un tableau est vide, il préférable d'utiliser la méthode isEmpty plutôt que de passer par la méthode count et vérifier que celle-ci est égale à 0 :

let  tableauVide: [String] = []

if tableauVide.isEmpty {
    print("Le tableau est vide")
}
// Affichera : Le tableau est vide

Ajouter un élément à un tableau

Pour ajouter un élément à un tableau existant, on utilise la méthode append. Elle ajoutera un élément à la fin du tableau

var sport = ["golf", "tennis", "football"]

sport.append("natation")

// Le tableau sport contient désormais 4 éléments

Il est également possible d'ajouter un ou plusieurs éléments grâce à l'opérateur d'affectation combiné :

var sport = ["golf", "tennis", "football"]

sport += ["natation"]

// Le tableau sport contient desormais 4 éléments

sport += ["gym", "judo"]

// Et maintenant, Le tableau sport contient 6 éléments

Insérer un élément en première position

Pour insérer un élément en première position, on utilise la méthode insert(_:at:). Il suffit d'indiquer l'élément à ajouter puis d'indiquer sa position après le paramètre at:.

var sport = ["golf", "tennis", "football"]

// On insére un élément en première position
sport.insert("Basket", at: 0)

// Le tableau sport a désormais 4 éléments
// sport a pour valeur : ["Basket", "golf", "tennis", "football"]

Pour vous prouver que l'index du premier élément d'un tableau est bien 0, vous allez le constater grâce à la méthode enumerated(). Cette méthode, qui ne prend aucun paramètre vous permet d'utiliser un tuple lors de l'itération du tableau. Ce tuple contiendra un entier, soit l'index, et une valeur.

var sport = ["golf", "tennis", "football"]

for (indice, valeur) in sport.enumerated() {
    print("Item N°\(indice) : \(valeur)")
}

// Cela affichera :
// Item N°0 : golf
// Item N°1 : tennis
// Item N°2 : football

Beaucoup de nouvelles méthodes vous sont présentées dans ce chapitre. Ne vous inquiétez pas si vous ne les retenez pas toutes par coeur. Sachez simplement qu'elles existent et que certaines actions sont possibles. Nous reviendrons plus en détails sur ce qu'est une méthode dans quelques chapitres...

Supprimer un élément d'un tableau

Pour supprimer un élément d'un tableau, on utilise la méthode remove(at:). Elle ne contient qu'un seul paramètre nommé at:. Il s'agit ici de lui indiquer l'emplacement de l'élément à supprimer. Pensez à bien vous rappeler que le premier élément a pour indice 0.

var sport = ["golf", "tennis", "football"]

// On supprime l'élément en seconde position
sport.remove(at: 1)

// Le tableau sport a désormais 2 éléments
// sport a pour valeur : ["golf", "football"]

Pour supprimer le dernier élément uniquement, on utilise la méthode removeLast() qui ne contient aucun paramètre. On l'applique à notre tableau et cela supprimera automatiquement le dernier élément.

var sport = ["golf", "tennis", "football"]

// On supprime l'élément en dernière position
sport.removeLast()

// Le tableau sport a désormais 2 éléments
// sport a pour valeur : ["golf", "tennis"]

Récupérer et modifier la valeur d'un élément

Pour récupérer et utiliser la valeur d'un élément d'un tableau, on utilise la syntaxe des indices. On indique la valeur de l'indice entre crochets juste après le nom du tableau. Cette fameuse syntaxe où le premier élément commence par 0. Je préfère vous le répéter pour que cela rentre dans votre tête.

var sport = ["golf", "tennis", "football"]

print(sport[2])
// Cela affichera : football

Pour modifier la valeur d'un élément, on utilise également la syntaxe des indices. La nouvelle valeur écrasera l'ancienne. Cette nouvelle valeur sera impérativement du même type. Un tableau contenant des String, ne peut contenir que des String .

var sport = ["golf", "tennis", "football"]

// On remplace la 3eme valeur par : rugby
sport[2] = "rugby"

print(sport[2])
// Cela affichera : rugby

Lorsque plusieurs éléments doivent être modifiés en même temps, il est plus pratique d'utiliser les opérateurs de plage. Ces opérateurs serviront à indiquer à Swift l'indice de l'élément à modifier.

var sport = ["golf", "tennis", "football", "rugby"]

// On remplace la 2eme et la 3eme valeur par : volley et ping-pong
sport[2...3] = ["volley", "ping-pong"]

print(sport)
// Cela affichera : golf, tennis, volley, ping-pong

Remarquez la présence de crochets dans la valeur à remplacer. Il s'agit d'un nouveau tableau qui s'intègrera à l'intérieur du tableau original en remplaçant les valeurs appartenant aux indices définis.

Remplir un tableau automatiquement

Une dernière petite chose que vous devez savoir. Je sais que ce chapitre est assez long et que beaucoup de nouvelles informations vous sont arrivées mais restez concentré encore quelques instants. En Swift, le type Array fournit également un initialiseur pour créer un tableau d'une certaine taille avec toutes ses valeurs définies sur la même valeur par défaut.

Le terme initialiseur est nouveau pour vous. Nous n'allons pas entrer dans les détails sur ce principe tout de suite mais sachez simplement que cela se comporte un peu comme une instruction lors de l'initialisation d'une variable. En d'autres termes, au moment où le tableau est déclaré et qu'on lui assigne une valeur.

Cela vous gagnera un temps fou sur la déclaration de certains tableaux. Par exemple, imaginons que vous avez codé un jeu et que chaque nouveau joueur se voit attribuer 3 valeurs contenues dans un tableau : le nombre de points d'expérience, le niveau actuel et le nombre de victoires. Rien de plus simple :

var joueur = Array(repeating: 0, count: 3)

// joueur = [0, 0, 0]

// Le tableau est crée aussitot
// avec trois éléments identiques
// ayant chacun pour valeur 0

Ce chapitre est désormais terminé. Ce fût un chapitre assez long composé de nombreuses informations nouvelles. Il n'est pas nécessaire de mémoriser l'ensemble des méthodes que nous avons parcourues ici. Comprenez surtout les principes. Lorsque vous développerez, vous vous documenterez constamment sur les syntaxes, le nom des méthodes ... mais vous comprendrez leur fonctionnement. Et c'est bien cela le plus important, car en comprenant vous saurez comment toutes les utiliser.

// Tableau N°1
let chambre = ["Lit", "Table", "Armoire", "Lampe"]

// Tableau N°2
let salon = ["Table", "Fauteuil", "Télévision", "Canapé", "Table"]

// Tableau N°1
let chambre = ["Lit", "Table", "Armoire", "Lampe"]

// Tableau N°2
let salon = ["Table", "Fauteuil", "Télévision", "Canapé", "Table"]

// On les assemble
let assemblage = chambre + salon

// On initialise le compteur
var compteur = 0


// On itère le nouveau tableau
for item in assemblage {
    
    // Si l'élément est "Table", on incrémente le compteur
    if item == "Table" {
        compteur += 1
    }
    
}

// On affiche la sortie
print("Le mot Table apparait \(compteur) fois")