Swift Academy · Leçon

Contraintes des paramètres de type

Exigez la conformité des paramètres génériques.

Contraintes des paramètres de type est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 génériques

Une fonction générique utilise un paramètre de type comme <T> afin de fonctionner avec de nombreux types. Cependant, un T sans contrainte peut seulement être transmis, et non examiné. Les contraintes permettent d'accéder à des fonctionnalités.

func identity<T>(_ x: T) -> T { x }
print(identity(5))
print(identity("hi"))

La contrainte Comparable

Écrire <T: Comparable> garantit que les valeurs de T prennent en charge <, > et les opérateurs associés, ce qui vous permet de les comparer.

func largest<T: Comparable>(_ a: T, _ b: T) -> T {
    a > b ? a : b
}
print(largest(3, 9))
print(largest("apple", "pear"))

Pourquoi les contraintes sont nécessaires

Sans Comparable, le compilateur rejette a > b, car tous les types ne prennent pas cette opération en charge. La contrainte constitue la promesse qui rend l'opération légale.

func minOf<T: Comparable>(_ list: [T]) -> T? {
    list.min()
}
print(minOf([4, 2, 8])!)

La contrainte Equatable

Equatable permet d'utiliser == et !=. Utilisez-la pour compter ou trouver les éléments correspondants.

func count<T: Equatable>(_ x: T, in list: [T]) -> Int {
    list.filter { $0 == x }.count
}
print(count(2, in: [2, 3, 2, 2]))

La contrainte Hashable

Hashable vous permet d'utiliser des valeurs comme éléments d'un Set ou comme clés de dictionnaire.

func unique<T: Hashable>(_ list: [T]) -> [T] {
    Array(Set(list))
}
print(unique([1, 1, 2, 3, 3]).sorted())

Contraintes de protocole

N'importe quel protocole peut servir de contrainte. Ici, un protocole personnalisé permet d'utiliser sa méthode sur le paramètre générique.

protocol Speaker { func speak() -> String }
struct Dog: Speaker { func speak() -> String { "Woof" } }

func announce<T: Speaker>(_ x: T) {
    print(x.speak())
}
announce(Dog())

Contraintes de classe

Vous pouvez exiger que T hérite d'une classe particulière afin d'accéder aux membres de cette classe.

class Animal { func name() -> String { "animal" } }
class Cat: Animal { override func name() -> String { "cat" } }

func describe<T: Animal>(_ x: T) { print(x.name()) }
describe(Cat())

Plusieurs contraintes

Combinez des contraintes avec & pour exiger plusieurs protocoles à la fois.

func show<T: CustomStringConvertible & Equatable>(_ a: T, _ b: T) {
    print(a.description, a == b)
}
show(5, 5)

Plusieurs paramètres de type

Une fonction peut avoir plusieurs paramètres contraints, chacun avec ses propres exigences.

func zipMap<K: Hashable, V>(_ keys: [K], _ vals: [V]) -> [K: V] {
    var d: [K: V] = [:]
    for (k, v) in zip(keys, vals) { d[k] = v }
    return d
}
print(zipMap(["a", "b"], [1, 2]))

Contraintes sur les types

Les types génériques, et pas seulement les fonctions, acceptent eux aussi des contraintes. Une structure générique peut exiger que son paramètre se conforme à un protocole.

struct SortedBox<T: Comparable> {
    var items: [T]
    var smallest: T? { items.min() }
}
print(SortedBox(items: [5, 1, 9]).smallest!)

Contraintes numériques

Les protocoles standard comme Numeric permettent au code générique d'effectuer des calculs avec Int, Double et bien d'autres types.

func sum<T: Numeric>(_ list: [T]) -> T {
    list.reduce(0, +)
}
print(sum([1, 2, 3]))
print(sum([1.5, 2.5]))

Vérification rapide

Évaluez votre compréhension des contraintes sur les paramètres de type.

Récapitulatif

Les contraintes sur les paramètres de type (<T: Protocol> ou <T: SomeClass>) indiquent au compilateur ce qu'un type générique peut faire. Vous avez vu Comparable, Equatable, Hashable, Numeric, les protocoles personnalisés, les contraintes de classe, les contraintes multiples avec & et les contraintes sur les types génériques.

Questions Fréquemment Posées

La leçon « Contraintes des paramètres de type » est-elle gratuite ?

Oui — le texte complet de « Contraintes des paramètres de type » 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 « Contraintes des paramètres de type » ?

Exigez la conformité des paramètres 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 1 sur 4.

Combien de temps prend la leçon « Contraintes des paramètres de type » ?

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

← Retour à Swift Academy