Indices et extensions génériques
Appliquez des contraintes aux indices et aux extensions.
Indices et extensions génériques est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.
Indices génériques
Les indices peuvent être génériques et accepter leurs propres paramètres de type, indépendamment du type qui les contient. Ainsi, un même indice peut servir avec de nombreux types d'entrée.
struct Lookup {
let data = [1, 2, 3, 4, 5]
subscript<S: Sequence>(indices idx: S) -> [Int] where S.Element == Int {
idx.map { data[$0] }
}
}
print(Lookup()[indices: [0, 2, 4]])Pourquoi des indices génériques ?
Vous pouvez transmettre un Array, un Set ou un Range d'indices au même indice, car celui-ci accepte toute Sequence de Int.
struct Lookup {
let data = [10, 20, 30, 40]
subscript<S: Sequence>(_ idx: S) -> [Int] where S.Element == Int {
idx.map { data[$0] }
}
}
let l = Lookup()
print(l[0...1])
print(l[[3, 0]])Extensions contraintes
Une extension ... where ajoute des membres qui n'existent que lorsque la contrainte est respectée. Ils apparaissent sur le type uniquement pour les arguments génériques correspondants.
extension Array where Element: Numeric {
func sumAll() -> Element { reduce(0, +) }
}
print([1, 2, 3].sumAll())
print([1.5, 2.5].sumAll())Extension sur un type d'élément précis
Utilisez where Element == String pour ajouter des fonctions auxiliaires propres à String uniquement aux tableaux de chaînes.
extension Array where Element == String {
func shout() -> [String] { map { $0.uppercased() + "!" } }
}
print(["hi", "bye"].shout())Extension contrainte avec un protocole
Ajoutez un comportement lorsque les éléments se conforment à un protocole personnalisé.
protocol Priced { var price: Double { get } }
struct Item: Priced { let price: Double }
extension Collection where Element: Priced {
var total: Double { reduce(0) { $0 + $1.price } }
}
print([Item(price: 2), Item(price: 3)].total)Indice générique renvoyant un type optionnel
Un indice peut être générique et renvoyer un type optionnel, par exemple pour accéder à une collection de manière sûre par son indice.
extension Array {
subscript(safe i: Int) -> Element? {
indices.contains(i) ? self[i] : nil
}
}
print([1, 2, 3][safe: 1] ?? -1)
print([1, 2, 3][safe: 9] ?? -1)Indice générique sur un dictionnaire
Les indices génériques peuvent accepter une séquence de clés et renvoyer les valeurs correspondantes.
extension Dictionary {
subscript<S: Sequence>(keys ks: S) -> [Value] where S.Element == Key {
ks.compactMap { self[$0] }
}
}
let d = ["a": 1, "b": 2, "c": 3]
print(d[keys: ["a", "c"]].sorted())Combiner avec where sur Self
Les extensions de types génériques peuvent contraindre le type enveloppé et exposer des API adaptées.
struct Stack<T> { var items: [T] = [] }
extension Stack where T: Comparable {
var peakMax: T? { items.max() }
}
var s = Stack<Int>(); s.items = [3, 9, 1]
print(s.peakMax!)Indice générique avec plusieurs paramètres
Un indice peut accepter plusieurs arguments ainsi que ses propres paramètres de type.
struct Grid {
let rows = [[1, 2], [3, 4]]
subscript(_ r: Int, _ c: Int) -> Int { rows[r][c] }
}
print(Grid()[1, 0])Lecture seule ou lecture-écriture
Comme les propriétés, les indices peuvent avoir uniquement un get, ou à la fois un get et un set pour permettre la modification.
struct Pad {
var values = [0, 0, 0]
subscript(i: Int) -> Int {
get { values[i] }
set { values[i] = newValue }
}
}
var p = Pad(); p[1] = 7
print(p.values)Mettre tout ensemble
Les indices génériques et les extensions contraintes vous permettent de créer des API expressives et sûres du point de vue des types, qui s'adaptent aux types d'éléments ou d'arguments utilisés.
extension Array where Element: Comparable {
subscript(topAfterSort i: Int) -> Element { sorted()[i] }
}
print([5, 1, 9, 3][topAfterSort: 0])Vérification rapide
Évaluez votre compréhension des indices génériques et des extensions contraintes.
Récapitulatif
Les indices génériques déclarent leurs propres paramètres de type et clauses where, ce qui permet à un même indice d'accepter de nombreux types d'entrée. Les extensions contraintes (where Element: ... ou == ...) ajoutent des membres uniquement lorsque les conditions sont respectées. Ensemble, elles permettent de créer des API sûres et adaptables.
Questions Fréquemment Posées
La leçon « Indices et extensions génériques » est-elle gratuite ?
Oui — le texte complet de « Indices et extensions génériques » 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 « Indices et extensions génériques » ?
Appliquez des contraintes aux indices et aux extensions. 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 4 sur 4.
Combien de temps prend la leçon « Indices et extensions génériques » ?
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