Tableaux, dictionnaires, structures et classes¶
Les tableaux Swift¶
Les tableaux en Swift ressemblent beaucoup aux tableaux en PHP.
Par contre, tous les éléments du tableau doivent avoir le même type.
Cette syntaxe permet d'initialiser un tableau plus facilement quand les éléments ont tous la même valeur au départ.
Il est possible de déclarer un tableau vide à condition de spécifier son type.
Cette autre syntaxe est équivalente. On dira qu'elle utilise l'inférence de type (c'est-à-dire que le type n'est pas spécifié). Elle appelle le constructeur du type Array avec le type String : String
Tableau d'instances d'une structure¶
Un tableau peut contenir n'importe quel type de données, incluant des instances d'une structure.
var items: [Item] = [
Item(id: 1, code: "abc", titre: "Une table"),
Item(id: 2, code: "def", titre: "Une chaise")
]
Il est également possible d'ajouter des éléments au tableau dans un deuxième temps.
Tableau à deux dimensions¶
Voici la syntaxe pour déclarer un tableau à deux dimensions. Ici, c'est un tableau de Int et il est vide au départ.
On aurait pu initialiser le tableau dès sa déclaration.
Pour donner la même valeur de départ à tous les éléments :
Pour modifier une valeur de ce tableau :
Tableau avec données variées¶
Si jamais vous avez besoin d'un tableau qui contient différents types de données, la solution consiste à déclarer un protocole, de créer différentes structures qui répondent à ce protocole et d'utiliser ce protocole comme type de données dans le tableau.
Pour plus d'information¶
« Array ». Apple. https://developer.apple.com/documentation/swift/array
« Collection Types ». Swift. https://docs.swift.org/swift-book/LanguageGuide/CollectionTypes.html
« Constants, Variables and Types ». Dimitri Racordon. https://kyouko-taiga.github.io/swift-thoughts/tutorial/chapter-1/
Boucler dans un tableau¶
Je vous présente ici quelques techniques pour boucler dans les éléments d'un tableau.
for¶
La boucle for permet de boucler facilement dans les éléments d'un tableau.
Cette syntaxe prend tout son sens si vous avez pris soin de donner un nom au pluriel au tableau, par exemple valeurs.
À l'intérieur de la boucle, l'élément qui est en cours de traitement portera ce nom mais au singulier, par exemple valeur.
La fonction zip() permet de créer une séquence de paires dont les valeurs sont tirées de deux tableaux.
Autrement dit, elle associe le premier élément du premier tableau avec le premier élément du second tableau et ainsi de suite.
let films: [String] = ["Harry Potter", "Seigneur des anneaux", "Star Wars"]
let acteurs: [String] = ["Daniel Radcliffe", "Viggo Mortensen", "Mark Hamill"]
for(film, acteur) in zip(films, acteurs) {
print("\(film): \(acteur)")
}
Voici un autre exemple qui permet de retrouver les indices d'un tableau.
let mots: [String] = ["Allô", "Bonjour", "Salut"]
for(i, mot) in zip(mots.indices, mots) {
print("\(i): \(mot)")
}
La méthode enumerated() permet elle aussi de travailler avec un tableau et ses indices.
let mots: [String] = ["Allô", "Bonjour", "Salut"]
for(i, mot) in mots.enumerated() {
print("\(i): \(mot)")
}
forEach()¶
Il est également possible d'utiliser la méthode forEach().
Voici quelques exemples supplémentaires avec forEach().
let mots: [String] = ["Allô", "Bonjour", "Salut"]
mots.indices.forEach { i in
print("\(i): \(mots[i])")
}
Ici, on travaille avec la méthode enumerated().
let mots: [String] = ["Allô", "Bonjour", "Salut"]
mots.enumerated().forEach { (i, mot) in
print("\(i): \(mot)")
}
Les dictionnaires¶
Un dictionnaire, parfois appelé tableau associatif, est un type de tableau dont les données sont regroupées en paires clé-valeur.
Toutes les clés doivent être du même type et toutes les valeurs doivent être du même type, qui peut être différent du type des clés.
Déclaration et initialisation¶
Pour déclarer un dictionnaire vide :
ou
On peut également le remplir dès sa déclaration :
Pour ajouter une valeur, il suffit d'utiliser une clé qui n'existe pas encore.
Accéder à un élément¶
Plutôt que de retrouver une information à l'aide d'un indice numérique, on retrouvera la valeur d'un tableau associatif à partir de sa clé.
Boucler dans le dictionnaire¶
Pour boucler dans les éléments du dictionnaire, la boucle for est toute indiquée.
On peut également utiliser la propriété keys(). Ceci retourne une collection. On convertira le résultat en tableau à l'aide de Array().
let cles = Array(monDictionnaire.keys)
var valeur: Int
for cle in cles {
valeur = monDictionnaire[cle]!
print(cle)
print(valeur)
}
Remarquez le point d'exclamation dans l'instruction qui retrouve la valeur. Dans ce contexte, on l'appelle implicitly unwrapped optional.
Si on ne le met pas, on obtiendra cet avertissement : « Expression implicitly coerced from 'Int?' to 'Any' ».
C'est que le compilateur nous informe que monDictionnaire[cle] pourrait être nul. Il demande ce qu'il doit faire si ça arrive afin de ne pas faire planter le programme.
Avec le point d'exclamation – qu'il faut utiliser seulement dans des situations très spécifiques – on informe le compilateur que c'est certain que la valeur ne peut pas être nulle.
Tri¶
Dans les deux boucles précédentes, les valeurs affichées à l'écran pourraient être affichées dans un ordre différent à chaque fois que le programme est exécuté.
Si on a besoin d'un ordre spécifque, il faut le spécifier.
ou encore :
Quelques méthodes utiles¶
- allSatisfy()
- contains()
- count()
- filter()
- firstIndex()
- forEach()
- index()
- isEmpty()
- keys()
- max()
- min()
- randomElement()
- remove()
- removeValue()
- values()
Pour plus d'information¶
« Dictionary ». Apple. https://developer.apple.com/documentation/swift/dictionary
« Collection Types - Dictionnaries ». Swift. https://docs.swift.org/swift-book/LanguageGuide/CollectionTypes.html#ID113
« Expression implicitly coerced from ‘String?’ to ‘Any’- WHY SWIFT, WHY :( ». Steven Curtis. https://stevenpcurtis.medium.com/expression-implicitly-coerced-from-string-to-any-why-swift-why-190dd0a58c58
« Dictionaries in SwiftDictionaries in Swift ». Andy Bargh. https://andybargh.com/dictionaries-in-swift/
Recherche dans un tableau ou dans un dictionnaire¶
Tableau simple¶
La méthode firstIndex(of:) permet de retrouver la position d'un élément dans un tableau.
let monTableau = ["Premier élément", "Deuxième élément", "Troisième élément"]
...
let position = monTableau.firstIndex(of: "Deuxième élément") // 1
Tableau de structures¶
La méthode firstIndex(where:) permet d'effectuer une recherche plus diversifiée. Elle prend en paramètre une fonction anonyme qui permet de rechercher autre chose qu'une égalité.
Entre autres, elle permet de trouver la position d'un élément dans un tableau de structures.
struct Ami {
var nomFamille: String
var prenom: String
}
...
let amis: [Ami] = [
Ami(nomFamille: "Lacasse", prenom: "Toto"),
Ami(nomFamille: "Gagnon", prenom: "Annie"),
Ami(nomFamille: "Girard", prenom: "Andréanne")
]
...
if let position = amis.firstIndex(where: {
$0.prenom == "Annie"
}) {
nomFamille = amis[position].nomFamille
}
else {
nomFamille = "personne"
}
Dictionnaire¶
Pour rechercher la valeur qui correspond à une clé, il suffit d'accéder directement à cette valeur à partir de la clé.
Si la clé n'existe pas, on aura nil.
C'est pourquoi il faut prévoir ce qui se passera si jamais la clé n'existe pas. Ici, j'ai choisi d'imprimer le mot « aucun ».
let monDictionnaire:[String:String] = ["Nom":"Annie Gagnon", "Spécialité":"SwiftUI", "Ville":"Victoriaville"]
print(monDictionnaire["Nom"] ?? "aucun") // Annie Gagnon
print(monDictionnaire["Téléphone"] ?? "aucun") // aucun
Il aurait aussi été possible de gérer le cas où la clé n'existe pas comme suit :
let monDictionnaire:[String:String] = ["Nom":"Annie Gagnon", "Spécialité":"SwiftUI", "Ville":"Victoriaville"]
if let valeur = monDictionnaire["Nom"] {
print(valeur)
}
else {
print("aucun")
}
Pour rechercher la clé qui correspond à une valeur dans un dictionnaire, il faut faire appel aux méthodes key() et value().
let monDictionnaire:[String:Int] = ["ABC":10, "DEF":3, "GHI":8]
if let cle = monDictionnaire.first(where: { $0.value == 3 })?.key {
print(cle) // "DEF"
}
Pour plus d'information¶
« How To Find an Item in an Array in Swift ». LearnAppMaking.com. https://learnappmaking.com/find-item-in-array-swift/
Structure vs classe¶
Swift propose des structures et des classes pour représenter des données et des comportements.
La différence entre les deux n'est pas si évidente à prime abord.
Voici d'abord quelques ressemblances :
- Les deux permettent de définir des propriétés et des méthodes.
- Il est possible de créer des instances de structures et des instances de classes (dans le cas des classes, les instances sont aussi appelées objets).
Et quelques différences :
- Les classes offrent des fonctionnalités supplémentaires, par exemple l'héritage.
- Les structures, quant à elles, offrent l'avantage d'être moins complexes à mettre en oeuvre.
- Les structures ont un constructeur par défaut mais les classes n'en ont pas.
- Lorsqu'une fonction reçoit en paramètre une instance d'une classe, le paramètre est passé par référence. Quand le paramètre est une instance d'une structure, il est passé par valeur.
Pour vous aider à choisir entre créer une structure ou créer une classe, rappelez-vous qu'il faut d'abord privilégier les structures et choisir les classes seulement losrque requis1:,
As a general guideline, prefer structures because they’re easier to reason about, and use classes when they’re appropriate or necessary.
Source¶
- « Structures and Classes ». Swift. https://docs.swift.org/swift-book/LanguageGuide/ClassesAndStructures.html
Les structures¶
Les structures Swift permettent de représenter des données complexes ainsi que des comportements.
Dans SwiftUI, une structure sera généralement placée dans son propre fichier. Le nom de la structure sera identique au nom du fichier.
Puisque les structures représentent les données de l'application (le modèle), leurs fichiers seront placés dans un dossier nommé Models.
Le nom de la structure sera un mot au singulier.
Définir une structure¶
Dans la structure, les propriétés sont définies avec le mot-clé var et les méthodes, avec le mot-clé func.
import Foundation
struct Ami {
var nomFamille: String
var prenom: String
func inviter() {
...
}
}
Instancier une structure¶
Pour créer une instance de la structure, on procédera comme suit :
Dans cet exemple, il ne sera pas possible de modifier les propriétés de l'instance puisqu'elle a été créée avec le mot-clé let.
Constructeur¶
Chaque structure contient un constructeur par défaut, qu'on appelle en anglais memberwise initializer. Il n'y a rien à coder pour que ce constructeur existe. Il est là de base.
Le memberwise initializer permet d'instancier la structure en précisant une valeur pour chacune des propriétés, comme dans l'exemple précédent.
Il est possible de définir un constructeur nommé init() qui répondra à nos besoins de façon plus précise, par exemple en donnant une valeur par défaut à certaines propriétés ou en effectuant un traitement particulier.
Attention : sans précaution, ceci écrasera le memberwise initializer. C'est pourquoi il est préférable de créer une extension de la structure dans laquelle le ou les constructeurs seront définis.
De cette façon, l'instance pourra être créée à l'aide du memberwise initializer ou d'un des constructeurs définis dans l'extension.
Dans un projet SwiftUI, les extensions peuvent être placées à différents endroits selon la structure de fichiers dont vous vous êtes dotés. Dans le cas d'une extension à une structure que vous avez créée, il est intéressant de la placer dans le même fichier que la structure.
extension Ami {
init(prenom: String) {
self.prenom = prenom
self.nomFamille = ""
}
}
Désormais, pour instancier un Ami, il est possible de fournir seulement le prénom.
Le nom de famille pourra être ajusté au besoin par une instruction séparée.
Tout constructeur doit s'assurer que chacune des propriétés a une valeur valide lorsque l'instanciation est terminée.
Les propriétés calculées¶
Dans une classe ou dans une structure, il est possible de définir des propriétés calculées, c'est-à-dire des propriétés dont la valeur est calculée à partir d'autres valeurs.
class Eleve {
var prenom: String
var nomFamille: String
// propriété calculée
var nomComplet: String {
self.prenom + " " + self.nomFamille
}
}
La propriété calculée peut obtenir une valeur différente selon une condition. À ce moment, il faut utiliser le mot-clé return pour définir sa valeur.
class Eleve {
var prenom: String
var nomFamille: String
var gentile: String?
// propriété calculée
var nomEtGentile: String {
if self.gentile != nil {
return self.prenom + " " + self.nomFamille + " de " + self.gentile
}
else {
return self.prenom + " " + self.nomFamille
}
}
}
Voici un autre exemple de propriétés calculées, cette fois dans une vue.
struct AjouterItem: View {
@State private var nom: String = ""
...
// propriété calculée
var messageNom: String {
var message = ""
if nom.count == 0 {
message = "Le nom est requis."
}
else if nom.count > 100 {
message = "Le nom doit comporter au maximum 100 caractères."
}
return message
}
// propriété calculée
var formulaireValide: Bool {
messageNom == "" && messageDescription == ""
}
...
}
Pour plus d'information¶
« Properties ». Swift. https://docs.swift.org/swift-book/documentation/the-swift-programming-language/properties/
« What is a Computed Property in Swift? ». Swift Lee. https://www.avanderlee.com/swift/computed-property/
« What are computed properties in Swift and when should you use them? ». Donny Wals. https://www.donnywals.com/what-are-computed-properties-in-swift-and-when-should-you-use-them/
« Deciding between a computed property and a function in Swift ». Donny Wals. https://www.donnywals.com/deciding-between-a-computed-property-and-a-function-in-swift/