Contraindre les types associés
Limitez les types associés dans les contextes génériques.
Contraindre les types associés 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.
Récapitulatif des types associés
Un protocole peut déclarer un type associé avec associatedtype, un espace réservé qu'un type conforme renseigne. Element dans un protocole de conteneur en est l'exemple classique.
protocol Container {
associatedtype Item
var count: Int { get }
func item(at i: Int) -> Item
}Se conformer avec un type concret
Un type conforme fixe le type associé, souvent déduit de la manière dont il est utilisé.
protocol Container {
associatedtype Item
func item(at i: Int) -> Item
}
struct IntBox: Container {
let values: [Int]
func item(at i: Int) -> Int { values[i] }
}
print(IntBox(values: [10, 20]).item(at: 1))Contraindre le type associé
Ajoutez une contrainte directement dans la déclaration : associatedtype Item: Comparable force le type d'élément de chaque type conforme à prendre en charge la comparaison.
protocol Sorted {
associatedtype Item: Comparable
var items: [Item] { get }
}
struct Nums: Sorted { let items: [Int] }
print(Nums(items: [3, 1, 2]).items.sorted())Utiliser la contrainte
Comme le type associé est soumis à une contrainte, les extensions de protocole peuvent s'appuyer sur cette capacité.
protocol Sorted {
associatedtype Item: Comparable
var items: [Item] { get }
}
extension Sorted {
var smallest: Item? { items.min() }
}
struct Nums: Sorted { let items: [Int] }
print(Nums(items: [5, 2, 8]).smallest!)Clause de contrainte sur un type associé
Swift permet également d'appliquer une clause where à un type associé pour le relier à un autre type associé ou à un type imbriqué.
protocol Sequence2 {
associatedtype Element
associatedtype Iterator: IteratorProtocol where Iterator.Element == Element
}Contraindre à un autre protocole
Un type associé peut être tenu de se conformer à un protocole que vous définissez, ce qui permet de superposer des comportements.
protocol HasName { var name: String { get } }
protocol Registry {
associatedtype Entry: HasName
var entries: [Entry] { get }
}
struct User: HasName { let name: String }
struct Users: Registry { let entries: [User] }
print(Users(entries: [User(name: "Ada")]).entries[0].name)Plusieurs types associés
Un protocole peut déclarer plusieurs types associés, chacun soumis à ses propres contraintes.
protocol Mapping {
associatedtype Key: Hashable
associatedtype Value
func value(for k: Key) -> Value?
}
struct Phonebook: Mapping {
let data: [String: Int]
func value(for k: String) -> Int? { data[k] }
}
print(Phonebook(data: ["x": 1]).value(for: "x")!)Type associé par défaut
Vous pouvez attribuer une valeur par défaut à un type associé avec =, utilisée lorsqu'un type conforme ne le précise pas autrement.
protocol Producer {
associatedtype Output = String
func make() -> Output
}
struct Hello: Producer {
func make() -> String { "hi" }
}
print(Hello().make())Les contraintes permettent des algorithmes génériques
Lorsqu'un type associé est soumis à une contrainte, une extension de protocole peut implémenter de véritables algorithmes partagés par tous les types conformes.
protocol Scored {
associatedtype Score: Comparable
var scores: [Score] { get }
}
extension Scored {
var best: Score? { scores.max() }
}
struct Game: Scored { let scores: [Int] }
print(Game(scores: [10, 40, 25]).best!)Contraintes de même type dans les extensions
En dehors du protocole, vous pouvez contraindre davantage le type associé lors de l'extension du protocole.
protocol Box2 {
associatedtype Content
var content: Content { get }
}
extension Box2 where Content == Int {
var doubled: Int { content * 2 }
}
struct IB: Box2 { let content: Int }
print(IB(content: 7).doubled)Pourquoi ajouter une contrainte ?
Contraindre les types associés permet aux protocoles de rester génériques tout en étant puissants : la contrainte est une promesse sur laquelle l'extension et les appelants peuvent compter.
protocol Listy {
associatedtype E: Equatable
var elements: [E] { get }
}
extension Listy {
func has(_ x: E) -> Bool { elements.contains(x) }
}
struct L: Listy { let elements: [String] }
print(L(elements: ["a", "b"]).has("b"))Vérification rapide
Évaluez votre compréhension des contraintes sur les types associés.
Récapitulatif
Vous pouvez contraindre directement les types associés (associatedtype Item: Comparable), les relier avec des clauses where, exiger une conformité à un protocole, définir des valeurs par défaut avec =, déclarer plusieurs types associés et les préciser dans des extensions. Les contraintes permettent aux extensions de protocole d'implémenter des algorithmes partagés et sûrs du point de vue des types.
Questions Fréquemment Posées
La leçon « Contraindre les types associés » est-elle gratuite ?
Oui — le texte complet de « Contraindre les types associés » 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 « Contraindre les types associés » ?
Limitez les types associés dans les contextes génériques. 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 « Contraindre les types associés » ?
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
- Contraintes des paramètres de type
- Clauses where sur les fonctions
- Contraindre les types associés
- Indices et extensions génériques