TypeScript: защитники типов
Type Guards — очень важный механизм сужения типов в TypeScript.
Они позволяют разработчикам использовать определённые проверки условий во время выполнения, чтобы компилятор TypeScript мог точно вывести конкретный тип переменной.
С помощью Type Guards мы можем безопасно обращаться к свойствам и методам конкретного типа внутри переменной объединённого типа.
Зачем нам нужны Type Guards?
В TypeScript переменная может быть объявлена как объединение нескольких типов.
Когда нам нужно выполнять разные операции в зависимости от конкретного типа, компилятор не может автоматически определить текущий конкретный тип.
Type Guards — ключевой механизм решения этой проблемы.
Объяснение концепции:Основной принцип Type Guards — «сужение типов». С помощью проверок условий TypeScript автоматически сужает объединённый тип до конкретного типа.
SVG-диаграмма: Поток защиты типов
typeof — защита типа
typeof — наиболее часто используемая защита типа, применяемая для проверки примитивных типов (string, number, boolean и т. д.).
Он возвращает строку, указывающую тип значения.
Базовое использование typeof
// Параметр value может быть строкой или числом
function printValue(value: string | number): void {
// Используйте typeof для проверки типа
// Когда условие if истинно, TypeScript автоматически сужает value до типа string
if (typeof value === "string") {
// На этом этапе TypeScript знает, что value — строка
// Можно безопасно обратиться к свойству length строки
console.log("Длина строки: " + value.length);
} else {
// В ветке else TypeScript знает, что value не является строкой
// Оно может иметь только тип number
// Можно безопасно выполнять математические операции
console.log("Удвоенное число: " + (value * 2));
}
}
// Тестовые вызовы
printValue("hello"); // Передаём строку
printValue(42); // Передаём число
Вывод:
字符串长度: 5 数字翻倍: 84
Типы, поддерживаемые typeof:
- "string"- тип string
- "number"- тип number (включая NaN и Infinity)
- "boolean"- тип boolean
- "undefined"- тип undefined
- "object"- тип object (примечание: массивы и null также распознаются как "object")
- "function"- тип function
Примечание:typeof возвращает "object" как для массивов, так и для null. Если вам нужно точно различать массивы и объекты, необходимо использовать другие методы.
instanceof — защитник типа
instanceof используется для проверки, является ли объект экземпляром определённого класса.
Он определяет тип, проверяя цепочку прототипов объекта.
instanceof: базовое использование
class Dog {
// Метод bark собаки
bark(): void {
console.log("Гав гав гав!");
}
}
// Определить класс Cat
class Cat {
// Метод meow кота
meow(): void {
console.log("Мяу мяу мяу!");
}
}
// Функция, принимающая тип объединения
function makeSound(animal: Dog | Cat): void {
// Используйте instanceof, чтобы проверить, является ли animal объектом Dog или Cat
// Когда условие if истинно, TypeScript сужает тип animal до типа Dog
if (animal instanceof Dog) {
// На этом этапе можно вызывать методы, специфичные для Dog
animal.bark();
} else {
// В ветке else TypeScript сужает тип animal до типа Cat
animal.meow();
}
}
// Тестовые вызовы
makeSound(new Dog()); // Создайте экземпляр Dog и вызовите его
makeSound(new Cat()); // Создайте экземпляр Cat и вызовите его
Вывод:
Woof woof woof! Meow meow meow!
Пояснение:
instanceof проверяет цепочку прототипов объекта, поэтому его можно использовать только с экземплярами классов, но не с интерфейсами или псевдонимами типов.
Пользовательские защитники типов
Когда встроенные typeof и instanceof не соответствуют требованиям, можно создавать пользовательские функции-защитники типов.
Пользовательские защитники типов используютvalue is Typeсинтаксис возвращаемого типа.
Пользовательские функции-защитники
// Тип возвращаемого значения использует формат "value is Type"
// Это сообщает TypeScript: когда функция возвращает true, тип параметра — string
function isString(value: any): value is string {
// Используйте typeof для проверки, является ли значение строкой
return typeof value === "string";
}
// Ещё одна пользовательская защита: проверьте, является ли значение числом
function isNumber(value: any): value is number {
return typeof value === "number";
}
// Определите защиту типа для массива
function isArray(value: any): value is any[] {
return Array.isArray(value);
}
// Функция, обрабатывающая значения
function processValue(value: string | number | any[]): void {
// Используйте пользовательские защиты для проверки типов
if (isString(value)) {
// TypeScript знает, что value имеет тип string
// Можно вызвать метод toUpperCase()
console.log("Строка в верхнем регистре: " + value.toUpperCase());
} else if (isNumber(value)) {
// TypeScript знает, что value имеет тип number
// Можно вызвать метод toFixed()
console.log("Форматированное число: " + value.toFixed(2));
} else if (isArray(value)) {
// TypeScript знает, что value имеет тип array
console.log("Длина массива: " + value.length);
}
}
// Тестовые вызовы
processValue("привет");
processValue(3.14159);
processValue([1, 2, 3, 4, 5]);
Вывод:
字符串转大写: HELLO 数字格式化: 3.14 数组长度: 5
Совет:Ключ к пользовательской защите типа — это возвращаемый тип
value is Type, который является маркером, используемым TypeScript для определения защиты типа.
Защита типа с помощью оператора in
Оператор in может проверить, содержит ли объект определённое свойство.
Используя in в условных проверках, TypeScript автоматически сужает область типа объекта.
Использование оператора in
interface A {
a: string; // Имеет только свойство a
}
interface B {
b: number; // Имеет только свойство b
}
// Функция, принимающая тип объединения
function process(obj: A | B): void {
// Используйте in, чтобы проверить, содержит ли объект свойство "a"
if ("a" in obj) {
// В ветке if TypeScript знает, что obj содержит свойство a
// Поэтому тип obj сужается до A
console.log("Свойство a объекта A: " + obj.a);
} else {
// В ветке else obj не содержит свойства a
// TypeScript знает, что obj может быть только типа B
// Поэтому можно безопасно обратиться к свойству b
console.log("Свойство b объекта B: " + obj.b);
}
}
// Тестовые вызовы
process({ a: "hello" }); // Передайте объект, содержащий свойство a
process({ b: 42 }); // Передайте объект, содержащий свойство b
Результат выполнения:
A 的属性 a: hello B 的属性 b: 42
Размеченные объединения и защитники типов
Размеченное объединение — это мощный шаблон, который различает элементы объединённого типа с помощью общего свойства "дискриминант".
В сочетании с операторами switch или проверками if можно реализовать полноценные защитники типов.
Реализация калькулятора с размеченными объединениями
interface Circle {
kind: "circle"; // Поле-дискриминант: значение — "circle"
radius: number; // радиус
}
// Определим интерфейс Rectangle
interface Rectangle {
kind: "rectangle"; // Поле-дискриминант: значение — "rectangle"
width: number; // ширина
height: number; // высота
}
// Определим интерфейс Triangle
interface Triangle {
kind: "triangle"; // Поле-дискриминант: значение — "triangle"
base: number; // base
height: number; // высота
}
// Определяем объединённый тип
type Shape = Circle | Rectangle | Triangle;
// Функция для вычисления площади
function getArea(shape: Shape): number {
// Используйте оператор switch для защиты типов
// На основе значения свойства kind TypeScript автоматически сужает тип
switch (shape.kind) {
case "circle":
// shape сужается до типа Circle
// Можно получить доступ к свойству radius
return Math.PI * shape.radius ** 2;
case "rectangle":
// shape сужается до типа Rectangle
// Можно получить доступ к свойствам width и height
return shape.width * shape.height;
case "triangle":
// shape сужается до типа Triangle
return 0.5 * shape.base * shape.height;
}
}
// Тестовые вызовы
var circle = { kind: "circle" as const, radius: 5 };
var rectangle = { kind: "rectangle" as const, width: 4, height: 6 };
var triangle = { kind: "triangle" as const, base: 3, height: 4 };
console.log("Площадь круга: " + getArea(circle).toFixed(2));
console.log("Площадь прямоугольника: " + getArea(rectangle));
console.log("Площадь треугольника: " + getArea(triangle));
Результат выполнения:
圆形面积: 78.54 矩形面积: 24 三角形面积: 6
Примечание:Размеченные объединения — один из наиболее рекомендуемых паттернов в TypeScript. Они различают разные члены типа через общее литеральное свойство (обычно kind или type), делая код одновременно типобезопасным и простым в поддержке.
Проверки null и undefined
При работе со значениями, которые могут быть null или undefined, прямые проверки на равенство также являются эффективными защитниками типов.
Проверка на null
function getLength(str: string | null): number {
// Напрямую проверяем, что str не равен null
// Когда условие истинно, TypeScript знает, что str не равен null
// На этом этапе можно безопасно обращаться к свойствам str
if (str !== null) {
return str.length;
}
// Обработка случая null
return 0;
}
// Тестовые вызовы
console.log(getLength("hello")); // Обычная строка
console.log(getLength(null)); // Передаём null
Результат выполнения:
5 0
Совет:После включения strictNullChecks рекомендуется всегда выполнять проверки на null. Для упрощения кода можно использовать опциональную цепочку (?.) и оператор нулевого слияния (??).
Сужение по истинности
Помимо явных проверок типов, TypeScript также сужает диапазоны типов с помощью проверок на истинность.
Сужение по истинности
function greet(name?: string): string {
// Используйте оператор короткого замыкания: если name равно undefined или является пустой строкой, используйте значение по умолчанию
// В блоке кода после && TypeScript знает, что name должен иметь значение
return name && "Hello, " + name;
}
// Тест
console.log(greet("EXAMPLE"));
console.log(greet());
Результат выполнения:
Hello, EXAMPLE Hello, undefined
Важные замечания
- Защитники типа должны использоваться в условных ветвях:Только после использования защитника типа для условной проверки TypeScript выполнит сужение типа.
- Тип возвращаемого значения должен быть предикатом типа:Тип возвращаемого значения пользовательского защитника типа должен быть
value is Typeformat - Размеченные объединения — лучшая практика:Для сложных union-типов рекомендуется использовать шаблон размеченного объединения.
- Обратите внимание на полноту сужения типов:При использовании операторов switch рекомендуется обрабатывать все возможные ветви.
Рекомендация:При работе с union-типами отдавайте предпочтение шаблону размеченного объединения. Он не только делает код понятнее, но и полностью задействует возможности вывода типов TypeScript.
Итог
Защитники типа — важная часть системы типов TypeScript.
- typeof:Самый распространённый способ, подходящий для проверки примитивных типов.
- instanceof:Проверяет, является ли объект экземпляром определённого класса.
- Пользовательские защиты:С помощью
value is Typeсинтаксиса можно реализовать гибкие проверки типов. - in:Проверяет, содержит ли объект определенное свойство.
- Размеченные объединения:Рекомендуемый шаблон лучшей практики, различающий типы с помощью полей-дискриминантов.
- Сужение по истинности:Используйте проверки истинности JavaScript для сужения типов.