.count }.reduce(0, +) return Int(round(Double(size) / Double(count.toIntMax()))) } }

Nous pouvons maintenant calculer la taille moyenne de n'importe quelle collection de files d'attente (Array, Set, etc.). Sans les extensions de protocole, nous aurions dû ajouter cette méthode à chaque type de collection séparément.

Dans la bibliothèque standard Swift, les extensions de protocole sont utilisées pour implémenter, par exemple, des méthodes telles que map, filter, reduce, etc.

qu'est-ce qu'un bot discord
extension Collection { public func map(_ transform: (Self.Iterator.Element) throws -> T) rethrows -> [T] { } }

Extensions de protocole et polymorphisme

Comme je l'ai dit plus tôt, les extensions de protocole nous permettent d'ajouter des implémentations par défaut de certaines méthodes et d'ajouter de nouvelles implémentations de méthode. Mais quelle est la différence entre ces deux fonctionnalités? Revenons au gestionnaire d'erreurs et découvrons-le.

protocol ErrorHandler { func handle(error: Error) } extension ErrorHandler { func handle(error: Error) { print(error.localizedDescription) } } struct Handler: ErrorHandler { func handle(error: Error) { fatalError('Unexpected error occurred') } } enum ApplicationError: Error { case other } let handler: Handler = Handler() handler.handle(error: ApplicationError.other)

Le résultat est une erreur fatale.

Supprimez maintenant le handle(error: Error) déclaration de méthode du protocole.

protocol ErrorHandler { }

Le résultat est le même: une erreur fatale.

Cela signifie-t-il qu'il n'y a aucune différence entre l'ajout d'une implémentation par défaut de la méthode de protocole et l'ajout d'une nouvelle implémentation de méthode au protocole?

Non! Une différence existe et vous pouvez la voir en changeant le type de la variable handler de Handler à ErrorHandler.

let handler: ErrorHandler = Handler()

Maintenant, la sortie vers la console est: L’opération n’a pas pu être terminée. (Erreur ApplicationError 0.)

Mais si nous renvoyons la déclaration de la méthode handle (error: Error) au protocole, le résultat reviendra à l'erreur fatale.

protocol ErrorHandler { func handle(error: Error) }

Examinons l’ordre de ce qui se passe dans chaque cas.

Lorsque la déclaration de méthode existe dans le protocole:

Le protocole déclare le handle(error: Error) et fournit une implémentation par défaut. La méthode est remplacée dans le Handler la mise en oeuvre. Ainsi, l'implémentation correcte de la méthode est appelée lors de l'exécution, quel que soit le type de la variable.

Lorsque la déclaration de méthode n’existe pas dans le protocole:

Étant donné que la méthode n'est pas déclarée dans le protocole, le type ne peut pas la remplacer. C'est pourquoi l'implémentation d'une méthode appelée dépend du type de la variable.

Si la variable est de type Handler, l'implémentation de la méthode à partir du type est appelée. Dans le cas où la variable est de type ErrorHandler, l'implémentation de la méthode à partir de l'extension de protocole est appelée.

Code orienté protocole: sûr mais expressif

Dans cet article, nous avons démontré une partie de la puissance des extensions de protocole dans Swift.

Contrairement aux autres langages de programmation avec interfaces, Swift ne restreint pas les protocoles avec des limitations inutiles. Swift contourne les bizarreries communes de ces langages de programmation en permettant au développeur de résoudre l'ambiguïté si nécessaire.

Avec les protocoles Swift et les extensions de protocole, le code que vous écrivez peut être aussi expressif que la plupart des langages de programmation dynamiques et être toujours de type sécurisé au moment de la compilation. Cela vous permet d'assurer la réutilisabilité et la maintenabilité de votre code et d'apporter des modifications à la base de code de votre application Swift avec plus de confiance.

Nous espérons que cet article vous sera utile et accueillera vos commentaires ou autres informations.