Implémentations par défaut dans les extensions
Fournissez un comportement commun via des extensions de protocoles.
Implémentations par défaut dans les extensions est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.
Le problème
Les protocoles déclarent des exigences, mais ne fournissent aucun comportement. Si chaque type conforme devait répéter la même logique, vous dupliqueriez le code. Les extensions de protocoles résolvent ce problème en fournissant des implémentations par défaut.
protocol Greeter {
func greet() -> String
}Ajouter une valeur par défaut
Une extension du protocole peut implémenter une exigence. Les types conformes obtiennent ce comportement gratuitement, sauf s'ils le remplacent.
protocol Greeter { func greet() -> String }
extension Greeter {
func greet() -> String { "Hello!" }
}
struct Robot: Greeter {}
print(Robot().greet())Remplacer la valeur par défaut
Un type conforme peut fournir sa propre implémentation, qui est prioritaire sur celle par défaut de l'extension.
protocol Greeter { func greet() -> String }
extension Greeter { func greet() -> String { "Hello!" } }
struct French: Greeter {
func greet() -> String { "Bonjour!" }
}
print(French().greet())Ajouter des méthodes supplémentaires
Les extensions peuvent ajouter des méthodes entièrement nouvelles qui ne figurent pas du tout dans le protocole. Chaque type conforme les obtient automatiquement.
protocol Named { var name: String { get } }
extension Named {
func loudName() -> String { name.uppercased() }
}
struct City: Named { let name: String }
print(City(name: "paris").loudName())Propriétés calculées par défaut
Les extensions peuvent également fournir des propriétés calculées par défaut.
protocol Sized {
var width: Double { get }
var height: Double { get }
}
extension Sized {
var area: Double { width * height }
}
struct Rect: Sized { let width: Double; let height: Double }
print(Rect(width: 2, height: 5).area)S'appuyer sur les exigences
Une implémentation par défaut peut appeler les propres exigences du protocole et composer un comportement plus riche à partir du contrat minimal que chaque type doit fournir.
protocol Summable {
var values: [Int] { get }
}
extension Summable {
var total: Int { values.reduce(0, +) }
}
struct Cart: Summable { let values: [Int] }
print(Cart(values: [10, 20, 30]).total)Extensions contraintes
Utilisez une clause where pour qu'une valeur par défaut ne s'applique que lorsque des conditions supplémentaires sont remplies. Ici, la valeur par défaut n'existe que lorsque Self est également Equatable.
protocol Container {
associatedtype Item
var items: [Item] { get }
}
extension Container where Item: Equatable {
func contains(_ x: Item) -> Bool { items.contains(x) }
}
struct Bag: Container { let items: [Int] }
print(Bag(items: [1, 2, 3]).contains(2))Valeur par défaut et exigence ensemble
Vous pouvez déclarer une méthode dans le protocole AND fournir une implémentation par défaut. Le fait de l'énumérer dans le protocole permet la résolution dynamique des appels via le type du protocole.
protocol Logger {
func log() -> String
}
extension Logger {
func log() -> String { "default log" }
}
struct A: Logger {}
struct B: Logger { func log() -> String { "B log" } }
let loggers: [Logger] = [A(), B()]
for l in loggers { print(l.log()) }Piège de la résolution statique
Si une méthode figure dans l'extension ONLY et non dans le protocole, les appels effectués via une valeur typée comme un protocole utilisent la version de l'extension, même si le type concret en a défini une autre. Déclarez-la dans le protocole pour obtenir une résolution dynamique des appels.
protocol P {}
extension P { func who() -> String { "P-default" } }
struct Q: P { func who() -> String { "Q" } }
let direct = Q()
let asP: P = Q()
print(direct.who())
print(asP.who())Réduire le code répétitif
L'association d'un petit ensemble d'exigences et de valeurs par défaut riches constitue le cœur de la conception orientée protocoles : les types conformes implémentent le minimum et le comportement partagé est défini en un seul endroit.
protocol Identifiable { var id: Int { get } }
extension Identifiable {
var tag: String { "ID-" + String(id) }
}
struct Order: Identifiable { let id: Int }
print(Order(id: 7).tag)Combiner plusieurs extensions
Vous pouvez répartir les valeurs par défaut entre plusieurs extensions pour organiser le code ; elles contribuent toutes au type conforme.
protocol Money { var cents: Int { get } }
extension Money { var dollars: Double { Double(cents) / 100 } }
extension Money { var label: String { "$" + String(format: "%.2f", dollars) } }
struct Price: Money { let cents: Int }
print(Price(cents: 1299).label)Vérification rapide
Vérifiez votre compréhension des valeurs par défaut des extensions de protocoles.
Récapitulatif
Les extensions de protocoles fournissent des implémentations par défaut, ce qui permet aux types conformes d'hériter d'un comportement partagé et de le remplacer si nécessaire. Vous pouvez ajouter des méthodes et des propriétés calculées supplémentaires, contraindre les valeurs par défaut avec where et retenir la règle de résolution statique ou dynamique des appels : déclarez une méthode dans le protocole pour obtenir une résolution dynamique.
Questions Fréquemment Posées
La leçon « Implémentations par défaut dans les extensions » est-elle gratuite ?
Oui — le texte complet de « Implémentations par défaut dans les extensions » 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 « Implémentations par défaut dans les extensions » ?
Fournissez un comportement commun via des extensions de protocoles. 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 2 sur 4.
Combien de temps prend la leçon « Implémentations par défaut dans les extensions » ?
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
- Les protocoles comme contrats
- Implémentations par défaut dans les extensions
- Composition de protocoles
- Conformité conditionnelle