TypeScript — всё по этой теме для программистов

Оглавление (нажмите, чтобы открыть):

Как начать работать с TypeScript

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

TypeScript — это просто JavaScript с необязательным добавлением типов для ваших переменных. Вы можете писать в современном синтаксисе JavaScript (ES2015+) и использовать TypeScript, после чего с помощью компилятора преобразовывать TypeScript(.ts) в JavaScript(.js), и также при необходимости скомпилировать JavaScript с поддержкой предыдущих версий, таких как ES5.

Обратите внимание, что если вы используете require() или import/export, вам все равно нужно будет использовать сборщик для браузера, такой как Webpack, Rollup или SystemJS.

Устанавливаем TypeScript

Сначала установите TypeScript, используя npm:

или с помощью yarn:

После глобальной установки вам будет доступна команда в терминале tsc.

Компилируем .ts файлы

Используя терминал, создайте новый каталог с названием ts-simple с помощью следующей команды:

Перейдите в этот каталог и создайте файл index.ts. Внутри этого файла мы создадим функцию с именем sayHello и принимаемым аргументом name с типом string.

Теперь используем tsc для компиляции нашего index.ts:

Эта команда создаст новый файл index.js, предварительно удалив типизацию из параметра, а также преобразовав файл в код ES5. Полученный файл можно запустить в браузере или использовать в Node. Ваш файл будет выглядеть следующим образом:

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

Ошибки компиляции TypeScript

Одним из преимуществ TypeScript является то, что он может автоматически обнаруживать ошибки в вашем коде, если типы не совпадают. Например, представьте, что в приведенном выше примере, для параметра name мы вызываем функцию .trim(). Если мы передадим переменную любого другого типа, это может привести к тому, что наш код вызовет ошибку при воспроизведении в браузере. Давайте посмотрим на наш обновленный пример, неправильно передав массив в функцию:

Это приведет к следующей ошибке TypeScript при запуске команды tsc index.ts:

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

Свежие вакансии

Оператор по обработке данных на дому (подработка без опыта)

&nbsp Требования: Требуется сотрудник для набора данных на дому. Высокооплачиваемая, интересная подработка на дому. Без опыта.

5000 per day&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Сборщик ручек — работа на дому

&nbsp (удалённая работа), без опыта. Оплата сдельная. Обращайтесь на почту [email protected]

10 нобяря 2020 г. 09:43

Упаковщик пищевых п/ф

&nbsp Обязанности: Запаивание упаковок с продукцией на вакуумном оборудовании. Требования: Гражданство любое. Можно без опыта.

10 нобяря 2020 г. 09:43

Наборщик данных на дому, без опыта (ежедневная оплата)

&nbsp Требования: Требуется помощник по вводу данных доменов на дому, без опыта. Требования: от Вас требуется иметь.

10 нобяря 2020 г. 09:43

менеджер по персоналу ЗП от 18 т.р. (возможно без опыта работы)

&nbsp в/о, возможно без опыта, готовы обучить. 5/2, соцпакет по ТКРФ, ЗП от 18 т.р.+ премии. КЦ «КАЧЕСТВО», пр. Кирова, 58.

18000 в месяц&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Оператор по обработке данных на дому (подработка без опыта)

&nbsp Требования: Требуется сотрудник для набора данных на дому. Высокооплачиваемая, интересная подработка на дому. Без опыта.

5000 per day&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Модельщик стеклопластиков

&nbsp зарплата договорная Челябинск | 09 ноября 2020 Образование: Cредне-специальное Опыт работы: без опыта. зарабатывать Условия: Официальное трудоустройство. Возможно без опыта работы. Достойная и своевременная оплата труда, 2 раза в.

10 нобяря 2020 г. 09:43

Оператор-кассир заправочной станции (график 2/2)

&nbsp работы: Без опыта Образование: Среднее.

10 нобяря 2020 г. 09:43

Оператор-кассир заправочной станции

&nbsp Дополнительно: График работы: Сменный график Опыт работы: Без опыта Образование: Среднее.

10 нобяря 2020 г. 09:43

Наборщик данных на дому, без опыта (ежедневная оплата)

&nbsp Требования: Требуется помощник по вводу данных доменов на дому, без опыта. Требования: от Вас требуется иметь.

10 нобяря 2020 г. 09:43

Помощник бурильщика ЭРБ (возможно без опыта)

&nbsp Требуются помощники бурильщика ЭРБ скважин на нефть и газ, наличие удостоверения. Возможно без опыта. Заработная.

40000 в месяц&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Рабочий (ая) на линии

&nbsp Требования: Возможно без опыта работы, обучение Дополнительно: График работы: Сменный график.

10 нобяря 2020 г. 09:43

Машинист тесторазделочных машин (с обучением)

&nbsp Описание вакансии Требования можно без опыта работы, обучение в процессе производства Условия работы официальное.

10 нобяря 2020 г. 09:43

Кассир магазина

&nbsp Условия: Смены. Авансы. Медкнижка (помощь). Подряд. Проживание. Требования: Гражданство ЕАЭС. Без опыта. Контактное.

10 нобяря 2020 г. 09:43

Продавец

&nbsp технологий от полугода: • Оформление в штат без стажировки. В Билайн мы развиваем и поддерживаем здоровую и безопасную рабочую. помогаем раскрыть их даже тем, у кого нет опыта! Приходи, будет круто! Полный рабочий день.

10 нобяря 2020 г. 09:43

Упаковщик/фасовщик полуфабрикатов (вахта с проживанием)

&nbsp ). Дополнительно: График работы: Вахтовый метод Опыт работы: Без опыта.

37300 в месяц&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Оператор (без опыта) (удаленная работа)

&nbsp Самостоятельный оператор (без опыта) Обязанности: сопровождение клиентов работа с отчетами, деловая переписка.

10 нобяря 2020 г. 09:43

Массажист/Массаж­истка

&nbsp Требования: Стаж работы массажистом не менее 5 лет. Пунктуальность. Легкий, позитивный характер, улыбчивость. Возможно без. опыта по LPG массажу и Шарко (поможем с обучением). Обязанности: Общий массаж, анцеллюлитный массаж, душ Шарко, LPG.

50000 в месяц&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Наборщик данных на дому, без опыта (ежедневная оплата)

&nbsp Требования: Требуется помощник по вводу данных доменов на дому, без опыта. Требования: от Вас требуется иметь.

10 нобяря 2020 г. 09:43

Продавец-консультант

10 нобяря 2020 г. 09:43

Рабочий на производство

&nbsp Требования: Без опыта работы , мужчины или женщины Дополнительно: График работы: Полный рабочий день Опыт работы: Без. опыта.

10 нобяря 2020 г. 09:43

Наборщик данных на дому, без опыта (ежедневная оплата)

&nbsp Требования: Требуется помощник по вводу данных доменов на дому, без опыта. Требования: от Вас требуется иметь.

10 нобяря 2020 г. 09:43

Оператор по обработке данных на дому (подработка без опыта)

&nbsp Требования: Требуется сотрудник для набора данных на дому. Высокооплачиваемая, интересная подработка на дому. Без опыта.

5000 per day&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Продавец-консультант

10 нобяря 2020 г. 09:43

Слесарь сборщик ПВХ-конструкций

&nbsp срок поставленные задачи; рассматриваем кандидатов без опыта работы; Условия: Зарплата окладно-премиальная, без.

25000 — 40000 в месяц&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Изготовитель полуфабрикатов (мясо/рыба)

&nbsp Условия: Смены. Медкнижка (помощь). Подряд. Обязанности: в магазин. Требования: Гражданство ЕАЭС и проч. Без опыта.

10 нобяря 2020 г. 09:43

Оператор по обработке данных на дому (подработка без опыта)

&nbsp Требования: Требуется сотрудник для набора данных на дому. Высокооплачиваемая, интересная подработка на дому. Без опыта.

5000 per day&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Оператор по ассортименту

&nbsp Условия: Смены. Помощь в оформлении медкнижки. Подряд. Обязанности: в магазин Требования: Гражданство любое. Без. опыта. Контактное лицо: Марина Дополнительно: График работы: Сменный график.

10 нобяря 2020 г. 09:43

Наборщик данных на дому, без опыта (ежедневная оплата)

&nbsp Требования: Требуется помощник по вводу данных доменов на дому, без опыта. Требования: от Вас требуется иметь.

10 нобяря 2020 г. 09:43

Уборщик производственных и служебных помещений

&nbsp РАБОТЫ ПО СОГЛАШЕНИЮ.БЕЗ ОПЫТА РАБОТЫ КОММУНИКАБЕЛЬНОСТЬ.МОЖНО ПРЕДПЕН.И ПЕНСИОННОГО ВОЗРАСТА Специализация Уборщик.

10 нобяря 2020 г. 09:43

Менеджер по продажам

&nbsp результат сотрудника. Рассмотрим студентов заочного отделения, рассмотрим кандидатов без опыта, но с большим желанием работать.

25000 — 40000 в месяц&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Повар

&nbsp Сфера деятельности: Начало карьеры, мало опыта / Рестораны, общественное питание Обязанности:Приготовление согласно. 13.00 до 01.00 Предоставляется развозка в черте города Бесплатное питание и униформа Выплаты 2 раза в месяц без задержек.

35000 — 40000 в месяц&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Укладчик хлебобулочных изделий

&nbsp Характер работы постоянно Режим работы работа по графику — г Примечание БЕЗ ОПЫТА РАБОТЫ Льготы Социальный пакет.

10 нобяря 2020 г. 09:43

Наборщик данных на дому, без опыта (ежедневная оплата)

&nbsp Требования: Требуется помощник по вводу данных доменов на дому, без опыта. Требования: от Вас требуется иметь.

10 нобяря 2020 г. 09:43

Товаровед — наборщик в службу доставки

&nbsp пользователь WhatsApp ответственность, пунктуальность рассмотрим кандидатов без опыта работы Обязанности сотрудника.

40000 — 80000 в месяц&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Менеджер по работе с входящими обращениями

&nbsp Положительный настрой Желание общаться с людьми Опыт работы в call центре будет преимуществом! Рассматриваем кандидатов без. опыта работы! Условия работы:- график работы 5/2, 8 часовой рабочий день. — оклад по результатам собеседования (15 000.

40000 в месяц&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Наборщик данных на дому, без опыта (ежедневная оплата)

&nbsp Требования: Требуется помощник по вводу данных доменов на дому, без опыта. Требования: от Вас требуется иметь.

10 нобяря 2020 г. 09:43

инженер-химик по оборудованию (без опыта работы) ЗП от 25 т.р

&nbsp в/о (химическое), возможно без опыта работы, 5/2 соцпакет по ТКРФ, ЗП от 25 т.р. КЦ «КАЧЕСТВО», г.Томск, пр. Кирова. (химическое), возможно без опыта работы, 5/2, соцпакет по ТКРФ, ЗП от 25 т.р.

25000 в месяц&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Подсобный рабочий

&nbsp ПАТП) Требования: без опыта работы Прием желающих: пн.-пт. с 8.30 до 15.30, с собой надо иметь трудовую книжку и.

10 нобяря 2020 г. 09:43

Менеджер по продажам недвижимости (новостройки, вторичное жилье). Эльмаш

&nbsp (НОВОСТРОЙКИ, ВТОРИЧНОЕ ЖИЛЬЕ) КОГО МЫ ИЩЕМ: Менеджера по продажам с опытом работы в любой сфере, ЛИБО без опыта продаж, который.

50000 — 150000 в месяц&nbsp&nbsp&nbsp&nbsp&nbsp 10 нобяря 2020 г. 09:43

Введение в TypeScript

Что такое TypeScript

TypeScript представляет язык программирования на основе JavaScript.

Развитие TypeScript началось в конце 2012 года. Хотя он зародился в компании Microsoft, и его фактическим создателем является программист Андерс Хейлсберг, так же известный как создатель таких языков как Delphi, C#, но данный проект сразу стал развиваться как OpenSource. И уже с самого начала новый язык стал быстро распространяться в силу своей гибкости и производительности. Немало проектов, которые были написаны на JavaScript, стали переноситься на TypeScript. Популярность и актуальность идей нового языка привела к тому, что ряд из этих идей в последующем станут частью нового стандарта JavaScript. А новая версия одного из популярнейших фреймворков для Web — Angular 2/4/5/6 полностью написана на TypeScript совместно компаниями Microsoft и Google.

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

Во-первых, следует отметить, что TypeScript — это строго типизированный и компилируемый язык, чем, возможно, будет ближе к программистам Java, C# и других строго типизированных языков. Хотя на выходе компилятор создает все тот же JavaScript, который затем исполняется браузером. Однако строгая типизация уменьшает количество потенциальных ошибок, которые могли бы возникнуть при разработке на JavaScript.

Во-вторых, TypeScript реализует многие концепции, которые свойственны объектно-ориентированным языкам, как, например, наследование, полиморфизм, инкапсуляция и модификаторы доступа и так далее.

В-третьих, потенциал TypeScriptа позволяет быстрее и проще писать большие сложные комплексные программы, соответственно их легче поддерживать, развивать, масштабировать и тестировать, чем на стандартном JavaScript.

В-четвертых, TypeScript развивается как opensource-проект и, как и многие проекты, хостится на гитхабе. Адрес репозитория — https://github.com/Microsoft/TypeScript. Кроме того, он является кроссплатформенным, а это значит, что для разработки мы можем испольвать как Windows, так и MasOS или Linux.

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

Генерируемый компилятором TypeScript код JS поддерживается подавляющим большинством браузеров, так как ориентируется прежде всего на стандарт ECMAScript 3, хотя TS также поддерживает и стандарты ECMAScript 5 и ECMAScript 2015 / 2020. Хотя в процессе разработки мы можем сами задать целевой стандарт ECMAScript.

Как использовать TypeScript? Поскольку данный язык является OpenSource, то все его инструменты доступны для всех желающих. Для работы с TypeScript мы можем использовать как Windows, так и Linux и MacOS.

Сам компилятор TS можно установить с помощью команды менеджера пакетов npm, который используется в Node.js:

Для написания кода на языке TypeScript можно использовать любой самый простейший текстовый редактор. Многие текстовые редакторы и среды разработки, например, Visual Code Studio, Atom, Sublime, Visual Studio, Netbeans, WebStorm и другие, имеют поддержку TypeScript на уровне плагинов, что позволяет воспользоваться рядом преимуществом, например, подцветкой кода или всплывающей подсказкой по типам и конструкциям языка.

Строгая типизация: Typescript, Flow, Javascript — быть или не быть?

Согласно опросу Global Developer Hiring Landscape Survey report 2020, проведенному Stack Overflow, JavaScript является самым востребованным языком программирования среди веб-разработчиков по всему миру. С момента своего создания в 1995 году JavaScript зарекомендовал себя как оптимальный язык работы с интерфейсами для браузеров и веб-страниц. Благодаря богатому набору библиотек он также обеспечил новые возможности для визуализации. Angular[.js], Ember.js и другие подобные фреймворки предоставили JS необходимую гибкость и возможности.

Следует помнить, что JavaScript разрабатывался как клиентский язык для масс, поэтому его функциональность не такая разнообразная, как у других языков. В нем не хватает множества важных функций, необходимых для адекватного написания и поддержки массивных приложений. Чтобы справиться с этой проблемой, веб-разработчики создавали такие инструменты, как eslint для сканирования кода.

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

JavaScript : история

Mosaic от NCSA был первым общепризнанным веб-браузером еще в 1993 году. А в 1994 Netscape представила свой популярный запатентованный браузер, получивший название Netscape Navigator, который считался единственным надежным вариантом в 90-х годах. Netscape наняла Брендана Эйха в 1995 году, и в том же году им был основан JavaScript. По словам Эйха:

«Мы стремились предоставить «язык-клей» для веб-дизайнеров и программистов на неполный рабочий день, которые строят веб-контент из таких компонентов, как изображения, плагины и мини-приложения на Java. Мы рассматривали Java как «компонентный язык», используемый более дорогостоящими программистами, где «программисты-склейщики» — разработчики веб-страниц — собирали бы компоненты и автоматизировали их с помощью JS».

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

JavaScript динамически типизированный и позволяет объявлять функции, объекты и переменные без объявления типа. Хотя эта возможность и упрощает использование языка, это не всегда удобно. Чтобы помочь справиться с такими проблемами, и появлялись TypeScript и Flow.

Цель статьи – выделить плюсы и минусы статической типизации в контексте разработки на Javascript. В дополнение к этому мы рассмотрим TypeScript и Flow, а также сравним их, чтобы в конце этой статьи вы могли бы решить: стоит ли переносить свои проекты на строгую типизацию вместо того, чтобы полагаться на «ванильный JavaScript».

Зачем это нужно

Вспомните Coffeescript, который был чрезвычайно популярен. Но, хотя я очень уважаю его изобретателя, факт заключается в том, что у этого языка были некоторые серьезные проблемы (почитайте соответствующую ветку переписки на ycombinator). Затем появился ES6.

Из-за необходимости поддерживать старые браузеры и для интерактивного выхода функционала ES6 у нас стали появляться транспайлеры, такие как Babel. Coffeescript имеет много общего с ним и тоже является транспайлером.

Инструментов CoffeeScript и Babel было недостаточно, что подтолкнуло сообщество в строну TypeScript и Flow. Взгляните на тренды (за Flow не ручаюсь, думаю, что возникла контекстуальная ошибка, он должен быть в несколько раз меньше).

Статистика Google Trends

TypeScript – это язык программирования с открытым исходным кодом, разработанный Microsoft, является суперсетом JS. По другую сторону – Flow, который разработан Facebook.

На практике Flow сравнительно проще, чем TypeScript, и его можно постепенно включить в файл проекта, настроить проверку типа в нем, просто добавив // @flow в начале файла. Все расширения основываются на комментариях.

Мастер Йода рекомендует:  Валидация и тестирование сайтов 20 онлайн-инструментов

TypeScript или Flow

Конечно, и TypeScript, и Flow полезны. Мы, в свою очередь, развернем сравнение с точки зрения разработчика.

TypeScript

TypeScript, как видно по названию, умеет проверять типизацию. Он принимает на вход (.ts) и генерирует (.js) на выходе. Существует флаг компилятора nolmplicitAny, который, если включен, потребует от вас указать типы и возвращаемые значения для всех используемых аргументов и функций.

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

Доступно множество описаний интерфейсов для библиотек JS. Если говорить о чем-то популярном, то проблем у вас не будет. Однако, нет уверенности, что разработчик, который написал файл .d.ts, сделал это аккуратно. Плюс ко всему, вам потребуется предоставить определение типов, если вы хотите внедрить стороннюю библиотеку для вашей кодировки. Готовьтесь заплатить за строгую типизацию своим временем.

В дополнение ко встроенной демонстрации ошибок до компиляции, при использовании TypeScript с IDE на подобии WebStorm перед вами откроется перекрестная навигация и более точное автозаполнение.

Flow

В отличие от TypeScript, Flow лишь сканирует ваши .js-файлы для обнаружения возможных ошибок. Другими словами, он действует как умный линтер.

Если пользуетесь Flow, то обратите внимание на пакет для Atom Nuclide.

Все же, кто на вершине?

Независимо от того, кто является вашим фаворитом: TypeScript или Flow, проверка типов – это будущее JS. Примечательным различием между Flow и TypeScript является то, насколько плавно они могут быть интегрированы в текущие проекты. В то время как TypeScript значительно сложнее, Flow относительно легко внедряем, предупреждая по ходу базовой интеграции, что проверяет меньше вашего кода, как и ожидается. Если вы пишете на Angular, то выбор у вас небольшой.

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

Преимущества использования статической типизации

Обнаружение ошибок на лету

С помощью тестирования типов легко проверить работоспособность кода еще до его выполнения.

Следующие операции действительны в JavaScript, но вы получите бонус в typescript, например:

Более точная передача смысла функции

Типы действуют как активная, живая документация для автора и его тим-мейтов. Благодаря статической типизации вам легче понять цель функции, тип данных, которые он принимает в качестве входных, или что ожидать взамен.

Если вы считаете, что включение комментариев может сделать то же самое, вы не ошибаетесь. Но поскольку комментарии являются довольно подробными, они нарушают общую структуру кода, уменьшают полезную плотность. Комментарии — это следствие того, что вы не справились с передачей смысла кода в синтаксисе его языка (интересная книга на эту тему: Чистый код Роберта Мартина).

Упрощение отладки ошибок

Нам лучше проверить, что s – строка, а y – регулярное выражение. Без статических типов вам понадобится дополнительный код. А без него нас могут ждать сюрпризы во время выполнения.

Различие между данными и поведением

Поскольку статические типы четко различают данные и поведение, это позволяет разработчикам более уверенно прогнозировать свои ожидания и более точно объяснять цель. Это не только смягчит давление и двусмысленность, но также добавит ясности и прозрачности во время кодинга.

Сокращение вероятности возникновения ошибок во время выполнения

Ошибки типа во время выполнения становятся катастрофическими, на чем и живут такие сервисы как Sentry.

Например, приведенный ниже код будет работать в JavaScript, но будет отмечать ошибку компиляции: строка не существует.

Инструмент доменного моделирования (если использовать IDE)

Одна из лучших особенностей статических типов. Если вы работали в Visual Studio на языке подобном C#, вы поймете, о чем я. Это реально уменьшает административную сложность. Пример (у вас реально получится работать с субдоменами):

Недостатки использования статических типов

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

Одна из проблем – дополнительная стоимость обучения инженеров и затраты на сопровождение типизированного кода.

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

С использованием TypeScript или Flow общий размер кода увеличится на 30% как минимум. Плотность кода снижается. Это как Ruby или Java 🙂

Использование статических типов в JavaScript — Да или Нет?

Курс по теме

Front-End Pro

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

  • Достаточно большой и комплексный проект

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

  • Над задачей работает большая команда

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

  • Рефакторинг программы в перспективе

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

  • Ваша команда знакома со статически типизированным языком

Строго типизированные языки, такие как TypeScript, – это прекрасный выбор, если вы или ваши товарищи по команде уже знакомы с типизированными языками, такими как Java или C#. Так как TypeScript был разработан тем же разработчиком, который изобрел C#, оба эти языка имеют похожие элементы.

  • Вы ищите замену babel

TS+ES6 возможно перевести на ES5 с помощью TS-транспайлера. Вы сможете отказаться от babel.

  • Библиотека/фреймворк предлагает TypeScript

Для тех, кто использует Angular 2+ или любой другой фреймворк, предлагающий TypeScript, следует попробовать статическую типизацию.

В заключение

Как только вы полноценно перейдете к статической типизации, то вряд ли вернетесь назад. Однако все это зависит от требований и объема проекта, над которым ведется работа. Не стесняйтесь поделиться своими мыслями, оставляйте комментарии. Мы будем рады услышать ваше мнение :).

Олександр Книга, Software Engineer в Weblab Technology

Дмитрий Дмитриенко, Brand Specialist в Weblab Technology

Шармин Хаят, Data Specialist в Weblab Technology

TypeScript: Урок 1 — Основные моменты

JavaScript — по настоящему вездесущий язык программирования. Можно написать веб приложение причем не только frontend, но и backend используя Node.js. И это не все, можно использовать Apache Cordova или ReactNative и другие подобные технологии для написания мобильных приложений , а можно программировать микроконтроллеры используя Kinoma. Бесспорный факт, что JavaScript завоевал популярность и используется практически на любой платформе.

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

JavaScript — интерпретируемый язык из-за чего мы можем узнать о проблеме (например опечатке), только после выполнения кода, что не очень удобно.

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

JavaScript — динамическая типизация, то тоже доставляет немало головной боли, с проверками на тип значения.

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

Введение

TypeScript — это не только язык программирования но и еще набор инструментов для генерации JavaScript. Он был разработан Андерсом Хейльсбергом (создатель C#) и является проектом с открытым исходным кодом, главной целью которого является помочь нам в создании больших и надежных приложений на JavaScript.

Преимущества TypeScript

Чтобы подчеркнуть преимущества TypeScript (и это далеко не полный список), давайте очень быстро рассмотрим некоторые вещи:

  • Компиляция
  • Строгая типизация
  • Использование популярных библиотек JavaScript
  • Инкапсуляция
  • Скрытые и публичные свойства и методы класса.

Компиляция

Одна из неприятностей которую можно встретить при разработке на JavaScript — это опечатка или случайное переопределение глобальной переменной. Что можно обнаружить только на этапе выполнения программы. И это явно не экономит время разработки.

TypeScript при компиляции проверяет код на ошибки, что очевидно ускорит выявление подобных неприятностей.

Строгая типизация

JavaScript не строго типизирован. Он очень динамичен и поэтому позволяет объектам изменять свои свойства «на лету». В качестве примера рассмотрим следующий код:

TypeScript – Изучаем с нуля

Дата публикации: 2020-01-26

От автора: начнем изучение TypeScript с нуля, а именно — с того, откуда он вообще взялся и для чего нужен.

JavaScript был представлен как язык программирования для клиентской стороны. Однако разработка Node.js позволила рассматривать JavaScript как перспективную технологию и на стороне сервера. Но по мере развития кода JavaScript, он становится все более запутанным, поэтому следить за кодом и повторно его использовать становится все сложнее.

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

Что такое TypeScript?

Согласно определению, «TypeScript – это JavaScript для разработки в масштабах приложений». TypeScript является строго типизированным, объектно-ориентированным, компилируемым языком программирования. Он был разработан Андерсом Хейлсбергом (разработчик C#) в Microsoft. TypeScript представляет собой как язык программирования, так и набор инструментов. Это типизированный, расширенный JavaScript, компилируемый в JavaScript. Другими словами, TypeScript – это JavaScript с некоторыми дополнительными характеристиками.

Как создать сайт самому?

Какие технологии и знания необходимы сегодня, чтобы создавать сайты самостоятельно? Узнайте на интенсиве!

Характеристики TypeScript

TypeScript – это просто JavaScript. TypeScript начинается в JavaScript и заканчивается в JavaScript. Typescript принимает базовые структурные элементы программы от JavaScript. Соответственно, чтобы использовать TypeScript, нужно знать только JavaScript. С целью выполнения, код TypeScript полностью конвертируется в JavaScript эквивалент.

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

JavaScript – это TypeScript. Это значит, что любой валидный .js файл можно переименовать в .ts и скомпилировать с другими TypeScript файлами.

TypeScript – портативный. TypeScript является легко-переносимым на браузеры, устройства и ОС языком. Он работает на всех платформах, на которых работает JavaScript. Его отличие от аналогов заключается в том, что TypeScript не нуждается в специальной виртуальной машине или среде выполнения.

TypeScript и ECMAScript

ECMAScript спецификация – это стандартизированная спецификация языка скриптов. Опубликовано уже шесть версий ECMA-262. Шестая стандартная версия имеет кодовое название «Harmony». TypeScript поддерживает спецификацию ECMAScript6.

TypeScript применяет базовые свойства языка спецификации ECMAScript5, то есть официальной спецификации JavaScript. Такие свойства языка TypeScript как Модули и ориентация на основе классов соответствуют спецификации EcmaScript 6. Плюс ко всему, TypeScript охватывает такие свойства как обобщенный тип и сигнатура типа, которые не являются частью спецификации EcmaScript6.

Как создать сайт самому?

Какие технологии и знания необходимы сегодня, чтобы создавать сайты самостоятельно? Узнайте на интенсиве!

Зачем нужен TypeScript?

TypeScript во многом превосходит все аналоги, к примеру, такие языки программирования как CoffeeScript и Dart, в том плане, что TypeScript – это расширенный JavaScript. Для сравнения, Dart и CoffeeScript являются новыми языками, и для них требуется среда выполнения, ориентированная на конкретный язык. Преимущества TypeScript:

Компиляция − JavaScript – это интерпретируемый язык программирования. По этой причине его нужно тестировать на корректность. В таком случае, если в коде присутствует ошибка, то это обнаружится только в конце, когда код уже полностью написан. Чтобы найти баг, придется потратить много времени. Компилятор типа «исходный код в исходный код» обеспечивает функцию проверки ошибок. Когда TypeScript находит синтаксические ошибки, он компилирует код и генерирует ошибки компиляции. Таким образом, можно найти ошибки еще до выполнения кода.

Строгая статическая типизация − JavaScript не является строго типизируемым языком программирования. TypeScript обладает функцией статической типизации и системой вывода типов посредством TLS (TypeScript Language Service – Языковая служба TypeScript). Тип переменной, объявленной без указания типа, может быть выведен посредством TLS на основе значения.

TypeScript поддерживает определения типа для существующих JavaScript библиотек. Файл определений TypeScript (с расширением .d.ts) обеспечивает определения для внешних JavaScript библиотек. Как результат, код TypeScript может содержать эти библиотеки.

TypeScript поддерживает такие понятия объектно-ориентированного программирования как классы, интерфейсы, механизм наследования и так далее.

Компоненты TypeScript

В основе TypeScript лежат три компонента:

Язык – Он включает в себя синтаксис, ключевые слова и сигнатуры типа.

Компилятор TypeScript − Компилятор TypeScript (tsc) конвертирует инструкции, написанные в TypeScript для его JavaScript эквивалентов.

Языковая служба TypeScript – «Языковая служба» предоставляет дополнительный уровень вокруг конвейера основного компилятора, которым являются редакторы. Языковая служба поддерживает стандартный набор стандартных операций по редактированию, например, автодополнение инструкций, автопоподстановки для сигнатур, форматирования и т.д.

Файлы определений

После того, как скрипт TypeScript был скомпилирован, можно сгенерировать файл определений (с расширением .d.ts), который выступает в качестве интерфейса для компонентов в скомпилированном JavaScript. Принцип действия файлов определений аналогичен принципу действия файлов заголовков в C/C++. Файлы определений (файлы с расширением .d.ts) обеспечивают автодозаполнение для поддержки типов, вызовов функций и переменных для таких JavaScript библиотек как jQuery, MooTools и т.д.

Редакция: Команда webformyself.

Как создать сайт самому?

Какие технологии и знания необходимы сегодня, чтобы создавать сайты самостоятельно? Узнайте на интенсиве!

JavaScript. Быстрый старт

Изучите основы JavaScript на практическом примере по созданию веб-приложения

Table of Contents #

Традиционный JavaScript фокусируется на функциях и наследовании, основанном на прототипах, для разработки многократно используемых компонентов, но этот подход довольно неудобен по сравнению с привычным объектно-ориентированным программированием, где классы наследуют функционал, и объекты строятся из этих классов. Начиная с ECMAScript 2015, также известном как ECMAScript 6, JavaScript программисты смогут создавать приложения, используя этот объектно-ориентированный подход, основанный на классах. В TypeScript этот подход можно применять уже сейчас, и компилировать код в JavaScript, который будет работать на основной массе браузеров и платформ, не дожидаясь следующей версии JavaScript.

Давайте рассмотрим простой пример работы с классами:

Синтаксис должен быть знакомым, если вы уже программировали на C# или Java. Мы объявили новый класс Greeter . Этот класс имеет три члена: свойство greeting , конструктор, и метод greet .

Вы заметили, что когда мы обращаемся к одному из полей класса, мы добавляем перед именем поля this. . Это означает, что мы получаем доступ к члену класса.

В последней строке мы создаем экземпляр класса Greeter , используя new . Он вызывает конструктор, что мы определили ранее, создает новый объект, и запускает конструктор для его инициализации.

Наследование #

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

Давайте посмотрим на пример:

Этот пример показывает многие возможности наследования TypeScript, такие же, как и в других языках. Здесь мы видим ключевое слово extends , используемое для создания подкласса. Классы Horse и Snake основаны на классе Animal и они получают доступ к его возможностям.

В примере показано, как переопределить методы базового класса с помощью методов, которые указаны в подклассе. Классы Snake и Horse создают метод move , который переопределяет метод move из класса Animal , придавая ему функциональность, специфичную для каждого из классов. Обратите внимание на то, что хотя tom объявлен как Animal , его значением является Horse , поэтому при вызове tom.move(34) , будет вызван переопределенный метод класса Horse .

Производные классы, содержащие функции-конструкторы, должны вызывать super() , который будет выполнять функцию-конструктор базового класса.

Модификаторы доступа #

public по умолчанию

В наших примерах мы смогли свободно получить доступ к членам класса, объявленным во всех классах программы. Если вы знакомы с классами в других языках, вы могли заметить, что в приведенных выше примерах мы не использовали слово public для изменения видимости члена класса. Например, C# требует, чтобы каждый член был явно помечен public для видимости. В TypeScript же, каждый член класса будет public по умолчанию.

Но мы можем пометить члены класса public явно. Класс Animal из предыдущего раздела будет выглядеть следующим образом:

Понимание private

Когда член класса помечен модификатором private , он не может быть доступен вне этого класса. Например:

TypeScript — это структурная система типов. Когда мы сравниваем два разных типа, независимо от того где и как они описаны и реализованы, если типы всех их членов совместимы, можно утверждать, что и сами типы совместимы. Впрочем, когда сравниваются типы с модификатором доступа private , это происходит по-другому. Два типа будут считаться совместимыми, если оба члена имеют модификатор private из того же самого объявления. Это относится и к protected членам.

Давайте посмотрим пример, чтобы понять принцип работы на практике:

В этом примере у нас есть классы Animal и Rhino , где Rhino является подклассом Animal . У нас также есть новый класс Employee , который выглядит идентично Animal . Мы создаем экземпляры этих классов и пытаемся получить доступ к каждому, чтобы посмотреть что произойдет. Поскольку private часть Animal и Rhino объявлена в одном и том же объявлении, они совместимы. Тем не менее, это не относится к Employee . Когда мы пытаемся присвоить Employee к Animal , мы получаем ошибку: эти типы не совместимы. Несмотря на то, что Employee имеет private член под именем name , это не тот член, который мы объявили в Animal .

Понимание protected

Модификатор protected действует аналогично private за исключением того, что члены, объявленные protected , могут быть доступны в подклассах. Например:

Обратите внимание на то, что мы не можем использовать член name вне класса Person , но можем использовать внутри метода подкласса Employee , потому что Employee происходит от Person .

Конструктор тоже может иметь модификатор protected . Это означает, что класс не может быть создан за пределами содержащего его класса, но может быть наследован. Например:

Модификатор readonly #

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

Свойства параметров

В нашем последнем примере мы объявили readonly член name и параметр конструктора theName в классе Octopus , и присвоили theName к name . Это очень распространенная практика. свойства параметров позволяют создавать и инициализировать члены в одном месте. Вот дальнейшая доработка предыдущего класса Octopus , используя свойство параметра:

Обратите внимание на то, как мы убрали theName и сократили параметр конструктора readonly name: string , чтобы создать и инициализировать член name . Мы объединили объявление и присваивание в одном месте.

Свойства параметров объявляются перед параметром конструктора, у которого есть модификатор доступности, readonly или и то, и другое. Использование свойства параметра private объявляет и инициализирует приватный член; то же самое делают public , protected и readonly .

Аксессоры (геттеры/сеттеры) #

TypeScript поддерживает геттеры и сеттеры как способ перехвата обращений к свойствам объекта. Это дает вам больший контроль над моментом взаимодействия со свойствами объектов.

Мастер Йода рекомендует:  Закругленные углы с помощью радиуса округления границ рамки CSS3

Давайте перепишем простой класс с использованием get и set . Для начала запишем пример без использования геттеров и сеттеров.

Разрешать напрямую устанавливать fullName — довольно удобно, но это может привести к проблемам если кто-то захочет изменить имя по своему желанию.

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

Чтобы убедиться, что наш метод доступа проверяет пароль, мы можем модифицировать его и увидеть, что при несовпадении мы получаем сообщение о том, что не можем модифицировать объект работника.

Внимание: аксессоры требуют установки в компиляторе генерации кода по стандарту ECMAScript 5 или выше.

Статические свойства #

До сих пор мы говорили только об членах экземпляра класса, тех, которые появляются в объекте, когда он инициализирован. Но мы можем создавать и статические члены класса, те, которые видны в классе без создания экземпляра. В этом примере мы используем static , так как origin — это общее значение для всех объектов. Каждый экземпляр получает доступ к этому значению, предваряя его именем класса. Схоже с тем, как мы добавляем this. для доступа к членам экземпляра, для доступа к статическим членам используется Grid. .

Абстрактные классы #

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

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

Дополнительные методы #

Конструкторы

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

В данном случае, когда мы говорим let greeter: Greeter , мы используем Greeter как тип экземпляров класса Greeter . Это почти привычка программистов из других объектно-ориентированных языков программирования.

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

Здесь let Greeter присваивается функция-конструктор. Когда мы указываем new и запускаем эту функцию, мы получаем экземпляр класса. Функция-конструктор также содержит все статические члены класса. Другой способ думать о каждом классе: есть часть экземпляр и статическая часть.

Давайте изменим немного код, чтобы показать эту разницу:

В этом примере greeter1 работает аналогично тому, что выше. Мы создали экземпляр класса Greeter и используем объект. Это мы уже видели.

Дальше используем непосредственно класс. Создаем новую переменную с именем greeterMaker . Эта переменная будет содержать сам класс, или, другими словами, функцию-конструктор. Здесь мы используем typeof Greeter , это выглядит как «дайте мне тип самого класса Greeter «, а не экземпляра. Или, точнее, «дайте мне тип идентификатора, что зовется Greeter «, который является типом функции-конструктора. Этот тип будет содержать все статические члены Greeter , вместе с конструктором, который создает экземпляры класса Greeter . Мы продемонстрировали это, использовав new с greeterMaker , создавая новые экземпляры Greeter и вызывая их, как раньше.

Использование класса в качестве интерфейса

Как мы уже говорили в предыдущем разделе, объявление класса создает две вещи: тип, описывающий экземпляры класса, и функцию-конструктор. Так как классы создают типы, мы можем использовать так же, как интерфейсы.

TypeScript как будущее энтерпрайзного JavaScript. Часть 1

Не стану пересказывать тут историю появления JS, она прекрасно всем известна, и описывается одним словом — спешка. JavaScript задумывался и создавался в очень сжатые сроки. По словам создателя JS Brendan Eich, у них было лишь 10 дней на все. Microsoft наступал на пятки и, если бы они проиграли, то сейчас эта статья была бы частично посвящена VBScript (Visual Basic Script).

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

Битва с ветряными мельницами

Браузерный мир выбрал JavaScript со всеми его недостатками, оговорками и поверхностной простотой. С тех пор утекло много воды, сам язык изменился, оброс дополнениями и удобствами, но основные проблемы остались, и избавиться от них почти невозможно, не сломав весь интернет.

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

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

Рискую быть закиданным помидорами, так как покушаюсь на святое, но самый популярный пример — jQuery. Стоит хотя бы вспомнить возможные варианты главной функции-объекта jQuery. «Функция-объект» — чувствуете, как это звучит? Вы можете вызвать jQuery как функцию девятью (девятью, Карл!) различными способами — все зависит от аргументов. А еще, сама функция является объектом, в котором может быть неконтролируемое число методов и/или свойств.

Да, jQuery — это действительно швейцарский нож с огромным количеством возможностей по упрощению жизни рядовому веб-разработчику. Но часто на базе системы jQuery-плагинов создают целые приложения интернет-магазина с десятками форм и диалогов. И вот там уже начинается натуральный ад и «лапша-код». Это самый популярный пример. jQuery разрабатывался как средство удобного доступа к DOM, но в итоге получился комбайн и практически отдельный язык программирования, что и порождает целую отдельную вселенную безумия, где на каждый вопрос один ответ — плагин для jQuery.

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

В корпорациях вроде Google технические специалисты очень быстро столкнулись с тем, что с ростом размеров JavaScript приложения практически с геометрической или даже экспоненциальной скоростью растут затраты на поддержку и исправление ошибок. В ответ на эту проблему Google выпустил GWT — Google Web Toolkit. Это компилятор, набор инструментов и базовых классов для разработки веб-приложений на Java. Стало возможным с минимальными оговорками писать веб-приложения на строго типизированном языке программирования с использованием большинства его плюшек. В качестве результата вы получаете приложение, написанное на, фактически, машинном JavaScript. Этот код невозможно отлаживать отдельно от GWT, это просто лишено смысла. В декабре прошлого года, после более чем года молчания, проект выпустил бету новой версии (2.8.0).

Стоит также заметить, что GWT чаще рассматривают как единственную возможность для джавистов, не владеющих JS, писать развесистый front-end без отрыва от любимого языка для back-end’а.

Других же не устраивал только синтаксис JavaScript, и они разрабатывали свои варианты языка программирования, которые с разной степенью прозрачности транслируются в JavaScript. Тут список примеров возглавляет, конечно же, CoffeScript. Подборка всего, что так или иначе транслируется в JavaScript, опубликована на github в wiki проекта CoffeScript.

Общий смысл сводится к тому, что вы можете писать front-end приложение почти на любом языке программирования, который вам нравится, важно лишь, чтобы была возможность сгенерировать JavaScript код на базе вашего исходного кода.

ES6 приходит к нам как набор дополнений к уже привычному стандарту ES5. Набор этих дополнений неточен, постоянно дополняется и переделывается в той или иной степени.

Конечно, ввиду того, что браузеров больше, чем один, и интерпретаторов JS, как минимум, столько же (даже несмотря на общие корни и/или основу у многих из них), каждый из них гнет свою линию и экспериментирует с синтаксисом, с трактованием предложений сообщества, или предлагает свои идеи.

Это своего рода продолжение войны браузеров, но уже в более вялой форме. Вот только она по-прежнему приводит к условиям проверки браузера или даже его версии в нашем коде, всевозможным «полифилам» (polifill), которые мы вынуждены подключать к нашим проектам, если хотим использовать какую-то «вкусность» из ES6, например, Promise или setImmediate. Но это история про браузерный API, а не про сам язык JavaScript.

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

Проект Babel представляет из себя транспайлер из современного представления о правильном переводе ES6 или даже ES2015 в код, совместимый с ES5. То есть разработчик получает возможность писать на самой современной версии JavaScript и, в большинстве случаев, не беспокоиться о совместимости с браузерами, которые еще не включают поддержку ES6 в свои JS-движки (или не включают по умолчанию, так как все, что скрыто за специальными экспериментальными настройками, лучше считать выключенным и недоступным). Про проект и все его возможности вы можете прочитать на официальном сайте, а мы пойдем дальше.

Бардак и порядок

Хорошо, мы можем прозрачно использовать все вкусности современного JavaScript в своем коде и не беспокоиться о совместимости с браузером.

Когда команда разработки состоит из более чем одного человека, то возникает необходимость в соглашениях — по архитектуре, выбору внешних библиотек, фреймворка или списка фреймворков (мало ли?). Большинство из этих вопросов решается устно за пару митингов и уточняется устно (конечно же документируется, верно?) на последующих митингах.

С началом разработки появляются новые вопросы и трудности — иерархии классов нужно поддерживать здоровыми и четкими. Минимализм интерфейсов крупных компонентов нужно строго документировать и постоянно устраивать внимательное ревью кода, чтобы не пропустить момент, когда все пойдет вкривь и вкось. А это обязательно случится. В какой-то команде/проекте раньше, в какой-то позже, но это случится. И это будет похоже на притчу про лягушку в кастрюле с холодной водой на медленном огне. В чем может быть причина такого развития событий?

Тут я выскажу исключительно свое мнение, которое вы не должны воспринимать как чистую правду или аксиому. Но дело вот в чем: динамическая природа JS подталкивает к излишней гибкости, и это расхлябывает интерфейсы объектов и функций. Со временем ваши функции и конструкторы объектов начинают принимать все больше разновидностей аргументов, объектов разной степени целостности и такая гибкость в итоге приводит к росту числа фантомных багов, которые решаются подпорками то тут то там, что в свою очередь, еще сильнее повышает энтропию в вашем коде.

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

Согласно второму закону термодинамики, энтропия всегда возрастает, но в наших силах хотя бы замедлить этот процесс.

TypeScript — надстройка вокруг ES6, ES2015

Пришло время перейти к главной теме. TypeScript — это язык программирования, который является супер-сетом вокруг ES6, ES2015. Разработан в Microsoft и теперь развивается в содружестве с коммьюнити. Даже Google приложил руку в виде AtScript, был поглощен одной из прошлых версий TypeScript. Спросите, если хотите, подробности у Google.

Что из себя представляет супер-сет? Это надстройка вокруг основного языка. Таким образом, любой работающий JavaScript-код автоматически является валидным TypeScript-кодом.

Что нового привносит TypeScript:
— Статическая типизация и выведение типов;
— Необязательные аргументы для функций и значения по умолчанию;
— public, private, protect для свойств и методов классов;
— Геттеры и сеттеры для свойств «без головной боли»;
— Декораторы для всего*;
— Интерфейсы и абстрактные классы;
— Generics;
— Компилирование в ES5 или даже в ES3 (с оговорками).

И в том числе плюшки ES6:
— Arrow Functions;
— Классы с единым стилем наследования;
— async/await из ES7;
— Итераторы и Генераторы*;
— Многострочные строки с шаблонизацией и тоже «без головной боли» с плюсами и кавычками;
— Управление зависимостями, в том числе и их динамическая загрузка.

* — (цель компиляции — не ниже ES5) экспериментальная поддержка, имплементация может измениться.

Главное, что нужно усвоить при начале использования TypeScript — никакой магии компилятор не делает, и что бронежилет он на вас тоже не надевает. Вы по-прежнему можете писать низкокачественную лапшу, и компилятор это переварит, хоть и завалит вас предупреждениями.

Подавляющее большинство работы по защите вас от вас же компилятор производит именно в момент анализа типов данных и их взаимодействия. Вообще вся история про TS так или иначе сводится к сверке типов данных и интерфейсов объектов. Только после этого начинают работать преобразователи синтаксического сахара. Они чем-то напоминают простые макросы, которые по шаблону переделывают строки (конечно, это грубое сравнение, но оно близко к реальности).

Компилятор не будет против сложения числа со строкой или даже с объектом, он лишь выдаст предупреждение о том, что вы, объявляя тип, имели ввиду, скорее всего, что-то другое, и вам стоит обратить внимание на конкретно эту строку и проверить, все ли вы тут делаете осознанно.

Предупреждения — главное оружие компилятора. Через предупреждения, которые он выдает в консоли, он сообщает вам о своих «сомнениях» относительно качества кода — «Вы указали, что эта переменная имеет тип Строка, но вот тут вы используете её как Число, вы уверены?» (это очень вольный пересказ сообщения компилятора). Если вы уверены, и ваш выбор конкретно такой логики осознан, то вы можете такую строчную переменную дополнить приведением типа к числу (или воспользоваться, например, parseInt() ), явно сообщая компилятору, что ситуация под контролем.

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

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

Предупреждения и ошибки компиляции

В большинстве случаев компилятор может скомпилировать код, даже с предупреждениями. Возможных ошибок, останавливающих компиляцию, довольно мало — например, некоторые синтаксические конструкции вроде декораторов невозможно скомпилировать в код, совместимый со стандартом ES3. Но это не означает, что вы не можете настроить жесточайшие правила для своего проекта.
Например, пакет компиляции TypeScript для grunt-ts вы можете настроить так, что он будет обрывать сборку даже при одном предупреждении от компилятора.

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

Лишь в ближайшее время компилятор TypeScript научится использовать в своей работе JavaScript-код (то есть код в файлах .js) — это позволит расширить сферу его возможностей к анализу на jsDoc-комментарии, где часто можно встретить в том числе типы данных для переменных, аргументов и непосредственному выведению типов на основе кода.

Любой JavaScript — это валидный TypeScript. Так как это супер-сет вокруг JavaScript, это означает, что вы можете использовать все, что есть в JavaScript всех версий, и то, что привносит непосредственно TypeScript.

Статическая типизация и выведение типов

У вас есть базовый набор типов JavaScript с явными декларациями, плюс парочка дополнительных, вроде enum(множество) и tuple (тьюплы, схожие по концепции с таковыми в python).

Все типы данных, явно декларируемые для переменных и свойств классов, конечно же, нужны только для проверок на этапе компиляции, никакой проверки типов на этапе выполнения не вносится. Все декларирование типов удаляется.

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

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

Но если волей программной логики вы вынуждены реализовать функцию, чей результат по типу может быть очень разным (строка, логическое, объект, уж не знаю, как вам вообще такая идея пришла в голову, но да ладно), или размеры функции не позволяют, окинув её взглядом, понять, какой тип данных она вернет, то его лучше указать явно, даже если компилятор вас об этом не просит (он смог вывести тип результата).

Также TypeScript, как говорилось ранее, оставляет вам возможность использовать все богатства динамического языка и позволяет вводить особый тип данных any. Этот тип данных говорит компилятору буквально следующее: «В этой переменной может быть все что угодно».

Необязательные аргументы для функций и значения по умолчанию

Без предисловий, пример, который расскажет сразу все:

Кроме объявления типа или структуры (что по сути является типом, но без имени) аргумента, в F1 используется конструкция для функции с неограниченным количеством аргументов (при вызове). Фокус состоит в том, что в переменную otherParams будут помещены все прочие (после четвертого) аргументы, с которыми будет вызвана функция. Конечно, для этого будет сгенерированы несколько строк JS-кода, которые любезно отделят эти аргументы из arguments в массив.

F2 описывает случай, когда в аргументах функции есть необязательные элементы — ?. Это означает, что для этих параметров при вызове функции компилятор не будет напоминать в предупреждениях о несоответствии заголовка функции её вызову. Переменная c — мало того, что необязательная, так еще и описывает несколько вариантов своего типа. То есть эта переменная может быть универсальной по типу — компилятор проследит, чтобы только эти типы данных использовались при вызове функции с этим аргументом.

Мастер Йода рекомендует:  SMO понятие, корни и основные правила

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

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

Те из вас, кто знаком с языком Python, могут спросить, почему авторы не пошли дальше и не добавили передачу аргументов по имени, примерно вот так:

let x = F3(a = 1, c = 3);

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

Public, private, protect для свойств и методов классов

Об этом пункте можно было бы рассказать в разделе «Без магии, или Контроль над ситуацией».

Конечно же, в объектной модели JavaScript в прототипах объектов не существует понятия доступности поля из потомка или потребителя. И TypeScript не добавляет его через хитрейшие сокрытия переменных в областях видимости. Все проще. Если конкретное поле или метод класса вы описали как private, но чуть позже пытаетесь обратится к нему извне, то компилятор скажет вам об этом. Но опять же, несмотря на предупреждение в консоли при компиляции, компилятор послушно сгенерирует обращение к этому полю объекта в JS-коде.

Геттеры и сеттеры для свойств «без головной боли»

Тут все просто — вы используете один синтаксис get name()<>, а TypeScript генерирует для вас способ определения таких свойств через стандартный Object.defineProperty. При этом вам доступен и вариант с вычисляемыми именами таких свойств.

Декораторы для всего (ES7)

Это экспериментальный функционал, доступный при включении опции —experimentalDecorators и при компиляции в JS версии не ниже ES5

Декораторы — это синтаксический сахар и паттерн одновременно.

В ранних версиях TS предлагалось использовать аннотации, но от этого отказались в пользу декораторов.

Аннотации — как это было (или могло быть)

Аннотации — это пометки на сущности. Выглядело это примерно вот так (в старых версиях TS и AtScript, откуда это и пришло):

А теперь JavaScript:

То есть к объекту прикреплялось дополнительное свойство __annotations или annotations, которые можно было использовать по своему усмотрению. Вы заметили это «__annotations или annotations»? В этом и скрывалась проблема, различные имплементации допускали разные варианты, что вводило путаницу. Проблема усугублялась еще больше, если существовал внешний код, который мог использовать эти свойства, но не знал, какой именно вариант нужно искать в объекте, если вообще знал, что нужно что-то искать, в итоге применение такого сгенерированного кода в модуле написанном на JS, обрастало условиями проверок вида аннотирования, что не способствовало качеству кода.

Декораторы

Декораторы в свою очередь «декорируют» объект, оборачивают собой сущность и, если нужно, подменяют её.

Суть проще продемонстрировать на простом примере. Представим класс, который предоставляет доступ к некой админке и кратко выглядит вот так:

Декораторы в этом примере описывают уровни доступа текущего пользователя к конкретным методам класса:
— Метод login доступен гостю, иначе перенаправить на страницу home;
— Метод fetch доступен только авторизованному пользователю;
— Возможность вызвать конец света методом destroyUniverse дана только авторизованному пользователю с правами рут-пользователя.

Такой стиль класса и использования декораторов должен вызвать чувство дежавю как минимум у питонистов и джавистов. Они привыкли к такому подходу.

Долго не задерживаясь, давайте посмотрим на имплементацию декоратора guest:

Итак, функция декоратора должна вернуть функцию, которая будет вызвана для объекта декорирования при создании объекта.

В случае декорирования метода класса функция-результат работы генератора декоратора получит прототип объекта, строчное имя метода и описание метода, если оно существует.

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

Возможность ответить на вопрос «Как применять декораторы в реальной практике и зачем они вам нужны?» я оставлю вам. Эта концепция имеет очень мощную основу и может существенно повлиять на архитектуру вашего приложения.

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

Интерфейсы и абстрактные классы

Ни интерфейсов, ни абстрактных классов в JavaScript нет, как и нет разумных аналогов их представления. Потому здесь речь опять про синтаксический сахар.

Приведу сразу объемный пример с комментариями, где я постарался использовать почти все:

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

В этом примере показан случай создания типа данных структуры без использования классов. Они не обязательны для таких случаев. Выгода от такого подхода в том, что вы явно просите компилятор помочь вам не ошибиться при работе с переменной. Конечно, на базе этих же описаний IDE сможет предложить вам достойный набор автодополнений и даже, возможно, рефакторинг.

Зачем это нужно? Ну, например, вы можете описать интерфейс требуемого колбека. Если вам в функцию попытаются передать функцию с другим интерфейсом, компилятор предупредит об этом.

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

Generics

Непростой функционал, хоть в базовом случае и работает очень просто. Пример из документации:

Как и в случае с интерфейсами, лучше прочесть главу в документации для полного понимания. Если очень кратко: компилятор подменяет T в декларации класса на number и перезапускает анализ, будто у класса там везде number. Вот и все. Опять же, до JavaScript-кода вся эта магия (как же я старался избегать этого слова) не доходит, все проверяется/сверяется/выводится до трансляции в JS-код.

Компилирование в ES5 или даже в ES3 (с оговорками)

Тут все просто, компилятор имеет внутри себя заготовки различных конструкций, вроде наследования, в виде шаблонов или кусков синтаксического дерева (это не важно), для различных версий стандарта EcmaScript (из списка поддерживаемых).

Оговорки касаются экспериментальных конструкций вроде декораторов и того, что просто невозможно описать в конкретной версии EcmaScript. Например, ни декораторы, ни set/get для полей класса нельзя описать в стандарте ES3 — просто в этом стандарте нет нужных вызовов в API примитива Object.

Выбор цели компиляции, гарантии, что будут доступны в качестве цели и будущие версии EcmaScript, — это делает TypeScript чуть ли не серебряной пулей. Вы уже можете использовать все то, что придумано нового в синтаксисе JavaScript, использовать проверку типов, декларации интерфейсов, абстрактные классы, декораторы и т.д. И в момент, когда «бизнес решит», что браузеры клиентов уже готовы для ES6 или ES7, вы просто переключите компилятор на другую цель, и генерируемый код обретет новые конструкции, избавится от каких-то подпорок для обратной совместимости. Код потенциально даже может стать быстрее, так как вместо явных обходных путей будет использовать нативное API движка JS.

ES6 в TypeScript

Как было сказано в самом начале, TypeScript является супер-сетом вокруг JavaScript. Это значит, что он включает в себя все синтаксические конструкции, которые добавлены в JS в ES6. Я не вижу смысла освещать их здесь, это заметка все же про TypeScript.

Выводы

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

Внесите порядок и структуру в ваш код и . (тут допишите свой вариант рекламного лозунга).

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

Во второй части расскажу о тонкостях процесса разработки на TS и миграции уже существующего кода, а также о планах развития TypeScript.

5 заповедей TypeScript-разработчика

Всё больше и больше проектов и команд используют TypeScript. Однако просто применять TypeScript и выжимать из него максимум пользы — это очень разные вещи.

Представляю вам список высокоуровневых передовых практик использования TypeScript, которые помогут получить максимум преимуществ от применения этого языка.

Не лгите

Типы — это контракт. Что это значит? Когда вы реализуете функцию, её тип становится обещанием, данным другим разработчикам (или вам же самим в будущем!), что, будучи вызвана, эта функция вернет определенный тип значения.

В следующем примере тип функции getUser гарантирует, что она возвращает объект, у которого всегда есть два свойства: name и age .

TypeScript — очень гибкий язык. В нем много компромиссов, призванных облегчить внедрение языка. Например, он позволяет вам реализовать функцию getUser вот так:

Не делайте так! Это ЛОЖЬ. Создавая такой код, вы ЛЖЕТЕ другим разработчикам (которые будут использовать вашу функцию в своих функциях). Они ожидают, что у объекта, возвращаемого функцией getUser , всегда будет какое-то поле name . Но его нет! Далее, что произойдет, когда ваш коллега напишет getUser(1).name.toString() ? Вы прекрасно знаете, что…

Здесь, конечно, ложь выглядит очевидной. Однако, работая с большой базой кода, вы будете часто оказываться в ситуациях, когда значение, которое вы хотите вернуть (или передать), почти совпадает с ожидаемым типом. Чтобы найти причину несовпадения типов, нужны время и усилия, а вы торопитесь… поэтому вы решаете использовать приведение типов.

Однако, делая это, вы нарушаете священный контракт. ВСЕГДА лучше выделить время и понять, почему типы не совпадают, чем использовать приведение типов. Очень вероятно, что под поверхностью скрывается какой-нибудь баг времени выполнения.

Не лгите. Соблюдайте свои контракты.

Будьте точны

Типы — это документация. Документируя функцию, разве вы не хотите донести как можно больше информации?

Какой комментарий для функции getUser вам бы больше понравился? Чем больше вы знаете о том, что возвращает функция, тем лучше. Например, зная, что она может вернуть undefined , вы можете написать блок if для проверки того, определен ли объект, который вернула функция, — перед тем, как запрашивать свойства этого объекта.

Ровно то же самое и с типами: чем более точно описан тип, тем больше информации он передает.

Вторая версия функции getUserType гораздо более информативна, и поэтому вызывающий ее находится в гораздо более удобной ситуации. Обрабатывать величину легче, если вы наверняка знаете (контракты, помните?), что это будет одна из трех заданных строк, а не просто любая строка. Начать с того, что вы точно знаете — величина не может быть пустой строкой.

Рассмотрим более реальный пример. Тип State описывает состояние компонента, который запрашивает некоторые данные с бекэнда. Точен ли этот тип?

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

Мы можем сделать тип намного более точным с помощью разграничивающих объединяющих типов (discriminated union types):

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

Будьте точны. Передавайте в своих типах как можно больше информации.

Начинайте с типов

Так как типы являются одновременно и контрактом, и документацией, они отлично подходят для проектирования ваших функций (или методов).

В Интернете есть множество статей, которые советуют программистам подумать перед тем, как писать код. Я полностью разделяю этот подход. Соблазн сразу перейти к коду велик, но это часто приводит к плохим решениям. Немного времени, потраченного на обдумывание реализации, всегда окупается сторицей.

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

В React JS есть понятие компонента высшего порядка (Higher Order Components, HOC). Это функции, которые каким-либо образом расширяют заданный компонент. К примеру, вы можете создать компонент высшего порядка withLoadingIndicator , который добавляет индикатор загрузки в существующий компонент.

Давайте напишем сигнатуру типа для этой функции. Функция принимает на вход компонент и возвращает тоже компонент. Для представления компонента мы можем воспользоваться типом React ComponentType .

ComponentType является обобщенным типом (generic type), который параметризуется типом свойств компонента. withLoadingIndicator принимает компонент и возвращает новый компонент, который отображает либо оригинальный компонент, либо индикатор загрузки. Решение о том, что именно отобразить, принимается исходя из значения нового логического свойства — isLoading . Таким образом, возвращаемому компоненту необходимы те же свойства, что и оригинальному, добавляется лишь новое свойство isLoading .

Окончательно оформим тип. withLoadingIndicator принимает компонент типа ComponentType

, где P обозначает тип свойств. withLoadingIndicator возвращает компонент с расширенными свойствами типа P & < isLoading: boolean >.

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

Начинайте с типов. Пусть типы вынуждают вас сначала проектировать, и лишь после этого писать реализацию.

Примите строгость

Первые три заповеди требуют от вас уделять особое внимание типам. К счастью, решая эту задачу, вы не обязаны делать все самостоятельно — зачастую сам компилятор TypeScript даст вам знать, когда ваши типы лгут или когда они недостаточно точны.

Можно помочь компилятору выполнять эту работу еще лучше, включив флаг —strict . Это мета-флаг, который подключает все опции строгой проверки типов: —noImplicitAny , —noImplicitThis , —alwaysStrict , —strictBindCallApply , —strictNullChecks , —strictFunctionTypes и —strictPropertyInitialization .

Что делают это флаги? Говоря в общем, их включение приводит к увеличению количества ошибок компиляции TypeScript. И это хорошо! Больше ошибок компиляции — больше помощи от компилятора.

Посмотрим, как включение флага —strictNullChecks помогает выявить ложь в коде.

Тип getUser гарантирует, что функция всегда возвращает объект типа User . Однако посмотрите на реализацию: функция может также вернуть значение undefined !

К счастью, включение флага —strictNullChecks приводит к ошибке компиляции:

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

Примите строгость проверки типов. Пусть компилятор оберегает вас от ошибок.

Будьте в курсе

Язык TypeScript развивается очень быстрыми темпами. Новый релиз выходит каждые два месяца. Каждый релиз привносит значительные улучшения языка и новые возможности.

Часто бывает так, что новые возможности языка позволяют определить типы точнее и проверять их строже.

Например, в версии 2.0 были представлены Discriminated Union Types (я упомянул их в заповеди Будьте точны).

Версия 3.2 представила флаг компилятора —strictBindCallApply , который включает корректную типизацию для функций bind , call и apply .

Версия 3.4 улучшила выведение типов (type inference) в функциях высшего порядка, что облегчило использование точных типов при написании кода в функциональном стиле.

Моя позиция такова, что знакомство с возможностями языка, вводимыми в последних версиях TypeScript, на самом деле стоит того. Часто это может помочь вам следовать остальным четырем заповедям из списка.

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

Будьте в курсе новых возможностей языка, и пусть это знание работает на вас.

Резюме

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

Буду рад увидеть ваши мысли на этот счет в комментариях.

Бонус

Понравилась эта статья о TypeScript? Уверен, вам также понравится и этот бесплатный PDF: 10 ошибок разработки на TypeScript, которые делают ваш код небезопасным

Проект на Phaser + TypeScript в VSCode

В этой статье поговорим о том, как организовать проект на Phaser-е используя редактор кода Visual Studio Code.
Такое решение подойдёт для тех, кто не хочет каждый раз запускать такого гиганта как MS VisualStudio для того, чтобы писать HTML5 игры.
VSCode по сравнению с MSVS намного легковесней, лаконичней и самое главное — бесплатна, но для организации проекта придётся сделать чуть-чуть больше действий.
Придётся самому написать специальный файл конфига для TS tsconfig.json (в VS эти настройки находятся в настройках проекта) и заводить http сервер для локального тестирования (это студия делает сама незаметно для глаз пользователя).
Пройдёмся по всему по порядку, как будь-то мы устанавливаем всё с нуля.

Установка NPM, TypeScript и VSCode

Для начала нам нужно установить сам typescript, это легче всего сделать с помощью npm, да и вообще npm просто необходим для js-программиста и всем прилежащим.
npm (аббр. node package manager) — это стандартный менеджер пакетов, автоматически устанавливающийся вместе с Node.js. Он используется для скачивания пакетов из облачного сервера npm, либо для загрузки пакетов на эти сервера.
Идём на сайт ноды, скачиваем и устанавливаем: https://nodejs.org/en/download

После того как установили это всё, мы можем открыть консоль и прописать установку TS командой:
npm install -g typescript

флаг -g сигнализирует о том, чтобы пакет устанавливался глобально в системе — для всех пользователей.

Так же для запуска проекта локально нам потребуется локальный сервер, установим и его:

npm install -g static-server

Теперь идём на сайт VSCode, скачиваем и устанавливаем, всё как обычно.

Настройка проекта в VSCode

Для начала в самой VSCode надо установить поддержку для TS и для JS. Вы легко найдёте это на главной странице:

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

Я устанавливаю такие расширения:

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

Проект представляет из себя папку в которой лежат все необходимые файлы: исходники, конфиги и т.п.

Создаём папку проекта (для определения я назову её project) и создаём в ней папки build и src.

Чтобы в дальнейшем протестировать сборку проекта, то в папки src и build нужно поместить соответсвующие файлы из папок src и build моего предыдущего шаблона на VisualStudio.

Открываем папку проекта в VSCode и дерево этой папки отобразится у нас слева как показано на рисунке:

Добавить комментарий