Ковариантность и контравариантность в TypeScript
Ковариантность и контравариантность — важные концепции в системе типов TypeScript; понимание их помогает писать типобезопасный код.
Они описывают, как ведут себя обобщённые типы в отношениях родитель-потомок.
SVG-диаграмма: Ковариантность и контравариантность
Зачем нам нужны ковариантность и контравариантность?
При использовании обобщённых классов или функций поведение параметров типа не так просто, как вы могли бы подумать.
Присваивание Dog типу Animal безопасно, но присваивание функции, которая обрабатывает Animal, функции, которая обрабатывает Dog, может быть небезопасным.
Правила ковариантности и контравариантности помогают TypeScript выявлять эти потенциальные ошибки типов.
Понятия:Ковариантность позволяет преобразовывать подтипы в супертипы, контравариантность позволяет преобразовывать супертипы в подтипы, а инвариантность не допускает преобразования ни в одном из направлений.
Ковариантный
Ковариантность означает, что подтип может быть присвоен супертипу. Это безопасно для выходных типов (например, возвращаемых значений функций).
Пример
class Animal {
name: string = "Animal";
}
class Dog extends Animal {
breed: string = "Rural Dog";
}
// Ковариантность: выходные типы могут быть преобразованы в более широкие типы
// Функция, возвращающая Dog, может быть присвоена функции, возвращающей Animal
type AnimalGetter = () => Animal;
type DogGetter = () => Dog;
// Dog — подтип Animal, поэтому DogGetter можно присвоить AnimalGetter
const getDog: DogGetter = () => new Dog();
const getAnimal: AnimalGetter = getDog; // Ковариантность: безопасно
// Запуск
const animal: Animal = getAnimal();
console.log("Имя животного: " + animal.name);
Вывод:
Animal Name: Animal
Ковариантность типа возвращаемого значения:Функция может безопасно возвращать более конкретный подтип, потому что возвращаемый объект всегда удовлетворяет требованиям супертипа.
Контравариантность
Контравариантность означает, что для входных типов (например, параметров функции) супертип может быть присвоен подтипу.
Пример
class Animal {
name: string = "Animal";
}
class Dog extends Animal {
breed: string = "Rural Dog";
}
// Контравариантность: входные типы можно преобразовать в более конкретные типы
// Функция, принимающая Animal, может быть присвоена функции, принимающей Dog
type DogConsumer = (dog: Dog) => void;
type AnimalConsumer = (animal: Animal) => void;
// Если функция, принимающая более широкий тип, может быть присвоена функции, принимающей более конкретный тип
// тогда, когда мы передаём Dog, функция может не суметь его обработать (у него отсутствуют свойства, специфичные для Dog)
const consumeAnimal: AnimalConsumer = (animal) => {
console.log("Обработка животного: " + animal.name);
};
const consumeDog: DogConsumer = consumeAnimal; // Контравариантность: безопасно
// Запуск
const dog = new Dog();
dog.breed = "Хаски";
consumeDog(dog);
Контравариантность параметров:Параметры функции используют контравариантность, потому что функция, принимающая более конкретный тип, не может обрабатывать более широкий тип.
Включение строгих типов функций
TypeScript по умолчанию проверяет параметры функций контравариантно. Включение strictFunctionTypes обеспечивает соблюдение этого правила.
Пример
interface Animal {
readonly name: string;
}
interface Dog extends Animal {
readonly breed: string;
}
// Определить типы функций
type GetName = (animal: Animal) => string;
type GetDogBreed = (dog: Dog) => string;
// Корректное присваивание
const getDogBreed: GetDogBreed = (dog) => dog.breed;
// Попытка присваивания - вызовет ошибку при strictFunctionTypes
// Поскольку AnimalConsumer (более широкий параметр) не может быть присвоен DogConsumer (более конкретному параметру)
// Это потому, что параметры контравариантны
function printAnimalName(animal: Animal): string {
return animal.name;
}
// Попытка присвоить функцию, принимающую более широкий тип, более конкретному типу
// const getSpecific: GetDogBreed = printAnimalName; // Ошибка!
console.log("Порода собаки: " + getDogBreed({ name: "Ванцай", breed: "Хаски" }));
strictFunctionTypes:Включите эту опцию в tsconfig.json для более строгой проверки типов.
Ковариантность обобщённых классов
Свойства обобщённых классов по умолчанию ковариантны.
Пример
class Animal {
name: string = "Animal";
}
class Dog extends Animal {
breed: string = "Собака";
}
// Обобщённый класс-контейнер
class Cage<T> {
animal: T;
constructor(animal: T) {
this.animal = animal;
}
}
// Ковариантность: контейнер подтипа можно присвоить контейнеру супертипа
const dogCage = new Cage(new Dog());
const animalCage: Cage<Animal> = dogCage; // Ковариантность: безопасно
// animalCage теперь можно безопасно использовать как клетку, содержащую животных
console.log("Имя животного: " + animalCage.animal.name);
Ковариантность свойств:Свойства объектов ковариантны; свойство подтипа можно присвоить свойству супертипа.
Ковариантность массивов
Массивы в TypeScript ковариантны, но нужно учитывать проблемы, вызванные изменяемостью.
Пример
class Animal {
name: string = "Animal";
}
class Dog extends Animal {
breed: string = "Собака";
}
// Ковариантность массивов
const dogs: Dog[] = [
{ name: "Ванцай", breed: "Хаски" },
{ name: "Сяо Бай", breed: "Самоед" }
];
// Dog[] можно присвоить Animal[]
const animals: Animal[] = dogs; // Ковариантность: безопасно
// Проблема: хотя это типобезопасно, вы на самом деле можете добавить других животных
// animals.push({ name: "Cat", breed: "Cat" }); // Может вызвать проблемы во время выполнения!
console.log("Количество животных: " + animals.length);
Изменяемость массива:Изменение массива после ковариантного присваивания может вызвать ошибки времени выполнения; будьте осторожны.
Использование extends для безопасного присваивания
После понимания ковариантности и контравариантности вы можете безопасно проектировать обобщённые интерфейсы.
Пример
interface Producer<T> {
// Метод Producer: возвращаемое значение ковариантно
produce(): T;
}
interface Consumer<T> {
// Метод Consumer: параметры контравариантны
consume(value: T): void;
}
// Конкретная реализация
class DogProducer implements Producer<Dog> {
produce(): Dog {
return { name: "Ванцай", breed: "Хаски" };
}
}
class AnimalConsumer implements Consumer<Animal> {
consume(animal: Animal): void {
console.log("Потребление животного: " + animal.name);
}
}
// Producer<Dog> может быть присвоен Producer<Animal> (ковариантный)
const animalProducer: Producer<Animal> = new DogProducer();
// Consumer<Animal> может быть присвоен Consumer<Dog> (контравариантный)
const dogConsumer: Consumer<Dog> = new AnimalConsumer();
// Тест
const animal = animalProducer.produce();
console.log("Производится: " + animal.name);
dogConsumer.consume({ name: "Ванцай", breed: "Хаски" });
Принципы проектирования:Выбирайте подходящее направление типов в зависимости от назначения метода, чтобы повысить типобезопасность вашего API.
Важные замечания
- Ковариантность возвращаемого типа:Функции могут безопасно возвращать подтип
- Контравариантность параметров:Параметры функции могут безопасно использовать супертип
- Включите строгий режим:Используйте strictFunctionTypes для более строгой проверки
- Ковариантность массивов:Помните о потенциальных проблемах, вызванных изменяемостью
Лучшие практики:Понимание ковариантности и контравариантности помогает проектировать более типобезопасные API и избегать ошибок времени выполнения.
Итог
Ковариантность и контравариантность — основные концепции системы типов TypeScript.
- Ковариантность:Подтип → супертип, используется для выходных типов
- Контравариантность:Родительский тип → дочерний тип, используется для входных типов
- Инвариантность:Не могут быть присвоены друг другу
- strictFunctionTypes:Включить строгую проверку типов функций
Другие расширенияРекомендация:Учитывайте ковариантность и контравариантность при проектировании обобщённых API, чтобы писать более безопасный типовой код.