TypeScript: защитники типов

Type Guards — очень важный механизм сужения типов в TypeScript.

Они позволяют разработчикам использовать определённые проверки условий во время выполнения, чтобы компилятор TypeScript мог точно вывести конкретный тип переменной.

С помощью Type Guards мы можем безопасно обращаться к свойствам и методам конкретного типа внутри переменной объединённого типа.


Зачем нам нужны Type Guards?

В TypeScript переменная может быть объявлена как объединение нескольких типов.

Когда нам нужно выполнять разные операции в зависимости от конкретного типа, компилятор не может автоматически определить текущий конкретный тип.

Type Guards — ключевой механизм решения этой проблемы.

Объяснение концепции:Основной принцип Type Guards — «сужение типов». С помощью проверок условий TypeScript автоматически сужает объединённый тип до конкретного типа.


SVG-диаграмма: Поток защиты типов Background Title Type Guard - Type Narrowing Flow Left: Union Type Original Union Type string | number | boolean Arrow 1 typeof Middle: typeof string typeof === "string" Narrowed to string Arrow 2 Branch Right: Result Type determined Can access .length Bottom: Type Guard Types Type Guard Methods Method 1 typeof typeof x === "string" Primitive type Method 2 instanceof x instanceof Array Class instance Method 3 Custom guard x is String value is Type Method 4 in "prop" in x Property check Arrow markers

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: базовое использование

// Определяем класс Dog
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 можно реализовать полноценные защитники типов.

Реализация калькулятора с размеченными объединениями

// Определим интерфейс Circle, используя свойство kind в качестве дискриминанта
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

// Определяем параметр функции, который может быть 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 также сужает диапазоны типов с помощью проверок на истинность.

Сужение по истинности

// Строка, которая может быть undefined
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 для сужения типов.
Другие расширения