← Назад к блогу

Вы настоящий TypeScript-разработчик, только если...

TypeScript предотвращает 38% ошибок, но только если вы настроили его правильно. Вот чек-лист привычек разработчика

Вы настоящий TypeScript-разработчик, только если...

Большинство команд, которые «используют TypeScript», на самом деле пишут JavaScript с аннотациями типов, рассыпанными сверху. Компилятор работает, сборка проходит, и тем не менее баги в продакшене продолжают появляться с той же частотой, что и раньше, — что поднимает неудобный вопрос о том, что же на самом деле дала миграция.

Разница измеряется деньгами, а не идеологией. Когда Airbnb проанализировали шесть месяцев пост-мортемов, они обнаружили, что 38% багов, дошедших до продакшена, могли быть предотвращены TypeScript — но только TypeScript, используемым правильно, когда компилятору действительно позволено делать свою работу. Наполовину настроенная конфигурация даёт лишь долю этой защиты, при этом по-прежнему обходясь в полную цену в виде инструментов сборки и кривой обучения.

Итак, вот чек-лист. Не викторина по utility-типам — а привычки, которые определяют, работает ли система типов на бизнес или просто украшает кодовую базу.

1. ...Вы работаете со strict: true и никогда его не выключали

Это самый главный водораздел. TypeScript без строгого режима — это система вежливости: она предлагает рекомендации, код их игнорирует, все идут дальше. Со strict: true компилятор принудительно выполняет две проверки, которые ловят больше всего реальных багов:

  • strictNullChecks — каждое значение, которое может быть null или undefined, должно быть обработано перед использованием. Тони Хоар, который изобрёл null-ссылку, назвал её своей «ошибкой на миллиард долларов» — это его оценка совокупной стоимости связанных с null падений по всей индустрии. Строгие проверки на null устраняют весь этот класс багов на этапе компиляции.
  • noImplicitAny — ни одно значение не ускользает из системы типов незаметно.

Проще говоря: нестрогий TypeScript-проект — это JavaScript-проект с более длинными расширениями файлов.

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

Что это значит для вашего проекта: если подрядчик сдаёт «кодовую базу на TypeScript», откройте tsconfig.json прежде, чем её принять. "strict": true должно быть первым, что вы увидите. Его отсутствие — это замечание в акте приёмки, а не вопрос вкуса.

2. ...any вызывает у вас дискомфорт

Каждый any — это дыра, прорезанная в страховочной сетке. Компилятор перестаёт проверять всё, что через неё проходит, — а небезопасность типов заразна: один any, возвращённый из функции получения данных, незаметно отключает проверку в каждом компоненте, который их потребляет.

Настоящий TypeScript-разработчик тянется к честным альтернативам:

  • unknown — когда тип действительно ещё неизвестен: он заставляет выполнить проверку перед использованием вместо того, чтобы разрешать всё подряд.
  • Суженный union ("pending" | "active" | "closed") — когда значение имеет фиксированный набор форм.
  • Дженерики — когда тип варьируется, но следует закономерности.

Линт-правило @typescript-eslint/no-explicit-any превращает это из личной добродетели в стандарт команды. Команды, допускающие небрежное использование any, обычно узнают его цену во время рефакторингов: переименовываешь поле, компилятор сообщает ноль ошибок, а сломанные экраны всплывают в продакшене один за другим в течение следующих недель.

Честно говоря: редкий, прокомментированный any на действительно нетипизируемой границе — легаси-библиотека без определений типов, быстрый прототип — это разумный инженерный компромисс. Пятьдесят непрокомментированных any, разбросанных по бизнес-логике, — это JavaScript-кодовая база в маскарадном костюме.

3. ...Вы валидируете на границах, потому что знаете: типы стираются в рантайме

Это концептуальный тест, который отделяет людей, понимающих TypeScript, от людей, которые на нём пишут. Типы не существуют в работающем приложении. Они стираются при компиляции. Объявить ответ API как interface User { email: string } — это обещание, которое даёт разработчик: компилятор проверяет код на соответствие этому обещанию, но ничто не проверяет само обещание на соответствие реальности.

Когда бэкенд меняет поле, переименовывает email в emailAddress или возвращает объект ошибки вместо пользователя, аннотация типа не делает ничего. Данные втекают с неверным типом, и сбой проявляется где-то далеко от причины — классическое «undefined is not a function» тремя слоями глубже.

Настоящие TypeScript-разработчики валидируют на каждой границе, где данные входят в систему: ответы API, payload'ы вебхуков, ввод форм, переменные окружения, всё, что читается из хранилища. Библиотеки рантайм-валидации вроде Zod делают это почти бесплатным: определяете схему один раз — получаете и проверку в рантайме, и выведенный из неё статический тип. Один источник истины вместо двух, которые расходятся со временем.

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

4. ...Вы позволяете компилятору выводить типы возвращаемых значений (а публичные API типизируете явно)

Две привычки, которые выглядят противоречиво, но таковыми не являются:

  • Внутри модуля полагайтесь на вывод типов. Аннотирование каждой локальной переменной добавляет шум, не добавляя безопасности — компилятор и так знает.
  • На публичных границах — экспортируемые функции, общие утилиты, точки входа библиотек — пишите явные типы возвращаемых значений. Выведенный тип возврата меняется молча, когда меняется реализация; явный превращает то же изменение в ошибку компиляции в месте причины, а не в непонятную ошибку в каждом месте вызова.

Это принцип инструкции LEGO: внутри одного шага сборки никому не нужны ярлыки на каждой детали. Но точки соединения между блоками требуют точных спецификаций, потому что именно там присоединяется работа других людей.

5. ...Вы делаете недопустимые состояния непредставимыми

TypeScript-разработчик среднего уровня типизирует то, как данные выглядят. Настоящий — типизирует то, какими данным разрешено быть. Сравните:

  • Состояние запроса как { loading: boolean; data?: User; error?: string } — что технически допускает loading: true с одновременно присутствующими data и error: состояние, которое не значит ничего.
  • Дискриминированный union: { status: "loading" } | { status: "success"; data: User } | { status: "error"; error: string } — где бессмысленное состояние вообще невозможно сконструировать.

Вторая версия удаляет целую категорию защитных if-проверок и баги, живущие между ними. Компилятор к тому же обеспечивает исчерпывающую обработку: добавьте четвёртый статус — и каждый switch, который его не обрабатывает, станет ошибкой компиляции. Список задач, сгенерированный автоматически, с файлами и номерами строк.

Реальные цифры: это именно тот класс багов, который стоит за значительной долей предотвратимых TypeScript находок Airbnb — значения присутствуют там, где не должны, и отсутствуют там, где код предполагал их наличие. Моделирование состояний через union'ы переносит стоимость этих багов из продакшен-инцидентов (часы, дежурства, влияние на клиентов) в ошибки компиляции (секунды, до коммита).

6. ...Ваши типы документируют предметную область, а не только синтаксис

function process(data: object): object компилируется. И при этом не говорит следующему разработчику ничего. Сравните с function applyDiscount(order: Order, discount: PercentDiscount): PricedOrder — читается как предложение, проверяется машиной, и её невозможно вызвать с перепутанными аргументами.

Именно здесь TypeScript окупается как система документации, которая не может устареть. README-файлы и вики-страницы описывают код таким, каким он был, когда их в последний раз редактировали; типы описывают код таким, какой он есть, с проверкой на каждой сборке. Для команд с ротацией — агентств, растущих стартапов, проектов, переходящих от подрядчика к подрядчику — это разница между онбордингом за два дня и за две недели. Новые разработчики исследуют предметную область через автодополнение, а не через археологию.

7. ...Вы воспринимаете ошибки компилятора как информацию, а не как препятствия

Характерные анти-паттерны разработчика, который борется с компилятором вместо того, чтобы им пользоваться:

  • as any, чтобы заглушить ошибку, не разобравшись в ней
  • // @ts-ignore, рассыпанный как приправа
  • Non-null assertions (!) на значениях, которые действительно могут быть null

Каждый из них говорит: «компилятор нашёл проблему, и в ответ компилятор уволили». Каждая подавленная ошибка — это баг-репорт, удалённый непрочитанным. Ошибка указывала на реальный пробел — необработанный случай, непроверенное предположение — и подавление гарантирует, что он будет обнаружен заново позже, в рантайме, пользователем.

Профессиональная реакция на непонятную ошибку компилятора — спросить, что компилятор знает такого, чего не знает код. Примерно в девяти случаях из десяти компилятор прав.

8. ...Вы знаете, когда TypeScript — неправильный ответ

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

Экономика переворачивается в тот момент, когда у кода появляется будущее: несколько контрибьюторов, горизонт поддержки дольше нескольких месяцев или бизнес-логика, где баги стоят реальных денег. Этот переворот происходит раньше, чем ожидает большинство команд, — обычно около второго разработчика или третьего месяца, смотря что наступит первым. Индустрия проголосовала соответственно: TypeScript входит в число самых используемых и самых любимых языков в Stack Overflow Developer Survey, а к 2024 году стал одним из трёх главных языков на GitHub — принятие, движимое экономикой сопровождения, а не модой.

Альтернативы и компромиссы, честно

JSDoc-аннотации + checkJs. Проверка типов без шага сборки — компилятор читает типы из комментариев в обычных .js-файлах. Эргономика слабее, но это легитимный путь для кодовых баз, которые не могут внедрить этап компиляции. Несколько крупных open-source проектов сознательно работают именно так.

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

Стоимость на этапе сборки. Проверка типов занимает реальное время на больших кодовых базах, а медленный CI — это реальные расходы. Ландшафт смягчающих мер быстро улучшается — нативный порт компилятора TypeScript от Microsoft нацелен примерно на 10-кратное ускорение проверки типов, — но сегодня стандартный паттерн таков: быстрая транспиляция (esbuild, swc) для dev-сборок с проверкой типов в виде параллельного шага CI. Проверка по-прежнему выполняется; она просто перестаёт блокировать внутренний цикл разработки.

Ключевые выводы для бизнеса:

  1. Внедрение TypeScript бинарно по стоимости, но градуировано по выгоде. Инструментарий, шаг сборки и последствия для найма стоят одинаково независимо от того, использует ли кодовая база строгий режим, — но предотвращение багов (того рода, что стоит за цифрой Airbnb в 38%) материализуется только при строгих проверках, отсутствии небрежных any и рантайм-валидации на границах. Платить полную цену за частичную защиту — самый распространённый сценарий провала.

  2. Аудит дёшев. Три проверки раскрывают реальную типовую дисциплину кодовой базы за десять минут: "strict": true в tsconfig, подсчёт вхождений any и @ts-ignore, и валидируются ли внешние данные в точках входа. Любой технический ревьюер может выполнить их перед передачей проекта или acqui-hire.

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

Вот что мы рекомендуем: не спрашивайте, «использует» ли команда TypeScript. Спросите, позволено ли компилятору говорить им «нет». Этот один ответ предсказывает частоту багов лучше, чем расширения файлов.

Статья подготовлена на основе открытых источников и может содержать неточности.

Читайте также

✦ВыжимкаAI
  1. Без `strict: true` TypeScript — это просто JavaScript с длинными расширениями файлов: компилятор даёт рекомендации, но не принуждает к безопасности. Только в строгом режиме достигается реальная защита — именно её Airbnb зафиксировал как потенциальное предотвращение 38% продакшн-багов.
  2. Небезопасность типов заразна: один `any`, возвращённый из функции получения данных, незаметно распространяется и отключает проверки во всей цепочке вниз — а не только в одном месте.
  3. TypeScript работает только на этапе компиляции, а в рантайме типы стираются — поэтому валидация на границах системы (внешние API, пользовательский ввод) обязательна независимо от того, насколько точны типы в коде.
  4. Принять кодовую базу «на TypeScript» без проверки `tsconfig.json` — ошибка: отсутствие `strict: true` — это содержательное замечание в акте приёмки, а не вопрос вкуса команды.

Powered by B1KEY