Covariance et contravariance TypeScript
La covariance et la contravariance sont des concepts importants dans le système de types de TypeScript ; les comprendre vous aide à écrire du code sûr au niveau des types.
Ils décrivent comment les types génériques se comportent dans les relations de type parent-enfant.
Diagramme SVG : Covariance et contravariance
Pourquoi avons-nous besoin de la covariance et de la contravariance ?
Lorsque vous utilisez des classes ou des fonctions génériques, le comportement des paramètres de type n'est pas aussi simple que vous pourriez le penser.
Affecter Dog à Animal est sûr, mais affecter une fonction qui gère Animal à une fonction qui gère Dog peut ne pas être sûr.
Les règles de covariance et de contravariance aident TypeScript à détecter ces erreurs de type potentielles.
Concepts :La covariance permet de convertir des sous-types en supertypes, la contravariance permet de convertir des supertypes en sous-types, et l'invariance ne permet aucune conversion dans un sens ou dans l'autre.
Covariant
La covariance signifie qu'un sous-type peut être affecté à un supertype. C'est sûr pour les types de sortie (comme les valeurs de retour de fonction).
Exemple
class Animal {
name: string = "Animal";
}
class Dog extends Animal {
breed: string = "Chien rural";
}
// Covariance : les types de sortie peuvent être convertis en types plus larges
// Une fonction qui renvoie Dog peut être assignée à une fonction qui renvoie Animal
type AnimalGetter = () => Animal;
type DogGetter = () => Dog;
// Dog est un sous-type d'Animal, donc DogGetter peut être assigné à AnimalGetter
const getDog: DogGetter = () => new Dog();
const getAnimal: AnimalGetter = getDog; // Covariance : sûre
// Exécuter
const animal: Animal = getAnimal();
console.log("Nom de l'animal : " + animal.name);
Sortie :
Animal Name: Animal
Covariance du type de retour :Il est sûr qu'une fonction retourne un sous-type plus spécifique, car l'objet retourné satisfait toujours aux exigences du supertype.
Contravariant
La contravariance signifie que pour les types d'entrée (comme les paramètres de fonction), un supertype peut être affecté à un sous-type.
Exemple
class Animal {
name: string = "Animal";
}
class Dog extends Animal {
breed: string = "Chien rural";
}
// Contravariance : les types d'entrée peuvent être convertis en types plus spécifiques
// Une fonction acceptant Animal peut être affectée à une fonction acceptant Dog
type DogConsumer = (dog: Dog) => void;
type AnimalConsumer = (animal: Animal) => void;
// Si une fonction acceptant un type plus large peut être affectée à une fonction acceptant un type plus spécifique
// alors, lorsque nous passons un Dog, la fonction pourrait ne pas pouvoir le gérer (il lui manque les propriétés spécifiques à Dog)
const consumeAnimal: AnimalConsumer = (animal) => {
console.log("Traitement de l'animal : " + animal.name);
};
const consumeDog: DogConsumer = consumeAnimal; // Contravariance : sûre
// Exécuter
const dog = new Dog();
dog.breed = "Husky";
consumeDog(dog);
Contravariance des paramètres :Les paramètres de fonction utilisent la contravariance car une fonction qui accepte un type plus spécifique ne peut pas gérer un type plus large.
Activation des types de fonctions stricts
TypeScript vérifie les paramètres de fonction de manière contravariante par défaut. L'activation de strictFunctionTypes impose cette règle.
Exemple
interface Animal {
readonly name: string;
}
interface Dog extends Animal {
readonly breed: string;
}
// Définir les types de fonction
type GetName = (animal: Animal) => string;
type GetDogBreed = (dog: Dog) => string;
// Affectation correcte
const getDogBreed: GetDogBreed = (dog) => dog.breed;
// Tentative d'affectation - produira une erreur sous strictFunctionTypes
// Parce que AnimalConsumer (paramètre plus général) ne peut pas être affecté à DogConsumer (paramètre plus spécifique)
// C'est parce que les paramètres sont contravariants
function printAnimalName(animal: Animal): string {
return animal.name;
}
// Essayez d'affecter une fonction qui accepte un type plus général à un type plus spécifique
// const getSpecific: GetDogBreed = printAnimalName; // Erreur !
console.log("Race de chien : " + getDogBreed({ name: "Wangcai", breed: "Husky" }));
strictFunctionTypes:Activez cette option dans tsconfig.json pour une vérification de type plus stricte.
Covariance des classes génériques
Les propriétés des classes génériques sont covariantes par défaut.
Exemple
class Animal {
name: string = "Animal";
}
class Dog extends Animal {
breed: string = "Chien";
}
// Classe conteneur générique
class Cage<T> {
animal: T;
constructor(animal: T) {
this.animal = animal;
}
}
// Covariance : un conteneur de sous-type peut être affecté à un conteneur de supertype
const dogCage = new Cage(new Dog());
const animalCage: Cage<Animal> = dogCage; // Covariance : sans danger
// animalCage peut maintenant être utilisé en toute sécurité comme une cage contenant des animaux
console.log("Nom de l'animal : " + animalCage.animal.name);
Covariance des propriétés :Les propriétés d'un objet sont covariantes ; une propriété de sous-type peut être assignée à une propriété de supertype.
Covariance des tableaux
Les tableaux en TypeScript sont covariants, mais vous devez être conscient des problèmes causés par la mutabilité.
Exemple
class Animal {
name: string = "Animal";
}
class Dog extends Animal {
breed: string = "Chien";
}
// Covariance des tableaux
const dogs: Dog[] = [
{ name: "Wangcai", breed: "Husky" },
{ name: "Xiao Bai", breed: "Samoyède" }
];
// Dog[] peut être assigné à Animal[]
const animals: Animal[] = dogs; // Covariance : sûre
// Problème : bien que ce soit sûr au niveau des types, vous pouvez en fait ajouter d'autres animaux
// animals.push({ name: "Cat", breed: "Cat" }); // Peut causer des problèmes à l'exécution !
console.log("Nombre d'animaux : " + animals.length);
Mutabilité des tableaux :Modifier un tableau après une affectation covariante peut entraîner des erreurs d'exécution ; soyez prudent.
Utilisation de extends pour une affectation sûre
Après avoir compris la covariance et la contravariance, vous pouvez concevoir des interfaces génériques en toute sécurité.
Exemple
interface Producer<T> {
// Méthode Producer : la valeur de retour est covariante
produce(): T;
}
interface Consumer<T> {
// Méthode Consumer : les paramètres sont contravariants
consume(value: T): void;
}
// Implémentation concrète
class DogProducer implements Producer<Dog> {
produce(): Dog {
return { name: "Wangcai", breed: "Husky" };
}
}
class AnimalConsumer implements Consumer<Animal> {
consume(animal: Animal): void {
console.log("Animal consommé : " + animal.name);
}
}
// Producer<Dog> peut être assigné à Producer<Animal> (covariant)
const animalProducer: Producer<Animal> = new DogProducer();
// Consumer<Animal> peut être assigné à Consumer<Dog> (contravariant)
const dogConsumer: Consumer<Dog> = new AnimalConsumer();
// Test
const animal = animalProducer.produce();
console.log("Production : " + animal.name);
dogConsumer.consume({ name: "Wangcai", breed: "Husky" });
Principes de conception :Choisissez la direction de type appropriée en fonction de l’objectif de la méthode pour améliorer la sécurité des types de votre API.
Remarques importantes
- Covariance du type de retour :Il est sûr pour les fonctions de renvoyer un sous-type
- Contravariance des paramètres :Il est sûr pour les paramètres de fonction d’utiliser un supertype
- Activez le mode strict :Utilisez strictFunctionTypes pour une vérification plus stricte
- Covariance des tableaux :Faites attention aux problèmes potentiels causés par la mutabilité
Bonnes pratiques :Comprendre la covariance et la contravariance aide à concevoir des API plus sûres en termes de types et à éviter les erreurs d’exécution.
Résumé
La covariance et la contravariance sont des concepts fondamentaux du système de types de TypeScript.
- Covariance:Sous-type → supertype, utilisé pour les types de sortie
- Contravariance:Type parent → type enfant, utilisé pour les types d'entrée
- Invariance:Impossible de les assigner l'un à l'autre
- strictFunctionTypes:Activer la vérification stricte des types de fonctions
Autres extensionsRecommandation:Tenez compte de la covariance et de la contravariance lors de la conception d'API génériques pour écrire du code de type plus sûr.