Bases de la conversion ascendante et descendante
Passez d’un type de superclasse à un type de sous-classe, et inversement.
Bases de la conversion ascendante et descendante est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.
Vue d’ensemble du transtypage
Le transtypage permet de traiter une instance comme une instance d’un autre type dans sa hiérarchie de classes. Il vérifie ou modifie le type statique, mais ne convertit pas les données.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let d = Dog(name: "Rex")
print(d.bark())Une hiérarchie de classes
Le transtypage nécessite une hiérarchie. Ici, Dog et Cat héritent tous deux de Animal. Un Dog est un Animal.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let pet: Animal = Dog(name: "Rex")
print(pet.name)Conversion ascendante avec l’opérateur de conversion
La conversion ascendante traite une instance de sous-classe comme une instance de sa superclasse. Elle réussit toujours : utilisez donc l’opérateur as simple.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let dog = Dog(name: "Rex")
let asAnimal = dog as Animal
print(asAnimal.name)Pourquoi effectuer une conversion ascendante
La conversion ascendante est utile pour stocker différentes sous-classes ensemble, par exemple dans un tableau dont le type est celui de la superclasse commune.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for a in zoo { print(a.name) }La conversion ascendante est toujours sûre
Puisque toute instance de sous-classe est également une instance valide de sa superclasse, le compilateur accepte as pour les conversions ascendantes sans risque d’échec.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let cat = Cat(name: "Mia")
let animal = cat as Animal
print("Treated as Animal:", animal.name)Accès perdu après une conversion ascendante
Une fois l’instance stockée avec le type de la superclasse, vous ne pouvez appeler que les membres de cette superclasse. La méthode bark() propre à Dog reste masquée jusqu’à une conversion descendante.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
print(a.name)
// a.bark() would not compile hereIntroduction à la conversion descendante
La conversion descendante fonctionne dans l’autre sens : elle traite une référence de superclasse comme une sous-classe précise afin de récupérer ses membres. Elle peut échouer et nécessite donc as? ou as!.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
if let dog = a as? Dog {
print(dog.bark())
}Pourquoi une conversion descendante peut échouer
Le compilateur ne peut pas garantir qu’un Animal donné est réellement un Dog. Il peut s’agir d’un Cat. Cette incertitude impose de vérifier les conversions descendantes.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Cat(name: "Mia")
let maybeDog = a as? Dog
print("Is it a Dog?", maybeDog != nil)Conversion descendante dans une boucle
Un schéma courant consiste à parcourir un tableau de superclasses et à convertir chaque élément vers une sous-classe afin de les traiter différemment.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for a in zoo {
if let dog = a as? Dog { print(dog.bark()) }
if let cat = a as? Cat { print(cat.meow()) }
}Résumé des conversions ascendante et descendante
La conversion ascendante avec as se dirige vers le type de base et réussit toujours. La conversion descendante avec as? ou as! se dirige vers un type précis et peut échouer.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let d = Dog(name: "Rex")
let up = d as Animal
let down = up as? Dog
print(up.name, down?.bark() ?? "no")Le transtypage reste limité à une hiérarchie
Vous ne pouvez effectuer un transtypage qu’entre des types liés dans une même hiérarchie. Des types indépendants ne peuvent pas être convertis l’un vers l’autre.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
print(a is Animal)
print(a is Dog)Vérification rapide
Rappelez-vous quelle direction de conversion réussit toujours.
Récapitulatif : conversions ascendante et descendante
Vous avez appris que le transtypage fonctionne au sein d’une hiérarchie de classes, que la conversion ascendante avec as vers le type de base réussit toujours, et que la conversion descendante vers une sous-classe précise peut échouer et nécessite donc les opérateurs vérifiés présentés ensuite.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let pets: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for p in pets {
if let d = p as? Dog { print(d.bark()) } else { print(p.name) }
}Questions Fréquemment Posées
La leçon « Bases de la conversion ascendante et descendante » est-elle gratuite ?
Oui — le texte complet de « Bases de la conversion ascendante et descendante » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Bases de la conversion ascendante et descendante » ?
Passez d’un type de superclasse à un type de sous-classe, et inversement. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Swift Academy ?
Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Bases de la conversion ascendante et descendante » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?
Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Bases de la conversion ascendante et descendante
- Conversion conditionnelle avec as?
- Conversion forcée avec as! et ses risques
- Vérification des types avec is