TypeScript победил без революции: как необязательные типы стали стандартом JavaScript-разработки
За десять лет TypeScript прошёл путь от экспериментальной надстройки над JavaScript до одного из самых востребованных языков программирования. Рост популярности почти в пять раз, поддержка крупнейших фреймворков, появление Deno и Bun, интеграция в Node.js и новый компилятор на Go. Как технология, которая когда-то казалась необязательной, стала основой современной веб-разработки — и почему искусственный интеллект только ускорил этот процесс.

Когда TypeScript был просто удобной надстройкой
Если вспомнить JavaScript-разработку 2017–2018 годов, она выглядела совершенно иначе.
Node.js уже активно использовался для серверной разработки. React набирал популярность, Vue предлагал более простой подход к интерфейсам, а Angular воспринимался как серьёзный инструмент для больших приложений.
TypeScript к тому моменту тоже существовал далеко не первый год. На нём уже можно было полноценно разрабатывать приложения: описывать интерфейсы, использовать обобщённые типы, контролировать аргументы функций, возвращаемые значения и структуру объектов.
Для разработчика, которому просто хотелось писать более предсказуемый JavaScript, всего этого было достаточно.
В этом и заключается любопытный момент. Если сравнить повседневную разработку на TypeScript в 2018 и 2026 годах, фундаментальной разницы можно даже не заметить. Те же интерфейсы, те же типы, те же классы, та же проверка кода перед запуском.
Разумеется, язык развивался. Выходили новые версии, улучшался анализ типов, появлялись дополнительные возможности. Но большинство изменений не выглядели настолько значительными, чтобы перевернуть представление о программировании.
И всё же за это время произошло нечто гораздо более важное.
TypeScript перестал быть инструментом, который разработчик специально выбирает. Для значительной части современной JavaScript-разработки он превратился в исходную точку.
Как мы к этому пришли?
2012–2016: Microsoft предлагает типизированный JavaScript
История TypeScript началась 1 октября 2012 года, когда Microsoft публично представила первую версию языка.
Идея была достаточно прагматичной: JavaScript прекрасно подходил для создания веб-приложений, однако поддерживать большие проекты с сотнями тысяч строк динамически типизированного кода становилось всё сложнее.
Microsoft не собиралась создавать замену JavaScript с собственной виртуальной машиной или принципиально другой моделью выполнения.
Вместо этого компания предложила расширить существующий язык системой статической типизации, сохранив совместимость с его экосистемой.
Разработчик мог использовать привычный JavaScript, постепенно добавлять типы и получать обыкновенный JavaScript после компиляции.
В апреле 2014 года вышел TypeScript 1.0. К этому моменту язык уже поддерживал интерфейсы, классы, модули и обобщённые типы.
Но важнейшим событием ранней истории TypeScript стал вовсе не очередной релиз компилятора.
В марте 2015 года Microsoft объявила о сотрудничестве с командой Angular. Будущий Angular 2 должен был разрабатываться на TypeScript.
Это был серьёзный поворот.
Один из крупнейших фронтенд-фреймворков фактически сделал TypeScript основой своей архитектуры. Для множества разработчиков знакомство с языком происходило уже не из любопытства, а потому, что его использовал выбранный технологический стек.
Следующий важный шаг состоялся в сентябре 2016 года с выходом TypeScript 2.0.
В язык пришли полноценные проверки null и undefined, расширенный анализ потока управления и дискриминированные объединения типов. Именно тогда TypeScript стал гораздо лучше понимать не только объявленные типы переменных, но и то, как эти типы изменяются в зависимости от выполняемого кода.
Параллельно развивалась инфраструктура деклараций типов.
Проект DefinitelyTyped позволял сообществу описывать типы для обычных JavaScript-библиотек, а появление пакетов @types сделало их установку через npm привычной операцией.
Это решало одну из главных проблем любого нового языка: совместимость с уже существующим программным обеспечением.
Разработчикам не требовалось отказываться от npm, менять любимые библиотеки или переписывать приложения с нуля.
TypeScript мог использовать всё, что уже существовало в JavaScript, постепенно добавляя преимущества типизации.
2017–2019: развитие, которое легко было не заметить
К 2017 году TypeScript уже обладал практически всеми базовыми возможностями, с которыми его ассоциируют сегодня.
Однако внутри языка продолжалась довольно масштабная работа.
В TypeScript 2.1 появились keyof, индексированные и отображаемые типы. В версии 2.8 добавили условные типы. TypeScript 3.0, выпущенный летом 2018 года, принёс ссылки между проектами, улучшенную работу с кортежами и тип unknown.
Позднее появились новые способы вывода типов, дополнительные проверки и улучшения редакторских инструментов.
С точки зрения обычного разработчика всё это могло выглядеть довольно скучно.
Очередная версия TypeScript научилась точнее определять тип переменной после проверки условия. Следующая — лучше анализировать возвращаемое значение функции. Ещё одна — понимать сложные зависимости между типами.
Но именно здесь скрывалась главная работа.
Представим функцию, принимающую объект, который может описывать успешный результат операции или ошибку.
После проверки if (result.ok) TypeScript способен определить, какой именно вариант объекта находится внутри условия, и разрешить доступ только к соответствующим свойствам.
Подобный анализ называется narrowing, или сужением типов.
Для разработчика это просто удобное автодополнение и отсутствие лишних ошибок. Для сложной системы — возможность автоматически проверять связи между различными частями программы.
Со временем TypeScript научился описывать всё более сложные конструкции JavaScript, не заставляя программиста вручную указывать тип каждой переменной.
При этом типизация стала полезной не только в TypeScript-файлах. Языковой сервис TypeScript использовался для анализа JavaScript, обеспечивая автодополнение, навигацию по коду и рефакторинг в редакторах вроде Visual Studio Code.
Получилась интересная ситуация: даже разработчики, продолжавшие писать исключительно на JavaScript, постепенно начали пользоваться результатами развития TypeScript.
А сам язык становился всё более привлекательным для библиотек и фреймворков, которым требовалось точно описывать собственные API.
2020–2023: TypeScript становится частью экосистемы
В начале 2020-х годов TypeScript уже не нуждался в отдельном представлении.
Angular давно использовал его как основную технологию разработки. React получил полноценную экосистему типизированных компонентов и хуков. Next.js поддерживал TypeScript, а инструменты создания проектов всё чаще предлагали готовые TypeScript-шаблоны.
В сентябре 2020 года вышел Vue 3, внутренний код которого был переписан на TypeScript. Это улучшило типизацию публичных API и интеграцию с редакторами.
Позднее полноценная поддержка TypeScript закрепилась в экосистемах Svelte, Astro, Vite и других современных инструментов.
Причём дело было не только в возможности написать компонент с типами.
Разработчики библиотек начали проектировать API с учётом системы типов. Типизация стала способом документировать поведение функций, описывать допустимые параметры и обеспечивать предсказуемую интеграцию между пакетами.
Постепенно изменилась и сама логика выбора технологий.
Раньше разработчик создавал JavaScript-проект и при необходимости добавлял TypeScript.
Теперь всё чаще происходило наоборот: проект изначально создавался на TypeScript, а использование обычного JavaScript становилось осознанным решением.
Особенно сильно это проявлялось в командной разработке, где типы выполняли роль общего контракта между авторами различных модулей.
И важный момент: всё это произошло ещё до массового распространения AI-инструментов для генерации кода.
К моменту появления ChatGPT и стремительного развития GitHub Copilot TypeScript уже несколько лет уверенно рос.
Насколько сильно вырос TypeScript: цифры за десять лет
Оценить масштаб изменений позволяют ежегодные опросы Stack Overflow Developer Survey.
В них разработчики указывают языки программирования, которыми пользовались в течение предыдущего года.
| Год | Использовали TypeScript |
|---|---|
| 2017 | 9,4% |
| 2018 | 17,4% |
| 2019 | 21,2% |
| 2020 | 25,4% |
| 2021 | 30,2% |
| 2022 | 34,8% |
| 2023 | 38,9% |
| 2024 | 38,5% |
| 2025 | 43,6% |
| 2026 | 43,8% |
Источник: Stack Overflow Developer Survey — историческая статистика языков программирования.
Разница впечатляющая.
В 2017 году TypeScript использовали менее 10% опрошенных разработчиков. Уже в 2020 году — каждый четвёртый, а в 2026-м — почти 44%.
За девять лет доля увеличилась на 34,4 процентного пункта, или примерно в 4,7 раза.
Причём это не линейный рост. В 2018 году показатель практически удвоился, затем несколько лет увеличивался на 4–5 процентных пунктов ежегодно. В 2024 году наблюдалось небольшое снижение, за которым последовал новый скачок в 2025-м.
Разумеется, опросы не являются переписью всех программистов мира: состав участников меняется, и абсолютное количество пользователей языка из них напрямую вычислить нельзя.
Но многолетнюю тенденцию они показывают достаточно убедительно.
Ещё интереснее результаты специализированного State of JavaScript 2025.
Среди 10 934 участников, ответивших на вопрос о соотношении JavaScript и TypeScript, 4 367 человек сообщили, что пишут исключительно на TypeScript.
Это примерно 40% респондентов.
Для сравнения: исключительно JavaScript использовали около 6%.
А средняя доля TypeScript в коде, который писали участники опроса, достигла 77%.
Таким образом, среди активно вовлечённых в JavaScript-экосистему разработчиков TypeScript уже давно перестал быть второстепенным инструментом.
Он стал преобладающим способом написания JavaScript-приложений.
2025: TypeScript становится самым популярным языком на GitHub
Ещё один важный рубеж был пройден в августе 2025 года.
Согласно GitHub Octoverse 2025, TypeScript впервые занял первое место среди языков программирования по количеству активных контрибьюторов за месяц, обогнав Python и JavaScript.
За год количество разработчиков, работавших с TypeScript на GitHub, увеличилось более чем на миллион.
Рост составил 66,6% относительно августа 2024 года.
Для сравнения, JavaScript за тот же период прибавил около 24,8%, а Python — 48,8%.
Не менее показателен рост новых репозиториев. За период с сентября 2024 по август 2025 года на GitHub появилось около 5,39 млн репозиториев с TypeScript, а темп их создания в сравнении сопоставимых периодов вырос на 78,1%.
Важно понимать методику: первое место TypeScript относится именно к количеству контрибьюторов, а не к абсолютному числу репозиториев или всему написанному коду. По числу новых репозиториев JavaScript по-прежнему оставался впереди.
Но принципиального значения это уже не меняло.
Язык, который ещё несколько лет назад воспринимался как дополнительный инструмент для JavaScript, стал одним из главных центров разработки программного обеспечения.
И это произошло не благодаря появлению принципиально нового синтаксиса, а потому, что постепенно выросла целая экосистема, для которой TypeScript стал естественным выбором.
Deno, Bun и Node.js: когда компиляция перестала быть обязательным ритуалом
Ещё одним важным фактором распространения TypeScript стало развитие JavaScript-рантаймов.
Долгое время стандартный процесс выглядел достаточно просто: разработчик писал .ts-файлы, компилятор преобразовывал их в .js, и только после этого приложение запускалось в Node.js или браузере.
Однако постепенно этот промежуточный этап начал исчезать из повседневного взаимодействия с инструментами.
В мае 2020 года вышел Deno 1.0.
Одной из его главных особенностей стала встроенная поддержка TypeScript. Разработчик мог создать файл main.ts и выполнить его через deno run main.ts, не устанавливая отдельный транспилятор.
В сентябре 2023 года вышел Bun 1.0, который предложил похожий подход.
Bun объединил JavaScript-рантайм, транспилятор, пакетный менеджер, тестовый инструмент и сборщик в одной платформе.
TypeScript поддерживался сразу, без дополнительных зависимостей.
У обоих проектов были собственные архитектурные преимущества, но для TypeScript особенно важно другое: они сделали возможность непосредственного запуска .ts-файлов естественной частью среды выполнения.
Со временем к этому движению присоединился и Node.js.
В 2024 году Node.js 22.6 получил экспериментальную поддержку удаления типов, известную как type stripping. В начале 2025 года, начиная с Node.js 23.6, она стала доступна по умолчанию, а впоследствии получила стабильный статус.
Теперь Node.js может запускать TypeScript-файлы без предварительной ручной компиляции, если используемый синтаксис допускает простое удаление типов.
Разумеется, ограничения остались.
Встроенный механизм не выполняет полноценную проверку типов и не учитывает tsconfig.json. Также он не поддерживает конструкции, требующие генерации исполняемого JavaScript, например обычные enum, пространства имён с исполняемым кодом и свойства, объявленные непосредственно в параметрах конструктора.
Для полноценной работы с типами по-прежнему нужен TypeScript или совместимый инструмент проверки.
Однако сама необходимость запускать отдельный транспилятор ради простого TypeScript-файла во многих случаях исчезла.
Поддержка языка распространилась и на облачные платформы. Например, Cloudflare Workers позволяет разрабатывать воркеры на TypeScript, автоматически обрабатывая исходники через инструменты сборки.
При этом важно различать запуск TypeScript-исходников и выполнение TypeScript как отдельного языка.
В конечном счёте движки JavaScript по-прежнему исполняют JavaScript. Типы удаляются или исходный код преобразуется перед выполнением.
Но с точки зрения разработчика разница становится всё менее заметной.
Сегодня можно писать на TypeScript для браузера, Node.js, Deno, Bun, серверных API, облачных функций и edge-воркеров.
TypeScript больше не привязан к конкретному фреймворку или среде выполнения. Он стал универсальным языком разработки внутри JavaScript-экосистемы.
Искусственный интеллект закрепил победу TypeScript
С появлением современных AI-инструментов возник ещё один фактор, которого у TypeScript не было в первые десять лет существования.
Нейросети начали писать код.
Причём не только отдельные функции или небольшие примеры. Современные модели способны создавать целые компоненты, серверные обработчики, API, интеграции и значительные части приложений.
И здесь статическая типизация оказалась особенно полезной.
Когда разработчик пишет код самостоятельно, он обычно понимает предполагаемую структуру данных и взаимосвязи между функциями. Ошибки всё равно возникают, но значительная часть контекста остаётся у автора в голове.
С AI ситуация другая.
Модель генерирует реализацию на основании предоставленного контекста. Она может неправильно определить структуру ответа API, передать неподходящий аргумент, обратиться к несуществующему свойству или нарушить контракт между модулями.
В обычном JavaScript подобные проблемы могут оставаться незамеченными до выполнения соответствующего участка программы.
TypeScript позволяет обнаружить значительную часть таких несоответствий ещё до запуска приложения.
Более того, система типов создаёт удобную обратную связь для AI-агентов.
Модель генерирует код, компилятор сообщает о несовместимости типов, агент получает конкретные ошибки и может исправить реализацию.
Это не гарантирует правильности программы, но делает процесс генерации и проверки гораздо более управляемым.
Есть и другой эффект.
TypeScript уже давно широко используется в популярных фреймворках и библиотеках. Современные языковые модели хорошо знакомы с распространёнными паттернами JavaScript-экосистемы, включая типизированные компоненты React, серверные обработчики и описания API.
Возникает положительная обратная связь: популярный язык лучше представлен в доступных моделям примерах, AI-инструменты делают его использование удобнее, а разработчики получают дополнительные причины выбирать его для новых проектов.
GitHub в своём исследовании влияния AI на типизированные языки также связывает распространение AI-разработки с повышенным интересом к статической типизации.
При этом говорить, что именно нейросети сделали TypeScript популярным, было бы неправильно.
К началу массового внедрения генеративного AI язык уже занимал прочные позиции в индустрии.
Искусственный интеллект не создал эту тенденцию.
Он ускорил переход, который начался задолго до него.
И чем больше кода создаётся автоматически, тем важнее становятся инструменты, позволяющие проверять результат без необходимости вручную анализировать каждую строку.
TypeScript 7: новое поколение компилятора
Пока TypeScript превращался в стандарт JavaScript-разработки, у него постепенно возникала собственная проблема масштабирования.
Долгое время компилятор TypeScript разрабатывался на самом TypeScript и выполнялся на JavaScript-движке.
Для небольших проектов его производительности было достаточно. Но с ростом кодовых баз увеличивалось время проверки типов, потребление памяти и нагрузка на редакторы.
В марте 2025 года Microsoft представила план переноса компилятора и языкового сервиса на Go.
В марте 2026 года вышел TypeScript 6.0 — последняя основная версия старой реализации. А 8 июля 2026 года состоялся релиз TypeScript 7.0.
Это уже было не обычное расширение системы типов.
Команда переписала компилятор на Go, сохранив привычную семантику языка, но получив возможность использовать скорость нативного кода и многопоточную обработку.
Результаты оказались впечатляющими.
В опубликованных Microsoft тестах проверка и сборка проекта Visual Studio Code сократилась со 125,7 до 10,6 секунды — ускорение почти в 12 раз.
Для Sentry время уменьшилось со 139,8 до 15,7 секунды, а для Playwright — с 12,8 до 1,47 секунды.
В среднем на крупных проектах TypeScript 7 демонстрирует ускорение порядка 8–12 раз относительно предыдущей реализации.
При этом улучшения касаются не только запуска компилятора.
Быстрее работают анализ исходного кода, поиск ссылок, диагностические проверки и другие возможности языкового сервиса.
Символично и другое изменение: начиная с TypeScript 6.0 строгая типизация strict включена по умолчанию.
Когда-то разработчиков нужно было убеждать включать дополнительные проверки. Теперь именно строгий режим стал стандартной отправной точкой.
TypeScript 7 важен не потому, что предложил совершенно новый способ писать приложения.
Он показывает, насколько изменился масштаб использования языка.
Когда компилятор становится одной из центральных частей инфраструктуры разработки, его производительность перестаёт быть второстепенным вопросом.
И переход на Go стал логичным ответом на этот масштаб.
Почему TypeScript победил
Секрет успеха TypeScript заключается не в количестве добавленных ключевых слов или сложности системы типов.
Он оказался успешным потому, что практически никогда не требовал от JavaScript-разработчиков отказываться от привычной экосистемы.
Можно было продолжать использовать npm, существующие библиотеки, браузерные API и Node.js.
Можно было постепенно переносить проект на TypeScript, файл за файлом, без полной переработки приложения.
Можно было выбирать между строгой типизацией и более гибкими подходами, не меняя язык выполнения.
А по мере развития инструментов становилось всё меньше причин не использовать типы.
Фреймворки начали поддерживать TypeScript как полноценный способ разработки. Библиотеки получили декларации типов. Редакторы научились анализировать сложные зависимости между модулями. Deno и Bun сделали запуск TypeScript привычным, Node.js добавил собственную поддержку, а AI-инструменты получили возможность использовать типизацию для проверки генерируемого кода.
Постепенно TypeScript превратился из дополнительного удобства в основу взаимодействия между инструментами.
Разумеется, обычный JavaScript никуда не исчез. По данным Stack Overflow за 2026 год, его по-прежнему использовали 62% опрошенных разработчиков против 43,8% у TypeScript. Для небольших скриптов и простых задач он остаётся вполне разумным решением.
Но если речь идёт о новом полноценном веб-приложении, серверном API, библиотеке или большом проекте с несколькими разработчиками, TypeScript уже не приходится специально оправдывать.
Скорее наоборот: возникает вопрос, зачем сознательно отказываться от статической проверки типов, развитых инструментов и контрактов, которые понимают редакторы, компиляторы и AI-агенты.
Заключение
TypeScript не совершил одну большую революцию.
В 2012 году он предложил типы для JavaScript. В 2015-м получил поддержку Angular. В 2016-м значительно усилил систему типов и упростил работу с декларациями библиотек. В последующие годы постепенно стал частью React, Vue и других экосистем.
К началу 2020-х он уже занимал устойчивое положение в веб-разработке. Затем появились Deno, Bun и поддержка TypeScript в Node.js. Генеративный AI придал дополнительный импульс его распространению, а TypeScript 7 решил одну из важнейших проблем производительности.
За всей этой историей скрывается довольно простой принцип.
TypeScript не понадобилось заменять JavaScript, чтобы стать стандартом его разработки.
Он сохранил совместимость, последовательно устранял неудобства, улучшал инструменты и постепенно стал настолько естественной частью процесса, что сама необходимость выбирать между JavaScript и TypeScript для многих современных проектов практически исчезла.
И, пожалуй, именно это лучше всего описывает его успех: TypeScript не заставил индустрию перейти на новый язык. Он сделал так, что индустрия постепенно перешла на него сама.