Babel и TypeScript. Выбираем подходящий компилятор

Babel 7 был выпущен в 2018 году, и с тех пор обновления позволили разработчикам использовать Babel и TypeScript без необходимости усложнять свои сборки с помощью компилятора TypeScript. Но в чем разница между использованием компиляторов Babel и TypeScript? И какой из них стоит использовать для своего следующего проекта? Разберемся в этой статье. Мы рассмотрим следующее:

• Что такое Babel?
• Общие сведения о компиляторе TypeScript
• Роль Babel в интеграции TypeScript
• Полифиллы с помощью Babel и TypeScript
• Различия между Babel и TypeScript
• Что выбрать: Babel или TypeScript?

Что такое Babel?

Babel — это широко используемый компилятор JavaScript, который позволяет разработчикам писать современный код JavaScript с использованием новейших возможностей ECMAScript, обеспечивая при этом совместимость со старыми браузерами и средами. По мере появления новых возможностей JavaScript не все браузеры поддерживают их сразу, что приводит к потенциальным проблемам совместимости для разработчиков, ориентированных на более широкую аудиторию. Babel решает эту проблему, преобразуя современный код JavaScript в более старую версию JavaScript, которая широко поддерживается в различных браузерах и средах. Этот процесс позволяет разработчикам использовать передовые языковые возможности без ущерба для совместимости.

Общие сведения о компиляторе TypeScript

Компилятор TypeScript, tsc, отвечает за преобразование кода TypeScript в простой JavaScript, который может быть выполнен браузерами или Node.js. Понимание того, как работает компилятор TypeScript и процесс компиляции, важно для разработчиков TypeScript для создания эффективного и безошибочного кода JavaScript. Ниже приведен обзор процесса компиляции.

• Ввод кода TypeScript: компилятор TypeScript принимает файлы исходного кода TypeScript (.ts) в качестве входных данных. Эти файлы содержат синтаксис, специфичный для TypeScript, включая аннотации статической типизации, интерфейсы, классы и другие функции языка TypeScript
• Лексический анализ (сканирование): Первым шагом в процессе компиляции является лексический анализ, также известный как сканирование. Компилятор TypeScript сканирует входной исходный код и разбивает его на отдельные токены (такие как ключевые слова, идентификаторы, литералы, операторы) с помощью процесса, называемого токенизацией
• Синтаксический анализ (парсинг): после токенизации компилятор TypeScript выполняет синтаксический анализ. Полученные токены используются для построения абстрактного синтаксического дерева (AST), представляющего иерархическую структуру кода TypeScript
• Семантический анализ (проверка типов): После создания AST компилятор TypeScript переходит к этапу семантического анализа, который включает в себя проверку типов. На этом этапе компилятор проверяет типы переменных, выражений и других элементов в коде на основе предоставленных аннотаций типов и выводимых типов
• Преобразование и генерация JavaScript: После успешной проверки типов компилятор TypeScript проходит фазу преобразования, где он применяет различные преобразования, оптимизации и транспиляции к AST. Компилятор TypeScript может выполнять такие операции, как удаление специфичного для TypeScript синтаксиса (например, аннотаций типов), преобразование расширенных функций TypeScript (например, декораторов) или транспиляция новых функций ECMAScript (например, async/await) в старые конструкции JavaScript для совместимости с различными браузерами и средами. Окончательным результатом фазы преобразования является новый AST, представляющий собой простой код JavaScript без каких-либо конструкций, специфичных для TypeScript
• Создание выходных данных (файлы JavaScript): преобразованный AST используется для создания файлов кода JavaScript (.js), соответствующих исходным файлам TypeScript. Компилятор TypeScript создает соответствующий .js файлы с транспилированным JavaScript-кодом
• Файлы деклараций (declaration files, .d.ts): Кроме того, компилятор TypeScript может также генерировать файлы объявлений (.d.ts) в процессе компиляции. Файлы объявлений предоставляют информацию о типах для внешних библиотек или модулей JavaScript, что позволяет разработчикам TypeScript беспрепятственно использовать их в своих проектах TypeScript.
• Выдача выходных данных: Наконец, компилятор TypeScript выдает сгенерированные файлы JavaScript (.js) и файлы объявлений (.d.ts) в качестве выходных данных. Теперь эти файлы готовы к запуску браузерами или Node.js

Роль Babel в интеграции TypeScript

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

Транспиляция

TypeScript предоставляет функции, которые могут не поддерживаться в старых браузерах или определенных средах. Babel действует как транспайлер, беря код TypeScript (со статической типизацией, декораторами и т. д.) и преобразуя его в эквивалентный код JavaScript. Процесс транспиляции гарантирует, что функции TypeScript преобразуются в синтаксис и конструкции, совместимые с целевой средой.

Совместимость со средствами сборки

Многие современные проекты JavaScript используют инструменты сборки, такие как Webpack, Rollup или Parcel, для объединения и оптимизации кода. Babel легко интегрируется с этими инструментами сборки, позволяя транспилировать код TypeScript и включать его в процесс сборки проекта. Разработчики могут использовать плагины Babel для тонкой настройки процесса транспиляции, делая его совместимым с конкретными потребностями и требованиями проекта.

Упрощение миграции

Babel помогает в постепенной миграции существующих JavaScript-проектов на TypeScript. Настроив Babel для транспиляции кода TypeScript, разработчики могут постепенно внедрять TypeScript в свои проекты, не переписывая всю кодовую базу сразу. Это позволяет разработчикам использовать проверку типов TypeScript и другие языковые функции в определенных частях проекта при переходе на TypeScript.

Поддержка React и JSX

Babel обычно используется в React.js разработке для поддержки синтаксиса JSX, который изначально не понимается браузерами. JSX позволяет разработчикам писать компоненты React более интуитивно. При использовании TypeScript с React - Babel обеспечивает правильную транспиляцию синтаксиса JSX в файлах TypeScript, что позволяет разработчикам писать компоненты JSX в среде TypeScript.

Кастомизация с помощью плагинов

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

Поддержка экспериментальных функций TypeScript

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

Полифиллы с помощью Babel и TypeScript

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

Автоматический полифиллинг Babel

Babel предоставляет автоматический механизм полифиллов с помощью пресета @babel/preset-env. Когда вы настраиваете Babel с помощью @babel/preset-env, он автоматически обнаруживает функциональность ECMAScript, используемые в вашем коде, и включает необходимые полифиллы только для функциональности, отсутствующих в целевой среде. Например, если вы используете в своем коде такую ES6 фичу, как Promise, а целевая среда не поддерживает ее, автоматический полифиллинг Babel будет включать минимальный и оптимизированный полифилл для Promise в выходной код. Такой подход гарантирует, что ваш код будет правильно работать в старых браузерах, в которых отсутствует встроенная поддержка Promise. Преимущество автоматического полифиллинга заключается в том, что он уменьшает размер выходного пакета, включая только необходимые полифиллы, что делает их применение более эффективным.

Подход TypeScript к полифиллингу

Сам по себе TypeScript не предоставляет встроенного полифиллинга, как Babel. TypeScript фокусируется на статической проверке типов и транспиляции, оставляя полифиллинг для отдельной обработки. Пользователи TypeScript обычно используют Babel как часть процесса сборки, а Babel заботится как о транспиляции, так и о полифиллах с помощью @babel/preset-env. Когда код TypeScript транспилируется Babel, в игру вступает механизм автоматического полифиллинга, гарантирующий, что все отсутствующие функции, необходимые для кода TypeScript, будут правильно заполнены. Кроме того, разработчики TypeScript часто используют другие инструменты, такие как core-js или @babel/polyfill, непосредственно для включения конкретных полифиллов в зависимости от потребностей проекта и целевых сред. Чтобы включить явные полифиллы в проект TypeScript, можно импортировать необходимые полифиллы в точке входа их приложения. Например:

import 'core-js'; // имопорт всех полифиллов core-js
// или
import 'core-js/features/promise'; // импорт полифилла только для Promise

Использование core-js или других библиотек полифиллов дает разработчикам больше контроля над тем, какие полифиллы включаются, и позволяет им настраивать поведение полифиллов.

Различия между Babel и TypeScript

Существует несколько существенных различий между использованием TypeScript и использованием TypeScript с Babel. Мы рассмотрим пять самых важных отличий.

Нет проверки типов в Babel

Babel не обращает внимания на причудливые типы TypeScript. Он просто выбрасывает их в мусорное ведро, не проверяя, что они выполняются. Приведенный ниже пример компилируется без каких-либо ошибок или предупреждений с помощью Babel, но не с помощью TypeScript:

const myCoolString : string = 9;

9 - это точно не строка. Удаление типов может быть отличным вариантом для быстрого прототипирования, когда вы хотите, чтобы код компилировался, даже если ваши типы не соответствуют действительности. Если вы пытаетесь что-то напечатать, в какой-то момент вы, вероятно, захотите проверить, что они правильные. К счастью, в этом нет ничего страшного. Вы можете либо позволить своему редактору позаботиться об этом, либо запустить tsc --noEmit, который проверяет типы вашего проекта без компиляции.

Babel не умеет делать const enums

По умолчанию TypeScript компилирует весь проект сразу, в то время как Babel компилирует только один файл за раз. Ранее это означало, что Babel не поддерживал функции TypeScript, требующие чтения нескольких файлов, такие как const enums. Однако это уже не так со времен Babel 7.15, который был выпущен в 2021 году. Это означает, что если вы используете последнюю версию Babel, вы сможете скомпилировать все допустимые кодовые базы TypeScript.

Декораторы и метаданные: у TypeScript есть преимущество

В настоящее время спецификация ECMAScript и TypeScript не совсем согласны с тем, как должны вести себя декораторы. Плагины Babel соответствуют спецификации ECMAScript, что означает, что Babel не компилирует декораторы так же, как это делает TypeScript. К счастью для нас, в Babel есть legacy режим для компиляции декораторов со старым поведением. Просто добавьте плагин Babel "@babel/plugin-proposal-decorators" с опцией legacy, установленной в true. Есть еще одна функция декораторов TypeScript, о которой мы должны поговорить: emitDecoratorMetadata. TypeScript обычно стирает всю информацию о типе, чтобы она не существовала во время выполнения. emitDecoratorMetadata — это функция, которая сохраняет типы для классов и методов, к которым применен декоратор. Наличие типа во время выполнения позволяет нам делать всевозможные причудливые вещи, такие как внедрение зависимостей и сопоставление типов TypeScript с типами в базе данных SQL. Эта функция достаточно интенсивно используется в этих двух областях, с такими библиотеками, как TypeORM, TypeGoose, inversifyJS и даже системой внедрения зависимостей Angular, зависящей от этой функции. Поскольку Babel не заботится о информации о типе, для этой функции требуется пользовательский плагин babel-plugin-transform-typescript-metadata. Добавление этого плагина вместе с plugin-proposal-decorators, о которых мы упоминали ранее, должно обеспечить Babel паритет функций с TypeScript в отношении декораторов.

Babel превосходно справляется с пользовательскими преобразованиями

Babel гораздо более расширяем, чем TypeScript. Существует множество плагинов, которые оптимизируют ваш код и помогают удалить неиспользуемые импорты, встроенные строки, константы и многое другое. В то время как TypeScript имеет свой собственный API Transformer, который позволяет выполнять пользовательские преобразования, экосистема Babel богаче выбором плагинов и гораздо более доступна. Если вам нужны пользовательские преобразования, вам нужно использовать Babel. Хорошая новость заключается в том, что большинство инструментов TypeScript позволяют использовать TypeScript, а затем пропустить код через Babel, чтобы получить лучшее из обоих миров. Но это, очевидно, сопряжено с дополнительными сложностями в вашей цепочке сборки.

TypeScript и Babel имеют схожую производительность

Сравнивать Babel и TypeScript с точки зрения производительности сложно и, вероятно, не даст вам полной картины. TypeScript, выполняющий проверку типов, определенно будет медленнее, чем Babel, потому что в него включены дополнительные шаги. Чтобы достичь примерно одинаковой скорости, вы можете смягчить это замедление, используя что-то вроде fork-ts-checker-webpack-plugin, который запускает компиляцию без типов в одном процессе и проверку типов в фоновом процессе. Конечно, любой, кто пытался настроить Webpack, знает, что цепочки инструментов JavaScript кажутся чрезвычайно сложными. У вас есть плагины карты исходного кода, кэширование, выбор между количеством потоков, которые вы должны использовать — список можно продолжать. Ни один простой бенчмарк не может учесть всю картину, но если вы ожидаете многократного увеличения производительности при использовании Babel по сравнению с компилятором TypeScript, вам придется искать прирост производительности в другом месте.

Что выбрать: Babel или TypeScript?

На данный момент TypeScript и Babel примерно равны по роли, которую они могут играть в цепочке сборки. Babel теперь имеет полную поддержку const enums, декораторов и метаданных декораторов. Единственный недостаток использования Babel заключается в том, что вам нужно будет запускать проверку типов как отдельный процесс. Если у вас уже есть конвейер сборки, который вам подходит, я не вижу веских причин для перехода. Однако, если вы начинаете работу над проектом, я, вероятно, склоняюсь к использованию компилятора TypeScript, возможно, через что-то вроде ts-loader. Затем, если вы обнаружите, что вам нужно какое-то преобразование, предоставляемое только Babel, вы можете передать транспилированный вывод TypeScript в Babel. На мой вкус, это слишком сложно, но никто никогда не говорил, что набор инструментов для сборки JavaScript прост.

Содержание туториала по TypeScript Предположим, что у нас есть функция padLeft.

function padLeft(padding: number | string, input: string): string {
  throw new Error('Not implemented yet!');
}

Если padding является числом, оно будет рассматриваться как количество пробелов, которые мы хотим добавить перед input. Если padding является строкой, он должен просто добавлять padding перед input. Давайте попробуем реализовать логику, когда в padLeft передается padding как число.

function padLeft(padding: number | string, input: string) {
  return ' '.repeat(padding) + input;

  // Argument of type 'string | number' is not assignable to parameter of type 'number'.
  // Type 'string' is not assignable to type 'number'.

  // Аргумент типа 'string | number' не может быть присвоен параметру типа 'number'.
  // Тип 'string' не может быть присвоен типу 'number'.
}

TypeScript предупреждает нас, что добавление string | number в number может не дать нам того, что мы хотим, и это правильно. Другими словами, мы не проверяли явно, является ли padding числом, и не обрабатываем случай, когда это строка, так что давайте сделаем это.

function padLeft(padding: number | string, input: string) {
  if (typeof padding === 'number') {
    return ' '.repeat(padding) + input;
  }
  return padding + input;
}

Если не считать добавленных нами аннотаций типов, этот TypeScript код выглядит как JavaScript. Идея состоит в том, что система типов TypeScript направлена на то, чтобы максимально упростить написание JavaScript кода, без необходимости лезть вон из кожи, чтобы обеспечить безопасность типов. Хотя это может показаться не таким уж большим делом, на самом деле в этом коде скрывается много работы со стороны TypeScript. Подобно тому, как TypeScript анализирует значения во время выполнения с использованием статических типов, он накладывает анализ типов на конструкции потока управления во время выполнения JavaScript, такие как if/else, тернарные условия, циклы, проверки на истинность и т.д., которые могут влиять на эти типы. В нашей проверке if TypeScript видит typeof padding === 'number' и понимает это как особую форму кода, называемую защитой типа (type guard). TypeScript следует возможным путям выполнения, которые наши программы могут использовать для анализа наиболее конкретного возможного типа значения в данной позиции. Он рассматривает эти специальные проверки (называемые защитой типов) и присвоения, а процесс уточнения типов до более конкретных, чем объявленные, называется сужением (narrowing). Во многих IDE мы можем наблюдать за изменением этих типов, и мы даже будем делать это в наших примерах.

function padLeft(padding: number | string, input: string) {
  if (typeof padding === 'number') {
    return ' '.repeat(padding) + input;
    // при наведении курсора на padding => (parameter) padding: number
  }
  return padding + input;
  // в этом случае при наведении курсора на padding => (parameter) padding: string
}

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

Защитник типов typeof

Как мы видели, JavaScript поддерживает оператор typeof, который может дать очень базовую информацию о типе значений, во время выполнения. TypeScript ожидает, что это вернет определенный набор строк:

• "string"
• "number"
• "bigint"
• "boolean"
• "symbol"
• "undefined"
• "object"
• "function"

Как мы видели в случае с padLeft, этот оператор довольно часто встречается в ряде библиотек JavaScript, и TypeScript может понимать его для сужения типов в разных ветках кода. В TypeScript проверка значения, возвращаемого typeof, является защитой типа. Поскольку TypeScript понимает как typeof работает с разными значениями, он знает о некоторых причудах в JavaScript. Например, обратите внимание, что в приведенном выше списке typeof не возвращает строку null. Рассмторим следующий пример:

function printAll(strs: string | string[] | null) {
  if (typeof strs === 'object') {
    for (const s of strs) {
      // Object is possibly 'null'.
      // Возможно, объект 'null'.
      console.log(s);
    }
  } else if (typeof strs === 'string') {
    console.log(strs);
  } else {
    // ничего не делать
  }
}

В функции printAll мы пытаемся проверить, является ли strs объектом, чтобы узнать, является ли он типом массива (сейчас самое время подчеркнуть, что массивы являются объектными типами в JavaScript). Но оказывается, что в JavaScript typeof null на самом деле вернет "object"! Это одна из тех досадных исторических случайностей. Пользователи с достаточным опытом могут не удивиться, но не все сталкивались с этим в JavaScript. К счастью, TypeScript сообщает нам, что strs был сужен только до string[] | null вместо просто string[].

Проверка на истинность (Truthiness narrowing)

В JavaScript мы можем использовать любое выражение в условных выражениях, операторах &&, ||, операторах if, логических отрицаниях (!) и т.д. Например, операторы if не ожидают, что их условие всегда будет иметь логический тип.

function getUsersOnlineMessage(numUsersOnline: number) {
  if (numUsersOnline) {
    return `There are ${numUsersOnline} online now!`;
  }
  return "Nobody's here. :(";
}

В JavaScript такие конструкции, как if, сначала "приводят" свои условия к булевым значениям, а затем выбирают свои ответвления в зависимости от того, является ли результат истинным или ложным. Такие значения, как

• 0
• NaN
• "" (пустая строка)
• 0n (bigint версия нуля)
• null
• undefined

приводятся к false, а другие значения приводятся к true. Вы всегда можете привести значения к логическим значениям, применив к ним функцию Boolean или используя более короткое двойное логическое отрицание. (Последний имеет преимущество - TypeScript выводит узкий литеральный логический тип true, в то время как в первом варианте выводится логический тип boolean.)

// оба варианта имеют значение 'true'
Boolean('hello'); // type: boolean, value: true
!!'world'; // type: true, value: true

Довольно популярно использовать такое поведение, особенно для защиты от таких значений, как null или undefined. В качестве примера попробуем использовать его для нашей функции printAll.

function printAll(strs: string | string[] | null) {
  if (strs && typeof strs === 'object') {
    for (const s of strs) {
      console.log(s);
    }
  } else if (typeof strs === 'string') {
    console.log(strs);
  }
}

Обратите внимание, что мы избавились от приведенной выше ошибки, проверив, является ли strs истинным. Это, по крайней мере, защищает нас от ужасных ошибок при запуске нашего кода, например:

TypeError: null is not iterable

// TypeError: null не перечисляемый

Имейте в виду, однако, что проверка истинности примитивов часто может быть подвержена ошибкам. В качестве примера рассмотрим другой вариант printAll.

function printAll(strs: string | string[] | null) {
  // !!!!!!!!!!!!!!!!
  //  Не делайте так!
  //  Продолжайте чтение
  // !!!!!!!!!!!!!!!!
  if (strs) {
    if (typeof strs === 'object') {
      for (const s of strs) {
        console.log(s);
      }
    } else if (typeof strs === 'string') {
      console.log(strs);
    }
  }
}

Мы обернули все тело функции в проверку на истинность, но у такой реализации есть недостаток: мы больше не можем правильно обрабатывать случай пустой строки. И также рассмотрим пример с !.

function multiplyAll(
  values: number[] | undefined,
  factor: number
): number[] | undefined {
  if (!values) {
    return values;
  } else {
    return values.map((x) => x * factor);
  }
}

Сужение при проверке на равенство (Equality narrowing)

TypeScript также использует операторы switch и проверки на равенство, такие как ===, !==, == и != для сужения типов. Например:

function example(x: string | number, y: string | boolean) {
  if (x === y) {
    // Мы можем вызвать любой строковый метод у 'x' или 'y'.
    x.toUpperCase();
    // (method) String.toUpperCase(): string

    y.toLowerCase();
    // (method) String.toLowerCase(): string
  } else {
    console.log(x);
    // (parameter) x: string | number

    console.log(y);
    // (parameter) y: string | boolean
  }
}

Когда мы проверили, что x и y равны в приведенном выше примере, TypeScript узнал, что их типы также должны быть равны. Поскольку string — это единственный общий тип, который могут принимать как x, так и y, TypeScript знает, что x и y должны быть строкой в первой ветви. Также работает проверка конкретных литеральных значений (в отличие от переменных). В разделе Проверка на истинность мы написали функцию printAll, которая была подвержена ошибкам, потому что случайно неправильно обрабатывала пустые строки. Вместо этого мы могли бы сделать специальную проверку, чтобы заблокировать значения null, и TypeScript по-прежнему корректно удалял бы null из типа strs.

function printAll(strs: string | string[] | null) {
  if (strs !== null) {
    if (typeof strs === 'object') {
      for (const s of strs) {
        // (parameter) strs: string[]
        console.log(s);
      }
    } else if (typeof strs === 'string') {
      console.log(strs);
      // (parameter) strs: string
    }
  }
}

Cлабые проверки равенства в JavaScript с помощью == и != также корректно сужаются. Если вы не знакомы, проверка того, действительно ли что-то == null, не только проверяет, является ли это именно значением null, но также проверяет, является ли оно потенциально undefined. То же самое относится и к == undefined: он проверяет, является ли значение null или undefined.

interface Container {
  value: number | null | undefined;
}

function multiplyValue(container: Container, factor: number) {
  // Удаляем 'null' и 'undefined' из типа.
  if (container.value != null) {
    console.log(container.value);
    // (property) Container.value: number

    // Теперь можно безопасно умножить 'container.value'.
    container.value *= factor;
  }
}

Сужение типов с оператором in

В JavaScript есть оператор для определения наличия у объекта свойства с указанным именем: оператор in. TypeScript учитывает это как способ сузить число возможных типов. Например, кодом: "value" in x, где "value" — строковый литерал, а x — тип объединения. Ветвь с true сужает типы x, которые имеют либо необязательное, либо обязательное свойство value, а ветвь false сужает типы, которые имеют необязательное или отсутствующее свойство value.

type Fish = { swim: () => void };
type Bird = { fly: () => void };

function move(animal: Fish | Bird) {
  if ('swim' in animal) {
    return animal.swim();
  }

  return animal.fly();
}

Повторим, что необязательные свойства будут существовать в обеих ветках, например, человек может и плавать (swim), и летать (fly) (с соответствующим снаряжением):

type Fish = { swim: () => void };
type Bird = { fly: () => void };
type Human = { swim?: () => void; fly?: () => void };

function move(animal: Fish | Bird | Human) {
  if ('swim' in animal) {
    animal;
    // (parameter) animal: Fish | Human
  } else {
    animal;
    // (parameter) animal: Bird | Human
  }
}

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

В JavaScript есть оператор для проверки того, является ли значение «экземпляром» другого значения. В JavaScript x instanceof Foo проверяет, содержится ли Foo.prototype в цепочке прототипов x. Более подробно вернемся к этой теме, когда перейдем к классам. Как вы могли догадаться, instanceof также является защитой типов, а TypeScript сужает типы в ветках, защищенных instanceof.

function logValue(x: Date | string) {
  if (x instanceof Date) {
    console.log(x.toUTCString());
    //(parameter) x: Date
  } else {
    console.log(x.toUpperCase());
    // (parameter) x: string
  }
}

Присваивания (Assignments)

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

let x = Math.random() < 0.5 ? 10 : 'hello world!';

let x: string | number;
x = 1;

console.log(x);
// let x: number

x = 'goodbye!';

console.log(x);
// let x: string

Обратите внимание, что каждое из этих присвоений допустимо. Несмотря на то, что наблюдаемый тип x изменился на number после нашего первого присваивания, мы по-прежнему могли присвоить x строку. Это связано с тем, что объявленный тип x — тип, с которого начинается x — это string | number, а присваиваемость всегда проверяется по объявленному типу. Если бы мы присвоили x значение boolean, мы бы увидели ошибку, поскольку это не было частью объявленного типа.

let x = Math.random() < 0.5 ? 10 : 'hello world!';

let x: string | number;
x = 1;

console.log(x);
// let x: number

x = true;
// Type 'boolean' is not assignable to type 'string | number'.
// Тип 'boolean' нельзя присвоить к типу 'string | number'.

console.log(x);
// let x: string | number

Анализ потока управления

До этого момента мы рассмотрели несколько основных примеров того, как TypeScript сужает типы ветках. Но на самом деле происходит нечто большее, чем просто обход каждой переменной и поиск защитников типов в if, while, условных выражениях и т.д. Например.

function padLeft(padding: number | string, input: string) {
  if (typeof padding === 'number') {
    return ' '.repeat(padding) + input;
  }
  return padding + input;
}

padLeft возвращает значение из своего первого блока if. TypeScript смог проанализировать этот код и увидеть, что остальная часть тела (return padding + input;) недостижима в случае, когда padding является числом. В результате удалось удалить number из типа padding (сужение от string | number до string) для остальной части функции. Этот анализ кода, основанный на достижимости, называется анализом потока управления (control flow analysis), и TypeScript использует этот анализ потока для сужения типов по мере того, как он сталкивается с защитой типов и присваиваниями. Когда переменная анализируется, поток управления может разделяться и объединяться снова и снова, и можно наблюдать, что эта переменная имеет разный тип в каждой точке.

function example() {
  let x: string | number | boolean;

  x = Math.random() < 0.5;

  console.log(x);
  // let x: boolean

  if (Math.random() < 0.5) {
    x = 'hello';
    console.log(x);
    // let x: string
  } else {
    x = 100;
    console.log(x);
    // let x: number
  }

  return x;
  // let x: string | number
}

Использование предикатов типа (type predicates)

До сих пор мы работали с существующими конструкциями JavaScript, чтобы сужать типы, однако иногда вам нужен более прямой контроль над тем, как типы меняются в вашем коде. Чтобы выразить определяемую пользователем защиту типа, нам просто нужно написать функцию, возвращаемый тип которой является предикатом типа:

function isFish(pet: Fish | Bird): pet is Fish {
  return (pet as Fish).swim !== undefined;
}

pet is Fish — наш предикат типа в этом примере. Предикат принимает форму parameterName is Type, где parameterName должно быть именем параметра из текущей сигнатуры функции. Каждый раз, когда isFish вызывается с некоторой переменной, TypeScript сужает эту переменную до этого конкретного типа, если исходный тип совместим.

// Теперь вызовы 'swim' и 'fly' - ок.
let pet = getSmallPet();

if (isFish(pet)) {
  pet.swim();
} else {
  pet.fly();
}

Обратите внимание, что TypeScript не только знает, что pet — это Fish в ветке if; он также знает, что в другой ветке у вас нет Fish, поэтому у вас должна быть Bird. Вы можете использовать защиту типа isFish для фильтрации массива Fish | Bird и получить массив состоящий из Fish:

const zoo: (Fish | Bird)[] = [getSmallPet(), getSmallPet(), getSmallPet()];
const underWater1: Fish[] = zoo.filter(isFish);
// или, тоже самое
const underWater2: Fish[] = zoo.filter(isFish) as Fish[];

// Предикат может нуждаться в повторении для более сложных примеров.
const underWater3: Fish[] = zoo.filter((pet): pet is Fish => {
  if (pet.name === 'sharkey') return false;
  return isFish(pet);
});

Исключающие объединения (discriminated unions)

Большинство примеров, которые мы рассмотрели ранее, были сосредоточены на сужении одиночных переменных с помощью простых типов, таких как string, boolean и number. Однако, большую часть времени в JavaScript мы будем иметь дело с немного более сложными структурами. Представим, что мы пытаемся описать такие фигуры, как круги и квадраты. Круги отслеживают свои радиусы, а квадраты отслеживают длины своих сторон. Мы будем использовать поле под названием kind, чтобы указать, с какой формой мы имеем дело. Вот первая реализация Shape.

interface Shape {
  kind: 'circle' | 'square';
  radius?: number;
  sideLength?: number;
}

Обратите внимание, что мы используем объединение типов строковых литералов: "circle" и "square". Используя "circle" | "square" вместо string, мы можем избежать проблем с орфографическими ошибками.

function handleShape(shape: Shape) {
  // "rect" не входит в "circle"` или `"square"
  if (shape.kind === 'rect') {
    // This condition will always return 'false' since the types '"circle" | "square"' and '"rect"' have no overlap.
    // Это условие всегда будет возвращать 'false', так как типы '"circle" | "square"' и '"rect"' не пересекаются.
    // ...
  }
}

Мы можем написать функцию getArea, которая применяет правильную логику в зависимости от того, имеет ли она дело с кругом или квадратом. Сначала попробуем разобраться с кругами.

function getArea(shape: Shape) {
  return Math.PI * shape.radius ** 2;
  // Object is possibly 'undefined'.
  // Объект, возможно, 'undefined'.
}

В strictNullChecks это выдает ошибку, что уместно, поскольку радиус может быть не определен. Но что, если мы выполним соответствующие проверки свойства kind?

function getArea(shape: Shape) {
  if (shape.kind === 'circle') {
    return Math.PI * shape.radius ** 2;
    // Object is possibly 'undefined'.
    // Объект, возможно, 'undefined'.
  }
}

И здесь TypeScript не знает, что делать. Мы достигли точки, когда знаем о наших значениях больше, чем средство проверки типов. Мы могли бы попытаться использовать ненулевое утверждение (! после shape.radius), чтобы сказать, что радиус определенно присутствует.

function getArea(shape: Shape) {
  if (shape.kind === 'circle') {
    return Math.PI * shape.radius! ** 2;
  }
}

Но это выглядит не очень. Нам пришлось немного покричать на средство проверки типов с этими ненулевыми утверждениями (!), чтобы убедить его, что shape.radius был определен, но эти утверждения подвержены ошибкам, если мы начнем менять код. Кроме того, за пределами strictNullChecks мы все равно можем случайно получить доступ к любому из этих полей (поскольку предполагается, что необязательные свойства всегда присутствуют при их чтении). Мы определенно можем сделать лучше.

Проблема с этой реализацией Shape заключается в том, что средство проверки типов не может узнать, присутствуют ли radius или sideLength на основе свойства kind. Нам нужно сообщить то, что мы знаем, системе проверки типов. Имея это в виду, давайте еще раз обратимся к определению Shape.

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

interface Square {
  kind: 'square';
  sideLength: number;
}

type Shape = Circle | Square;

Здесь мы правильно разделили Shape на два типа с разными значениями свойства kind, но radius и sideLength объявлены как обязательные свойства в соответствующих типах. Давайте посмотрим, что здесь происходит, когда мы пытаемся получить доступ к радиусу Shape.

function getArea(shape: Shape) {
  return Math.PI * shape.radius ** 2;
  // Property 'radius' does not exist on type 'Shape'.
  // Свойство 'radius' не существует в типе 'Square'.
}

Как и в случае с нашим первой реализацией Shape, это все еще ошибка. Когда радиус был необязательным, мы получили ошибку (с включенной strictNullChecks), потому что TypeScript не мог определить, присутствует ли свойство. Теперь, когда Shape является объединением, TypeScript сообщает нам, что Shape может быть квадратом, а у квадратов не определен радиус! Обе интерпретации верны, но только объединенный тип Shape вызовет ошибку независимо от того, как настроен strictNullChecks. Но что, если мы попытаемся снова проверить свойство kind?

function getArea(shape: Shape) {
  if (shape.kind === 'circle') {
    return Math.PI * shape.radius ** 2;
    // (parameter) shape: Circle
  }
}

Мы избавилась от ошибки. Когда каждый тип в объединении содержит общее свойство с литеральными типами, TypeScript считает это исключающим объединением (discriminated union) и может сузить круг членов объединения. В данном случае это общее свойство было kind (это то, что считается дискриминантным свойством Shape). Проверка того, является ли свойство kind = "circle", избавляет от всех типов в Shape, которые не имеют свойства kind с типом "circle". Эта суженный shape до типа Circle. Та же проверка работает и с операторами switch. Теперь мы можем попытаться написать полную реализацию getArea без каких-либо ! ненулевых утверждений.

function getArea(shape: Shape) {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    // (parameter) shape: Circle

    case 'square':
      return shape.sideLength ** 2;
    // (parameter) shape: Square
  }
}

Передача правильной информации в TypeScript — что Circle и Square на самом деле были двумя отдельными типами с определенными полями kind — была крайне важна. Это позволяет нам писать типобезопасный код TypeScript. Кроме того, попробуйте поиграть с приведенным выше примером и удалить некоторые из возвращаемых ключевых слов. Вы увидите, что проверка типов может помочь избежать ошибок при случайном переходе через разные ветки в операторе switch. Исключающие объединения полезны не только для разделения кругов и квадратов. Они хороши для представления любой схемы обмена сообщениями в JavaScript, например, при отправке сообщений по сети (связь клиент-сервер) или для определения мутаций в библиотеках управления состоянием.

Тип never

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

Исчерпывающие проверки (Exhaustiveness checking)

Тип never присваивается каждому типу; однако никакому типу нельзя присвоить значение never (кроме самого never). Это означает, что вы можете использовать сужение и полагаться на never для выполнения исчерпывающих проверок в операторе switch. Например, добавление значения по умолчанию к нашей функции getArea, которая пытается присвоить форме значение never, будет выполняться, если все возможные случаи не были обработаны.

type Shape = Circle | Square;

function getArea(shape: Shape) {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    case 'square':
      return shape.sideLength ** 2;
    default:
      const _exhaustiveCheck: never = shape;
      return _exhaustiveCheck;
  }
}

Добавление нового члена в объединение Shape вызовет ошибку TypeScript:

interface Triangle {
  kind: 'triangle';
  sideLength: number;
}

type Shape = Circle | Square | Triangle;

function getArea(shape: Shape) {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    case 'square':
      return shape.sideLength ** 2;
    default:
      const _exhaustiveCheck: never = shape;
      // Type 'Triangle' is not assignable to type 'never'.
      // Тип 'Triangle' нельзя присвоить типу 'never'.
      return _exhaustiveCheck;
  }
}