Swift Academy · Leçon

Conversion forcée avec as! et ses risques

Utilisez as! uniquement lorsque la réussite de la conversion est garantie.

Leçon 3 sur 413 étapes

Conversion forcée avec as! et ses risques est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Conversion forcée

L’opérateur de conversion forcée as! effectue une conversion descendante et un déballage en une seule étape. Il fournit directement le type non optionnel, mais provoque un plantage si la conversion échoue.

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")
let dog = a as! Dog
print(dog.bark())

Aucun emballage optionnel

Contrairement à as?, le résultat de as! est du type simple et non une valeur optionnelle. Il n’y a rien à déballer.

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")
let dog: Dog = a as! Dog
print(type(of: dog))

Le risque de as!

Si l’instance n’est pas réellement du type cible, as! déclenche une interruption à l’exécution et arrête le programme. Il n’existe aucun moyen de récupérer cette erreur.

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")
// let cat = a as! Cat  // would crash at runtime
print("Only force-cast when certain")

Quand la conversion forcée est sûre

Utilisez as! uniquement lorsque vous êtes absolument certain du type, par exemple juste après l’avoir vérifié avec is.

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 a is Dog {
    let dog = a as! Dog
    print(dog.bark())
}

Conversion forcée après une garantie

Si la logique de votre code garantit le type, une conversion forcée documente cette certitude. Toutefois, privilégiez as? en cas de doute.

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" }
}
func barkIfDog(_ a: Animal) {
    guard a is Dog else { return }
    let dog = a as! Dog
    print(dog.bark())
}
barkIfDog(Dog(name: "Rex"))

Comparer les conversions conditionnelle et forcée

as? est sûr et renvoie une valeur optionnelle ; as! force la conversion et provoque un plantage en cas d’échec. Choisissez selon votre degré de certitude.

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")
let safe = a as? Dog
let forced = a as! Dog
print(safe?.bark() ?? "nil")
print(forced.bark())

Conversions forcées de collections

Les conversions forcées fonctionnent également sur des collections entières, comme array as! [Dog], mais le même risque de plantage s’applique à chaque élément.

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 animals: [Animal] = [Dog(name: "Rex"), Dog(name: "Buddy")]
let dogs = animals as! [Dog]
for d in dogs { print(d.bark()) }

Un schéma dangereux

Forcer la conversion d’un tableau qui contient un élément incorrect provoque un plantage. C’est pourquoi les collections mixtes doivent utiliser as? pour chaque élément.

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 animals: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
// let dogs = animals as! [Dog] // would crash on the Cat
for a in animals {
    if let d = a as? Dog { print(d.bark()) }
}

Déballage forcé et conversion forcée

Le ! de as! fonctionne conceptuellement comme le déballage forcé d’une valeur optionnelle : c’est pratique, mais dangereux si l’hypothèse est fausse.

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")
let viaOptional = (a as? Dog)!
let viaForce = a as! Dog
print(viaOptional.name, viaForce.name)

Bonne pratique

Privilégiez as? par défaut. Réservez as! aux situations où un échec indiquerait une erreur de programmation que vous souhaitez faire apparaître immédiatement pendant le développement.

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" }
}
func process(_ a: Animal) -> String {
    if let d = a as? Dog { return d.bark() }
    return "not a dog"
}
print(process(Dog(name: "Rex")))
print(process(Cat(name: "Mia")))

Exemple récapitulatif de conversion forcée

Lorsque le type a été vérifié, as! offre une syntaxe claire. En cas de doute, la conversion conditionnelle sûre est l’outil approprié.

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 known: Animal = Dog(name: "Rex")
if known is Dog {
    print((known as! Dog).bark())
}

Vérification rapide

Réfléchissez au danger des conversions forcées.

Réponds-y dans la leçon interactive

Récapitulatif : conversion forcée et risques associés

Vous avez appris que as! effectue une conversion descendante et un déballage vers un type non optionnel, mais provoque un plantage en cas d’échec, qu’il ne doit être utilisé que lorsque le type est certain, souvent après une vérification avec is, et que as? reste le choix le plus sûr par défaut.

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 a is Dog { print((a as! Dog).bark()) } else { print("safe skip") }

Gratuit pour commencer

Apprends Swift avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 122
Leçons: 409

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Conversion forcée avec as! et ses risques » est-elle gratuite ?

Oui — le texte complet de « Conversion forcée avec as! et ses risques » 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 « Conversion forcée avec as! et ses risques » ?

Utilisez as! uniquement lorsque la réussite de la conversion est garantie. 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 3 sur 4.

Combien de temps prend la leçon « Conversion forcée avec as! et ses risques » ?

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

← Retour à Swift Academy