M

MLOG

Русский

Изучите защиту типов и утверждения типов в TypeScript, чтобы повысить типобезопасность, предотвратить ошибки во время выполнения и писать более надежный и удобный в обслуживании код.

Обеспечение типобезопасности: полное руководство по защите типов и утверждениям типов

В области разработки программного обеспечения, особенно при работе с языками с динамической типизацией, такими как JavaScript, обеспечение типобезопасности может быть серьезной проблемой. TypeScript, надмножество JavaScript, решает эту проблему, представляя статическую типизацию. Однако даже с системой типов TypeScript возникают ситуации, когда компилятору требуется помощь в выводе правильного типа переменной. Именно здесь в игру вступают защита типов и утверждения типов. Это полное руководство углубится в эти мощные функции, предоставив практические примеры и лучшие практики для повышения надежности и удобства обслуживания вашего кода.

Что такое защита типов?

Защита типов — это выражения TypeScript, которые сужают тип переменной в определенной области видимости. Они позволяют компилятору более точно понимать тип переменной, чем он изначально вывел. Это особенно полезно при работе с объединениями типов или когда тип переменной зависит от условий во время выполнения. Используя защиту типов, вы можете избежать ошибок во время выполнения и написать более надежный код.

Общие методы защиты типов

TypeScript предоставляет несколько встроенных механизмов для создания защиты типов:

Использование typeof

Оператор typeof — это простой способ проверить примитивный тип переменной. Он возвращает строку, указывающую тип.

function printValue(value: string | number) {
  if (typeof value === "string") {
    console.log(value.toUpperCase()); // TypeScript знает, что 'value' - это строка здесь
  } else {
    console.log(value.toFixed(2)); // TypeScript знает, что 'value' - это число здесь
  }
}

printValue("hello"); // Вывод: HELLO
printValue(3.14159); // Вывод: 3.14

Использование instanceof

Оператор instanceof проверяет, является ли объект экземпляром определенного класса. Это особенно полезно при работе с наследованием.

class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

class Dog extends Animal {
  bark() {
    console.log("Woof!");
  }
}

function makeSound(animal: Animal) {
  if (animal instanceof Dog) {
    animal.bark(); // TypeScript знает, что 'animal' - это Dog здесь
  } else {
    console.log("Generic animal sound");
  }
}

const myDog = new Dog("Buddy");
const myAnimal = new Animal("Generic Animal");

makeSound(myDog); // Вывод: Woof!
makeSound(myAnimal); // Вывод: Generic animal sound

Использование in

Оператор in проверяет, имеет ли объект определенное свойство. Это полезно при работе с объектами, которые могут иметь разные свойства в зависимости от их типа.

interface Bird {
  fly(): void;
  layEggs(): void;
}

interface Fish {
  swim(): void;
  layEggs(): void;
}

function move(animal: Bird | Fish) {
  if ("fly" in animal) {
    animal.fly(); // TypeScript знает, что 'animal' - это Bird здесь
  } else {
    animal.swim(); // TypeScript знает, что 'animal' - это Fish здесь
  }
}

const myBird: Bird = { fly: () => console.log("Flying"), layEggs: () => console.log("Laying eggs") };
const myFish: Fish = { swim: () => console.log("Swimming"), layEggs: () => console.log("Laying eggs") };

move(myBird); // Вывод: Flying
move(myFish); // Вывод: Swimming

Пользовательские функции защиты типов

Для более сложных сценариев вы можете определить свои собственные функции защиты типов. Эти функции возвращают предикат типа, который представляет собой логическое выражение, которое TypeScript использует для сужения типа переменной. Предикат типа имеет форму variable is Type.

interface Square {
  kind: "square";
  size: number;
}

interface Circle {
  kind: "circle";
  radius: number;
}

type Shape = Square | Circle;

function isSquare(shape: Shape): shape is Square {
  return shape.kind === "square";
}

function getArea(shape: Shape) {
  if (isSquare(shape)) {
    return shape.size * shape.size; // TypeScript знает, что 'shape' - это Square здесь
  } else {
    return Math.PI * shape.radius * shape.radius; // TypeScript знает, что 'shape' - это Circle здесь
  }
}

const mySquare: Square = { kind: "square", size: 5 };
const myCircle: Circle = { kind: "circle", radius: 3 };

console.log(getArea(mySquare)); // Вывод: 25
console.log(getArea(myCircle)); // Вывод: 28.274333882308138

Что такое утверждения типов?

Утверждения типов — это способ сказать компилятору TypeScript, что вы знаете больше о типе переменной, чем он понимает в данный момент. Это способ переопределить вывод типов TypeScript и явно указать тип значения. Однако важно использовать утверждения типов с осторожностью, поскольку они могут обойти проверку типов TypeScript и потенциально привести к ошибкам во время выполнения, если используются неправильно.

Утверждения типов имеют две формы:

Ключевое слово as обычно предпочтительнее, потому что оно более совместимо с JSX.

Когда использовать утверждения типов

Утверждения типов обычно используются в следующих сценариях:

Примеры утверждений типов

Явное утверждение типа

В этом примере мы утверждаем, что вызов document.getElementById вернет HTMLCanvasElement. Без утверждения TypeScript выведет более общий тип HTMLElement | null.

const canvas = document.getElementById("myCanvas") as HTMLCanvasElement;
const ctx = canvas.getContext("2d"); // TypeScript знает, что 'canvas' - это HTMLCanvasElement здесь

if (ctx) {
  ctx.fillStyle = "#FF0000";
  ctx.fillRect(0, 0, 150, 75);
}

Работа с неизвестными типами

При работе с данными из внешнего источника, такого как API, вы можете получать данные с неизвестным типом. Вы можете использовать утверждение типа, чтобы сообщить TypeScript, как обрабатывать данные.

interface User {
  id: number;
  name: string;
  email: string;
}

async function fetchUser(id: number): Promise<User> {
  const response = await fetch(`https://jsonplaceholder.typicode.com/users/${id}`);
  const data = await response.json();
  return data as User; // Утвердить, что данные - это User
}

fetchUser(1)
  .then(user => {
    console.log(user.name); // TypeScript знает, что 'user' - это User здесь
  })
  .catch(error => {
    console.error("Error fetching user:", error);
  });

Предостережения при использовании утверждений типов

Утверждения типов следует использовать умеренно и с осторожностью. Чрезмерное использование утверждений типов может скрыть основные ошибки типов и привести к проблемам во время выполнения. Вот некоторые ключевые моменты:

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

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

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

Пример сужения типов

function processValue(value: string | number | null) {
  if (value === null) {
    console.log("Value is null");
  } else if (typeof value === "string") {
    console.log(value.toUpperCase()); // TypeScript знает, что 'value' - это строка здесь
  } else {
    console.log(value.toFixed(2)); // TypeScript знает, что 'value' - это число здесь
  }
}

processValue("test"); // Вывод: TEST
processValue(123.456); // Вывод: 123.46
processValue(null); // Вывод: Value is null

Лучшие практики

Чтобы эффективно использовать защиту типов и утверждения типов в своих проектах TypeScript, примите во внимание следующие лучшие практики:

Международные соображения

При разработке приложений для глобальной аудитории учитывайте, как защита типов и утверждения типов могут повлиять на усилия по локализации и интернационализации (i18n). В частности, учитывайте следующее:

Заключение

Защита типов и утверждения типов — важные инструменты для повышения типобезопасности и написания более надежного кода TypeScript. Понимая, как эффективно использовать эти функции, вы можете предотвращать ошибки во время выполнения, улучшить удобство обслуживания кода и создавать более надежные приложения. Помните, что следует отдавать предпочтение защите типов, а не утверждениям типов, когда это возможно, документировать свои утверждения типов и проверять внешние данные, чтобы обеспечить точность вашей информации о типах. Применение этих принципов позволит вам создавать более стабильное и предсказуемое программное обеспечение, пригодное для развертывания во всем мире.

Обеспечение типобезопасности: полное руководство по защите типов и утверждениям типов | MLOG