0Pricing
Swift Academy · Leçon

Quand utiliser les existentiels (any P) plutôt que les génériques

Choisissez entre any P (types existentiels) et les génériques : stockage hétérogène et comportement dynamique contre spécialisation à la compilation et garanties statiques.

Quand utiliser les existentiels (any P) plutôt que les génériques est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. 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 3 leçons au total.

Types existentiels et génériques

Les existentiels (n’importe quel P) stockent des valeurs d’un type concret inconnu qui se conforment à un protocole. Les génériques (<T: P>) conservent le type concret à la compilation pour la spécialisation.

Configuration du protocole

Les protocoles sans types associés sont faciles à utiliser comme existentiels n’importe quel P et comme contraintes génériques.

protocol Animal {
    func speak() -> String
}
struct Dog: Animal { func speak() -> String { "woof" } }
struct Cat: Animal { func speak() -> String { "meow" } }

Tableaux hétérogènes

Utilisez [n’importe quel Animal] pour stocker ensemble différents types conformes et n’appeler que l’API du protocole.

let zoo: [any Animal] = [Dog(), Cat()]   // heterogeneous array
for a in zoo { print(a.speak()) }              // "woof", "meow"

Spécialisation grâce aux génériques

Les génériques préservent le type concret (T), ce qui permet davantage d’optimisations et des vérifications plus strictes à la compilation.

// Generic version — compiler specializes for each concrete type
func shout<T: Animal>(_ a: T) {
    // Can inline/specialize based on concrete T
    print(a.speak().uppercased())
}
shout(Dog()) // WOOF
shout(Cat()) // MEOW

Limites des PAT

Les protocoles avec des types associés fonctionnent mal comme existentiels simples si vous avez besoin du type associé. Préférez les génériques ou l’effacement de type (par exemple, AnySequence).

protocol Container {
    associatedtype Item
    func get(_ i: Int) -> Item
}
// Storing as `any Container` loses the concrete Item.
// You can't use Item directly without additional constraints or type erasure.

Quand choisir quelle approche

Choisissez :

  • n’importe quel P lorsque vous avez besoin d’un stockage hétérogène ou d’un comportement dynamique limité à l’API du protocole.
  • Les génériques lorsque vous voulez des types statiques, une meilleure optimisation ou devez relier plusieurs types (par exemple, le même élément).
  • Pour les PAT où l’élément est important, utilisez les génériques ou ajoutez un effacement de type.

N’importe quel P ou génériques

Vérification rapide : quand faut-il préférer n’importe quel P ?

Récapitulatif

Récapitulatif : utilisez n’importe quel P pour des types conformes mélangés et un comportement dynamique ; utilisez les génériques pour la spécialisation à la compilation et lorsque les types associés ou les relations sont importants.

Questions Fréquemment Posées

La leçon « Quand utiliser les existentiels (any P) plutôt que les génériques » est-elle gratuite ?

Oui — le texte complet de « Quand utiliser les existentiels (any P) plutôt que les 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 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Quand utiliser les existentiels (any P) plutôt que les génériques » ?

Choisissez entre any P (types existentiels) et les génériques : stockage hétérogène et comportement dynamique contre spécialisation à la compilation et garanties statiques. 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 3.

Combien de temps prend la leçon « Quand utiliser les existentiels (any P) plutôt que les 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

  1. associatedtype et protocoles génériques
  2. Schémas d’effacement de type (AnySequence/AnyIterator)
  3. Quand utiliser les existentiels (any P) plutôt que les génériques
← Retour à Swift Academy