Comment implémenter le corps d'une fonction déclarée dans un protocole?

En Swift, un protocole peut déclarer des signatures de méthodes, ainsi que fournir une implémentation par défaut pour ces méthodes via des extensions (extensions de protocole).

Implémentation dans une extension de protocole

La façon la plus courante de fournir le corps d'une fonction pour une méthode déclarée dans un protocole :

protocol MyProtocol {
    func processData() // Déclaration de la méthode
}

extension MyProtocol {
    // Implémentation par défaut
    func processData() {
        print("Traitement des données par défaut...")
    }
}

// Classe conforme au protocole utilisant l'implémentation par défaut
class MyClass: MyProtocol {
    // Pas besoin d'implémenter processData si la version par défaut suffit
}

// Classe qui redéfinit l'implémentation
class AnotherClass: MyProtocol {
    func processData() {
        print("Traitement des données d'une autre manière...")
    }
}

let instance1 = MyClass()
instance1.processData() // Affiche : Traitement des données par défaut...

let instance2 = AnotherClass()
instance2.processData() // Affiche : Traitement des données d'une autre manière...

Implémentation dans le type correspondant

Le type (classe, structure ou énumération) qui conforme au protocole doit fournir sa propre implémentation pour chaque méthode déclarée dans le protocole, si le protocole ne fournit pas d'implémentation par défaut ou si une logique différente est requise.

protocol AnotherProtocol {
    func performAction(with value: Int) // Méthode sans implémentation par défaut
}

// Structure conforme au protocole avec sa propre implémentation
struct MyStruct: AnotherProtocol {
    func performAction(with value: Int) {
        print("Effectuer une action avec la valeur : \(value)")
    }
}

let instance3 = MyStruct()
instance3.performAction(with: 42) // Affiche : Effectuer une action avec la valeur : 42

Conclusions

• Extension de protocole : Fournit une implémentation par défaut que les types conformes au protocole peuvent utiliser. Les types peuvent redéfinir cette implémentation.
• Type correspondant : Doit implémenter les méthodes du protocole s'il n'y a pas d'implémentation par défaut ou si une logique personnalisée est requise.

Le choix de la méthode d'implémentation dépend de si la logique de la méthode est spécifique à chaque type conforme au protocole ou si elle peut être commune à tous les types (avec possibilité de redéfinition).