Clauses where sur les fonctions
Ajoutez des contraintes précises aux fonctions génériques.
Clauses where sur les fonctions 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.
Au-delà des contraintes simples
Une contrainte comme <T: Collection> décrit T lui-même. Mais vous devez parfois contraindre les types associés de T, comme son Element. C'est précisément le rôle d'une clause where.
func sumInts<C: Collection>(_ c: C) -> Int where C.Element == Int {
c.reduce(0, +)
}
print(sumInts([1, 2, 3]))Exigence de même type
where C.Element == Int exige que les éléments de la collection soient exactement de type Int, ce qui permet d'effectuer des opérations propres aux entiers.
func describe<C: Collection>(_ c: C) -> String where C.Element == Int {
"Sum is " + String(c.reduce(0, +))
}
print(describe(Set([1, 2, 3])))Exigence de protocole sur l'élément
Vous pouvez exiger que l'élément se conforme à un protocole plutôt qu'il soit d'un type précis, ce qui offre davantage de souplesse.
func joinAll<C: Collection>(_ c: C) -> String
where C.Element: CustomStringConvertible {
c.map { $0.description }.joined(separator: ", ")
}
print(joinAll([1, 2, 3]))where après la signature
La clause where se place entre le type de retour et le corps de la fonction. Les contraintes placées dans <> et celles de la clause where fonctionnent ensemble.
func maxElement<C: Collection>(_ c: C) -> C.Element?
where C.Element: Comparable {
c.max()
}
print(maxElement([4, 9, 2])!)Relier deux paramètres de type
Une clause where peut relier les types des éléments de deux types génériques différents avec ==.
func combine<A: Collection, B: Collection>(_ a: A, _ b: B) -> [A.Element]
where A.Element == B.Element {
Array(a) + Array(b)
}
print(combine([1, 2], Set([3])))Plusieurs conditions where
Énumérez plusieurs exigences séparées par des virgules pour exprimer des contraintes combinées.
func report<C: Collection>(_ c: C)
where C.Element: Comparable, C.Element: CustomStringConvertible {
if let m = c.max() { print("max:", m.description) }
}
report([5, 1, 9])Contraindre des types associés imbriqués
Vous pouvez aller plus loin, en exigeant par exemple le type de l'élément d'un élément lorsque vous travaillez avec des collections imbriquées.
func flatten<C: Collection>(_ c: C) -> [Int]
where C.Element: Collection, C.Element.Element == Int {
c.flatMap { Array($0) }
}
print(flatten([[1, 2], [3]]))where avec des éléments Equatable
Exiger des éléments Equatable vous permet d'effectuer des recherches dans une collection générique.
func indexOf<C: Collection>(_ x: C.Element, in c: C) -> C.Index?
where C.Element: Equatable {
c.firstIndex(of: x)
}
if let i = indexOf(2, in: [1, 2, 3]) { print("found") }Méthodes génériques avec where
Les méthodes à l'intérieur des types génériques utilisent elles aussi where, souvent pour ajouter un comportement uniquement pour certains types d'éléments.
struct Wrap<T> {
let items: [T]
func total() -> Int where T == Int { items.reduce(0, +) }
}
print(Wrap(items: [1, 2, 3]).total())Avantage en matière de lisibilité
Les contraintes complexes sont plus faciles à comprendre dans une clause where que lorsqu'elles sont entassées entre les chevrons, en particulier lorsqu'il existe plusieurs conditions sur les types associés.
func first<C: Collection>(_ c: C) -> String
where C.Element: CustomStringConvertible {
c.first.map { $0.description } ?? "empty"
}
print(first([10, 20]))where dans la bibliothèque standard
Des méthodes comme joined() sur des séquences de séquences utilisent des clauses where en interne pour exprimer précisément leurs exigences.
let nested = [[1, 2], [3, 4]]
print(Array(nested.joined()))Vérification rapide
Évaluez votre compréhension des clauses where sur les fonctions.
Récapitulatif
Les clauses where vous permettent de contraindre les types associés d'un type générique : exiger qu'un élément soit d'un type précis (== Int), qu'il se conforme à un protocole (: Comparable), relier les éléments de deux paramètres ou accéder à des types associés imbriqués. Elles se placent après la signature et rendent les contraintes complexes plus lisibles.
Questions Fréquemment Posées
La leçon « Clauses where sur les fonctions » est-elle gratuite ?
Oui — le texte complet de « Clauses where sur les fonctions » 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 « Clauses where sur les fonctions » ?
Ajoutez des contraintes précises aux fonctions 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 2 sur 4.
Combien de temps prend la leçon « Clauses where sur les fonctions » ?
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