Opérateurs de Type

Opérateur is

L'opérateur is permet de vérifier si une instance est d'un certain type. Il retourne un booléen indiquant si l'instance correspond au type spécifié.

Syntaxe :

instance is Type

Exemple :

let myNumber: Int = 42
if myNumber is Int {
    print("myNumber est un Int.")
} else {
    print("myNumber n'est pas un Int.")
}

• myNumber is Int : Vérifie si myNumber est un Int. Le résultat est true et le message "myNumber est un Int." est affiché.

Opérateur as simple : Conversion vers un supertype

L'opérateur as est utilisé pour convertir une valeur vers un type plus général ou supertype. Cela est utile lorsque vous travaillez avec des types qui partagent une hiérarchie, comme des sous-classes et des superclasses, ou des types conformant à un protocole.

Exemple de conversion vers un protocole ou un supertype :

class Animal {}
class Dog: Animal {}
let myDog = Dog()
let myAnimal: Animal = myDog as Animal  // Conversion d'un `Dog` en `Animal`

Dans cet exemple, myDog est de type Dog, mais nous pouvons le convertir en son supertype Animal avec as.

Opérateur as? : Casting optionnel (conversion sûre)

L'opérateur as? est utilisé lorsque vous souhaitez effectuer un casting qui pourrait échouer. Au lieu de lever une erreur en cas d'échec, il retourne une valeur optionnelle (nil si la conversion échoue).

Exemple de as? :

class Animal {}
class Dog: Animal {}
class Cat: Animal {}
let animals: [Animal] = [Dog(), Cat()]
for animal in animals {
    if let dog = animal as? Dog {
        print("C'est un chien !")
    } else {
        print("Ce n'est pas un chien.")
    }
}

Dans cet exemple, nous essayons de convertir chaque élément de la liste animals en type Dog. Si la conversion échoue, le résultat est nil, et le bloc else est exécuté.

Opérateur as! : Casting forcé (conversion non sécurisée)

L'opérateur as! est utilisé lorsque vous êtes certain que la conversion va réussir. Cependant, si la conversion échoue, cela entraîne une erreur d'exécution (crash de l'application).

Exemple de as! :

let myAnimal: Animal = Dog()
let myDog = myAnimal as! Dog  // Conversion forcée, succès car `myAnimal` est bien un `Dog`

Ce code fonctionne car myAnimal contient bien un Dog. Toutefois, si vous essayez de forcer un cast avec un type incompatible, une erreur se produira :

let myAnimal: Animal = Cat()
let myDog = myAnimal as! Dog  // Erreur d'exécution : `Cat` ne peut pas être converti en `Dog`

Conversion vers un type concret avec as

Vous pouvez également utiliser as pour convertir des types compatibles, comme des types primitifs. Par exemple, vous pouvez convertir un type Int en Double ou vice versa si la conversion est directe :

Exemple de conversion simple :

let number: Int = 10
let doubleValue = Double(number)  // Conversion d'un `Int` en `Double`

Toutefois, certaines conversions primitives (comme Int vers Double) ne peuvent pas se faire avec as. Vous devrez utiliser des initialiseurs spécifiques comme Double(number) dans ce cas.

Résumé des opérateurs de conversion avec as

• as : Conversion vers un supertype ou un protocole. Utilisé pour les conversions sûres où il n'y a pas d'ambiguïté de type.
• as? : Conversion optionnelle. Utilisé lorsque le type de destination peut ne pas correspondre, retourne un résultat optionnel (nil en cas d'échec).
• as! : Conversion forcée. Utilisé lorsque vous êtes sûr que la conversion ne peut pas échouer. Provoque une erreur d'exécution si le type ne correspond pas.

Exemple complet avec différents types de castings

class Animal {}
class Dog: Animal {}
class Cat: Animal {}
let myAnimal: Animal = Dog()
// Casting optionnel avec as?
if let dog = myAnimal as? Dog {
    print("C'est un chien")
} else {
    print("Ce n'est pas un chien")
}
// Casting forcé avec as!
let forcedDog = myAnimal as! Dog  // Pas d'erreur, car myAnimal est bien un Dog
print("Chien forcé trouvé")
// Vérification du type avec is
if myAnimal is Cat {
    print("C'est un chat")
} else {
    print("Ce n'est pas un chat")
}

Points Clés à Retenir

• L'opérateur is vérifie le type d'une instance et retourne un booléen.
• L'opérateur as effectue des conversions de type. Utilisez as pour des conversions implicites sûres, as? pour des conversions conditionnelles qui peuvent échouer, et as! pour des conversions forcées.