Structures et classes
Les structures et les classes sont deux des principales briques de base de la programmation en Swift. Toutes deux permettent de regrouper des données et des fonctions liées au sein d'unités de fonctionnalité autonomes. Et lorsque tu définis une structure ou une classe, tu définis en fait un nouveau type à utiliser dans Swift, exactement comme les types que tu as déjà utilisés, tels que Int et String.
Il existe de nombreuses similitudes entre les structures et les classes en Swift. Entre autres points communs, les deux peuvent stocker des valeurs dans des propriétés et fournir des fonctionnalités grâce à des méthodes.
Chacune apporte des fonctionnalités supplémentaires, qui sortent du cadre de cet exercice.
Définis des structures et des classes
Les structures comme les classes se définissent à peu près de la même manière. On commence par le mot-clé approprié, suivi du nom du type que l'on définit, puis on place le corps de la structure ou de la classe entre accolades.
Le corps peut être constitué de propriétés stockées, qui se définissent et se comportent comme des constantes ou des variables ordinaires.
struct CharacterStats {
var health = 0.0
var speed = 0
var strength = 0
}
class GameCharacter {
var stats = CharacterStats()
var characterClass: String?
var name: String?
var active = false
let id = makeRandomID()
}
Instances
Comme indiqué plus haut, définir une structure ou une classe revient simplement à définir un nouveau type. Ce n'est que le plan qui décrit à quoi ressembleront les valeurs de ce type, mais cela ne crée réellement aucune valeur de ce type avec laquelle travailler.
Pour créer une instance de ce type, il faut écrire le nom du type suivi de parenthèses.
let someStats = CharacterStats()
let someCharacter = GameCharacter()
Cela crée des valeurs de ces types, dont les propriétés sont remplies avec les valeurs par défaut fournies dans la définition. Note que dans les cas optionnels, comme la propriété name de GameCharacter, si aucune valeur n'est fournie, la propriété vaudra nil par défaut, exactement comme lorsqu'on définit des types optionnels ordinaires sans fournir immédiatement de valeur.
Avec les structures, Swift fournit automatiquement ce qu'on appelle un initialiseur membre par membre : on peut y fournir, entre les parenthèses, des valeurs pour les propriétés de la structure, qui remplacent les valeurs par défaut de la définition.
let differentStats = CharacterStats(health: 100.0, speed: 6, strength: 18)
Accède aux propriétés
On peut accéder aux propriétés d'une structure ou d'une classe à l'aide de la notation pointée : on écrit le nom de la valeur, suivi d'un point (.) et du nom de la propriété. Si une propriété d'une structure ou d'une classe possède elle-même des propriétés, cette notation pointée permet aussi d'accéder à ces propriétés imbriquées.
Cette notation sert à la fois à lire la valeur de la propriété et, lorsque c'est autorisé, à la modifier.
someStats.health
// => 0
someCharacter.name
// => nil
someStats.health = 87.3
someStats.health
// => 87.3
someCharacter.name = "Luther"
someCharacter.name
// => "Luther"
someCharacter.id = "new id"
// Error: Cannot assign to property: 'id' is a 'let' constant
Méthodes
Comme les propriétés, qui stockent des données dans les structures et les classes, tu peux aussi définir des méthodes, qui stockent des fonctions dans une structure ou une classe.
Les méthodes se définissent de la même manière qu'une fonction ordinaire, mais à l'intérieur du corps de la structure ou de la classe. Note que si une fonction modifie la valeur d'une propriété d'une structure, elle doit être précédée du mot-clé mutating. De plus, si une propriété peut être modifiée par une méthode, elle doit être définie avec var plutôt que let, exactement comme des variables ordinaires.
struct CharacterStats {
var health = 0.0
var speed = 0
var strength = 0
mutating func takeHit(_ damage: Double) {
health = max(0.0, health - damage)
}
func canLift(_ weight: Int) -> Bool {
weight < strength * 100
}
}
class GameCharacter {
var stats = CharacterStats()
var characterClass: String?
var name: String?
var active = false
let id: String = makeRandomID()
func takesDamage(_ damage: Double) {
stats.takeHit(damage)
if stats.health <= 0 {
active = false
}
}
func sayName() -> String {
return "My name is \(name ?? "no one"), my class is \(characterClass ?? "undetermined")"
}
func lift(_ weight: Int) -> String {
if stats.canLift(weight) {
return "No problem!"
} else {
return "Ooof! No way."
}
}
}
Ces méthodes s'appellent avec la notation pointée, exactement comme les propriétés.
var myChar = GameCharacter()
myChar.stats = CharacterStats(health: 72.8, speed: 19, strength: 6)
myChar.active = true
myChar.lift(750)
// => "Ooof! No way."
myChar.takesDamage(80)
myChar.active
// => false
Self
Chaque instance d'une structure ou d'une classe possède une propriété implicite nommée self, qui fait référence à l'instance elle-même.
L'usage le plus courant de self est de lever l'ambiguïté entre une propriété d'instance et un paramètre qui porte le même nom :
struct Position {
var x = 0
mutating func move(x: Int) {
// Here, 'self.x' refers to the struct's property,
// while 'x' refers to the parameter passed to the method.
self.x = x
}
}
Les types Swift proposent aussi un mot-clé Self avec une majuscule, qui désigne le type de l'instance plutôt que l'instance elle-même.
Exercice d'apprentissage
