<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Sergey Bakaev on Medium]]></title>
        <description><![CDATA[Stories by Sergey Bakaev on Medium]]></description>
        <link>https://medium.com/@sergey.bakaev?source=rss-5401fa6ede55------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by Sergey Bakaev on Medium</title>
            <link>https://medium.com/@sergey.bakaev?source=rss-5401fa6ede55------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 23:15:45 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sergey.bakaev/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Введение в управление памятью в языке C#/.NET]]></title>
            <link>https://medium.com/@sergey.bakaev/%D0%B2%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5-%D0%B2-%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C%D1%8E-%D0%B2-%D1%8F%D0%B7%D1%8B%D0%BA%D0%B5-c-net-4180257d8ecf?source=rss-5401fa6ede55------2</link>
            <guid isPermaLink="false">https://medium.com/p/4180257d8ecf</guid>
            <category><![CDATA[garbage-collection]]></category>
            <category><![CDATA[c-sharp-programming]]></category>
            <dc:creator><![CDATA[Sergey Bakaev]]></dc:creator>
            <pubDate>Tue, 05 May 2020 19:52:28 GMT</pubDate>
            <atom:updated>2020-05-05T19:52:28.653Z</atom:updated>
            <content:encoded><![CDATA[<p>Любая программа в процессе своей работы использует различные ресурсы — файлы, базы данных, экран, сетевые подключения и т.д. Все эти ресурсы хранятся в памяти. Поэтому в зависимости от того, как программа работает с памятью, зависит стабильность ее работы и производительность.</p><p>Жизненный цикл какого-либо ресурса (например, класса) в программе можно разбить на следующие этапы:</p><ol><li>Необходимо выделить память для типа, представляющего ресурс. В C# для этого используется оператор <strong>new</strong>;</li><li>Инициализировать выделенную память, установив начальное состояние ресурса (что обычно делается в конструкторе);</li><li>Использование ресурса;</li><li>Очистить состояние ресурса;</li><li>Освободить занимаемую им память.</li></ol><p>Вроде все выглядит просто. Однако на практике при работе с большим количеством ресурсов очень не просто вручную управлять их состоянием, вовремя и правильно освобождать занимаемую ими память. В таких языках программирования, как, например, C++, часто бывает так, что программисты забывают освобождать память, которая стала ненужной и, что еще более опасно, пытаются обратиться к уже освобожденному участку памяти, что может привести к непредсказуемым последствиям вплоть до аварийного завершения работы программы.</p><p>Чтобы избавить программистов от необходимости вручную управлять памятью, среда CLR предоставляет механизм автоматического управления памятью с помощью так называемого сборщика мусора — набора специальных алгоритмов для автоматического контроля за памятью приложения.</p><p>В существующих языках программирования используются различные алгоритмы для управления памятью. Рассмотрим основные из них.</p><h3>Управление памятью на основе списка свободных блоков</h3><p>Данный механизм управления памятью используется в стандартной библиотеке языка С и С++. Этот механизм целиком и полностью возлагает на программиста ответственность за выделение и освобождение памяти.</p><p>Исходя из названия, свободная память хранится в виде связного списка блоков. При выделении памяти выбирается свободный блок из этого списка, при освобождении памяти блок снова возвращается в список.</p><p>При начале работы приложение получает небольшое количество свободных блоков в виде списка. Список может быть определенным родом отсортирован, например, по размеру блока. Когда поступает запрос на выделение памяти, используются различные алгоритмы для поиска подходящего блока:</p><ul><li><strong><em>“Первый подходящий (First-Fit)”</em></strong> — выбирается первый встретившийся блок памяти, в котором поместится объект, даже если этот блок значительно больше требуемого размера памяти;</li><li><strong><em>“Лучше подходящий (Best-Fit)” </em></strong>— выбирается блок памяти, равный или наиболее близкий требуемому объему памяти;</li><li>Другие алгоритмы на основе более сложных критериев, включая комбинирование описанных выше двух алгоритмов.</li></ul><p>Данный механизм управления памятью имеет следующие недостатки:</p><ul><li>Достаточно высокая стоимость операции выделения. Поиск блока может занимать много времени. В многопроцессорных системах также придется решать проблему конкурентного доступа к списку за счет различных блокировок или другими способами, например, с помощью созданию нескольких списков, что, в свою очередь, может привести к фрагментации памяти;</li><li>Высокая стоимость возвращения освобожденного блока в список. Также существует проблема с одновременным доступом к списку в многопроцессорных системах;</li><li>Высокая стоимость управления списком. Рано или поздно память будет фрагментирована и необходимо будет использовать механизмы для дефрагментации памяти, что неизбежно потребует блокировок потоков выполнения.</li></ul><h3>Управление памятью на основе подсчета ссылок</h3><p>Одним из примеров такого механизма управления памятью в системе Windows является <em>объектная модель программных компонентов</em> <em>(Component Object Model, COM)</em>. Каждый объект имеет счетчик ссылок, на основе которого определяется время его жизни в памяти. В момент создания объекта этот счетчик становится равным 1. После создания дополнительной ссылки счетчик увеличивается на 1, при уничтожении ссылки — уменьшается на 1. Когда счетчик становится равным нулю, то можно освободить память, которую занимает данный объект.</p><p>Рассмотрим недостатки, присущие этому механизму управления памятью:</p><ul><li>Высокая стоимость управления. Необходимо каждый раз, когда создается или уничтожается ссылка на объект, обновлять счетчик ссылок. Т.е. мы получаем дополнительные расходы при таких операциях, как присваивание и передача ссылки в функцию. В многопроцессорных системах также возникает проблема одновременного доступа к счетчику ссылок, что требует дополнительных блокировок;</li><li>Дополнительное использование памяти. Просто потому, что счетчик ссылок нужно где-то хранить. Хотя если мы говорим о среде CLR, то это не будет являться серьезной проблемой, поскольку там каждому объекту дополнительно добавляется от 8 до 16 байт дополнительной памяти;</li><li>Проблема циклических ссылок. На мой взгляд это одна из самых серьезных проблем этого механизма. Она возникает тогда, когда, например, два объекта имеют ссылки друг на друга, но при этом больше нигде не используются в программе. Это приводит к утечке памяти.</li></ul><h3>Управление памятью на основе механизма отслеживания ссылок</h3><p>Именно этот механизм используется в среде .NET CLR для управления памятью. Программисту не требуется вручную заниматься выделением или освобождением памяти. За него это делает сборщик мусора (Garbage Collector). В этом механизме не используются счетчики ссылок. Освобождение памяти происходит путем срабатывания определенных триггеров, например, одним из таких триггеров является достижение некоего порогового значения, которое не является постоянным и может меняться в процессе работы приложения.</p><p>Кратко разберем как работает данный алгоритм. Когда срабатывает один из триггеров, начинается процесс сборки мусора. Он состоит из нескольких этапов. Первый этап — это фаза маркировки. На этом этапе с помощью специальных алгоритмов определяются объекты, которые больше не нужны и можно освободить выделяемую ими память. После этого идет второй этап — фаза планирования, где сборщик мусора принимает решение, какие алгоритмы использовать для освобождения памяти, нужно ли выполнять дефрагментацию и т.п. Последний этап — это фаза чистки и сжатия (в зависимости от решений, принятых на фазе планирования, могут задействоваться разные механизмы)</p><p>В следующих статьях будут подробно рассмотрены алгоритмы выделения памяти при создании нового объекта в среде CLR и алгоритмы сборки мусора.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4180257d8ecf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Создание и настройка базового проекта ReactJS в связке с Redux с нуля с использованием Webpack]]></title>
            <link>https://medium.com/@sergey.bakaev/%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D0%B8-%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-%D0%B1%D0%B0%D0%B7%D0%BE%D0%B2%D0%BE%D0%B3%D0%BE-%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B0-reactjs-%D0%B2-%D1%81%D0%B2%D1%8F%D0%B7%D0%BA%D0%B5-%D1%81-redux-%D1%81-%D0%BD%D1%83%D0%BB%D1%8F-%D1%81-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC-webpack-67a8cd3ec7bb?source=rss-5401fa6ede55------2</link>
            <guid isPermaLink="false">https://medium.com/p/67a8cd3ec7bb</guid>
            <category><![CDATA[webpack]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[redux]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Sergey Bakaev]]></dc:creator>
            <pubDate>Wed, 20 Feb 2019 17:38:13 GMT</pubDate>
            <atom:updated>2019-03-20T05:43:26.694Z</atom:updated>
            <content:encoded><![CDATA[<p>В этой статье рассказывается о том, как создать базовый проект для работы с фреймворком ReactJS с нуля. Да, сейчас можно использовать <a href="https://github.com/facebook/create-react-app">create-react-app</a> для быстрого старта. Но важно разобраться в том, как это работает для лучшего понимания.</p><p>Исходный код проекта можно взять тут:</p><p><a href="https://github.com/subakaev/reactjs-boilerplate">subakaev/reactjs-boilerplate</a></p><h4>Инициализация</h4><p>Для начала необходимо выполнить инициализацию нового репозитория при помощи команды git init в выбранной папке. После этого нужно выполнить инициализацию нового модуля npm с помощью команды npm init и после ответа на все предложенные утилитой вопросы в папке с проектом появится файл package.json.</p><h4>Установка и настройка Babel</h4><p>Babel нужен нам для того, чтобы пользоваться последними возможностями языка JavaScript. Для его установки нужно выполнить следующую команду в терминале:</p><pre>npm i --save-dev @babel/core @babel/cli @babel/node @babel/preset-env @babel/preset-react @babel/polyfill</pre><p>После этого в проекте появится папка node_modules, в которую будут установлены указанные выше пакеты. Папку node_modules следует добавить в .gitignore, чтобы не загружать установленные пакеты в репозиторий.</p><p>Теперь необходимо настроить babel. Для этого в корне проекта создаем файл .babelrc со следующим содержимым:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d65e3c856de8d98c5951b5b4e161950b/href">https://medium.com/media/d65e3c856de8d98c5951b5b4e161950b/href</a></iframe><h4>Установка фреймворка для тестирования Jest</h4><p>Для того, чтобы писать и запускать автоматические тесты, необходимо установить следующий набор пакетов:</p><pre>npm i --save-dev jest jest-cli babel-jest</pre><p>Также в секции scripts файла package.json необходимо добавить строчку:</p><pre>&quot;test&quot;: &quot;jest&quot;</pre><p>Теперь можно запускать тесты на выполнение с помощью команды npm test.</p><h4>Установка и конфигурирование линтера eslint</h4><p>Линтер необходим для отслеживания корректности синтаксиса кода. Необходимо выполнить установку следующих пакетов:</p><pre>npm i --save-dev eslint babel-eslint eslint-config-airbnb-base eslint-plugin-babel eslint-plugin-import eslint-plugin-react eslint-plugin-jest</pre><p>Для настройки нужно создать в корне проекта файл .eslintrc.yml со следующим содержимым:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9aaf1fd8159eec07a0e13de40e3fac9b/href">https://medium.com/media/9aaf1fd8159eec07a0e13de40e3fac9b/href</a></iframe><h4>Установка пакетов для работы с ReactJS&amp;Redux</h4><p>В терминале выполняем команду:</p><pre>npm i --save react react-dom redux react-redux prop-types</pre><h4>Создание тестового приложения</h4><p>Создадим простое приложение на React&amp;Redux. Также дополнительно подключим фреймворк bootstrap 4 для стилевого оформления. В качестве тестового приложения сделаем счетчик, который можно будет увеличивать или уменьшать с помощью кликов по соответствующим кнопкам.</p><p>Для начала установим bootstrap и все пакеты, которые необходимы нам для работы с ним:</p><pre>npm i --save bootstrap jquery popper.js</pre><p>В корне проекта создадим папку src. Внутри создадим файл index.html. Этот файл будет нашей стартовой (и единственной) страницей.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/246f846fd96c7f0ba73f898248d65bf6/href">https://medium.com/media/246f846fd96c7f0ba73f898248d65bf6/href</a></iframe><p>Я здесь специально не стал подключать скрипты, необходимые для работы с ReactJS. Это будет сделать сделано позже автоматически с использованием сборщика Webpack. Тоже самое касается и стилей css. Дополнительно я добавил в проект каталог img для хранения различных изображений и добавил туда картинку, которая будет <a href="https://ru.wikipedia.org/wiki/Favicon">фавиконом</a>.</p><p>Для хранения пользовательских стилей была создана папка css и файл main.scss внутри. Определим в нем простой пользовательский класс, который используем далее.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ebec329e4cb2d8a4af4940b938ef61d0/href">https://medium.com/media/ebec329e4cb2d8a4af4940b938ef61d0/href</a></iframe><p>После этого приступим непосредственно к созданию приложения на React.</p><p>В итоге должна получиться следующая структура проекта:</p><pre>src<br>  app<br>    components<br>      App.jsx<br>      Main.jsx<br>    containers<br>      MainContainer.js<br>    reducers<br>      index.js<br>    index.js<br>  css<br>    main.scss<br>  img<br>    Logo.png<br>  index.html</pre><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/460f0d1a1346b1e32739c79498f491bd/href">https://medium.com/media/460f0d1a1346b1e32739c79498f491bd/href</a></iframe><p>Main.jsx — обычный <a href="https://itnext.io/react-component-class-vs-stateless-component-e3797c7d23ab">stateless</a> react-компонент, который выводит на экран заголовок, покрашенный в цвет пользовательского стиля, указанного в файле main.scss, и счетчиком в виде двух кнопок из значения посередине. В props компонента передается текущее значение счетчика и две функции для изменения его значения</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9e46bd25fbd8d3ac9c4fd8a48415f80b/href">https://medium.com/media/9e46bd25fbd8d3ac9c4fd8a48415f80b/href</a></iframe><p>MainContainer.js- redux-контейнер, в который оборачивается Main.jsx и осуществляется пробрасывание необходимых свойств из redux store.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e78b19307d5fb6428155f281e18e21c3/href">https://medium.com/media/e78b19307d5fb6428155f281e18e21c3/href</a></iframe><p>App.jsx — главный компонент приложения. Именно он рендерится в DOM.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8fb7d2df3313f50aa8e4eb8c8b81f21d/href">https://medium.com/media/8fb7d2df3313f50aa8e4eb8c8b81f21d/href</a></iframe><p>Редьюсер необходим нам для обработки действий и изменения значения счетчика.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cb11459db9e84ff9ef3b04e75deb130e/href">https://medium.com/media/cb11459db9e84ff9ef3b04e75deb130e/href</a></iframe><p>Здесь происходит инициализация redux и рендеринг нашего приложения.</p><p>Теперь нам нужно сделать так, чтобы все это запускалось и работало. Для этого будет использоваться сборщик Webpack.</p><h4>Установка и настройка Webpack</h4><p>Для начала установим все необходимые пакеты, а потом выясним зачем каждый из них нужен. Для начала работы требуется установить следующие пакеты:</p><pre>npm i --save-dev webpack webpack-cli webpack-dev-server babel-loader css-loader file-loader img-loader postcss-loader sass-loader style-loader react-hot-loader autoprefixer node-sass</pre><p>Также нам для настройки сборки потребуются следующие webpack-плагины:</p><pre>npm i --save-dev clean-webpack-plugin copy-webpack-plugin mini-css-extract-plugin optimize-css-assets-webpack-plugin uglifyjs-webpack-plugin html-webpack-plugin imagemin-webpack-plugin</pre><p>Конфигурации сборщика для дебага и продакшена будут отличаться. Поэтому создаем в корне проекта два файла:</p><pre>webpack.config.dev.babel.js<br>webpack.config.prod.babel.js</pre><h4>Настройка конфигурации для debug</h4><p>Вот что должно быть в файле webpack.config.dev.babel.js. Я приведу сначала весь конфиг целиком, а потом по пунктам рассмотрим что он делает</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/04c048e93701b64b068f20d2734e2293/href">https://medium.com/media/04c048e93701b64b068f20d2734e2293/href</a></iframe><p>Теперь по порядку что у нас здесь происходит.</p><p>В секции конфига <a href="https://webpack.js.org/concepts#entry">entry</a> мы указываем, что у нас должно входить в сборку. В секции <a href="https://webpack.js.org/concepts#output">output</a> указываем шаблон, которому будут соответствовать собранные файлы на выходе. В данном случае у нас указан шаблон [name].js, а в секции entry у нас два ключа — main и bundle. Это значит, что на выходе будет два файла — main.js и bundle.js. В этих файлах окажется весь код, который мы указали в этих секциях, обернутый webpack’ом.</p><p>Далее у нас указана секция <a href="https://webpack.js.org/configuration/dev-server/#src/components/Sidebar/Sidebar.jsx">devServer</a>, которая означает, что мы будем использовать сервер для разработки, встроенный в webpack. Для быстрого запуска нашего приложения в режиме отладки необходимо добавить в секцию scripts файла package.json следующую строку:</p><pre>&quot;start:client:dev&quot;: &quot;webpack-dev-server --mode development --config webpack.config.dev.babel.js --open&quot;</pre><p>После этого при условии, что все сделано верно, можно запустить приложение, выполнив в терминале команду npm run start:client:dev.</p><p>Но продолжим. В секции <a href="https://webpack.js.org/configuration/module/">module</a> указан набор правил, который будет применяться к различным типам собираемых сборщиком файлов.</p><p>Для js и jsx файлов для сборки будет использоваться babel-loader, который если говорить простым языком умеет конвертировать код, находящийся в этих файлах в код, который будет понятен браузеру. Также можно заметить, что используются дополнительные пресеты для того, чтобы можно было использовать react, es6 и чтобы loader знал, как их обрабатывать. Плагин react-hot-loader/babel нужен для так называемой “горячей перезагрузки” приложения, если в нем что-то поменялось, что очень удобно при разработке.</p><p>Далее идут правила для обработки файлов стилей css. Тут используется целый набор лоадеров, через которые последовательно проходит ресурс. Тут используется <a href="https://github.com/postcss/autoprefixer">autoprefixer</a>, который автоматически проставляет <a href="http://yapro.ru/web-master/css/vendornie-prefiksi.html">вендорные префиксы</a> в стилях. Следует помнить, что порядок лоадеров важен!</p><p>После идут правила для обработки изображений.</p><p>Далее идет секция плагинов.</p><p><a href="https://webpack.js.org/plugins/provide-plugin/">ProvidePlugin</a> позволяет автоматически загружать модули без использования директив import или require. Это нужно нам для работы boostrap, поскольку он требует jQuery и popper.js.</p><p><a href="https://webpack.js.org/plugins/copy-webpack-plugin/">CopyWebpackPlugin</a> позволяет копировать файлы из одной директории в другую. Используется для копирования изображений из папки с проектом в папку сборки, чтобы они были доступны в собранном коде.</p><p><a href="https://webpack.js.org/plugins/source-map-dev-tool-plugin/">SourceMapDevToolPlugin</a> необходим при разработке для генерирования source maps для удобной отладки возникающих ошибок. Без source maps было бы невозможно увидеть нормальный stacktrace ошибки.</p><p><a href="https://webpack.js.org/plugins/hot-module-replacement-plugin/">HotModuleReplacementPlugin</a> отвечает за перезагрузку страницы при изменении кода.</p><p><a href="https://webpack.js.org/plugins/html-webpack-plugin/">HtmlWebpackPlugin</a> упрощает создание HTML файлов путем подстановки в них собранных webpack’ом сборок. Это очень удобно, особенно для тех сборок, которые включают hash в название выходного файла сборки, который меняется каждую компиляцию. Работает как для js файлов, так и для стилей.</p><h4>Настройка сборщика для production сборок</h4><p>Как и для debug, сначала приведу текст конфига. Затем пробежимся по отличиям, которых не так и много и касаются они оптимизации сборок, которые становятся после этого более компактными и занимают меньше места.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/72b87c3d9cc6c804460fb0cce4117380/href">https://medium.com/media/72b87c3d9cc6c804460fb0cce4117380/href</a></iframe><p>Первое отличие — в разделе output указывается директория, в которую будут складываться собранные webpack’ом файлы. В нашем случае — это каталог dist, который нужно не забыть добавить в .gitignore, т.к. содержимое этого каталога в репозитории хранить незачем.</p><p>Следующее отличие состоит в том, что нам не требуется для сборки js/jsx файлом использовать плагин для “горячей перезагрузки”, поскольку это нужно только при разработке. <a href="https://webpack.js.org/plugins/hot-module-replacement-plugin/">HotModuleReplacementPlugin</a> нам также не нужен здесь.</p><p><a href="https://github.com/webpack-contrib/mini-css-extract-plugin">MiniCssExtractPlugin</a> используется разбиения css по файлам. Он создает css файл для каждого js файла, в котором используются css.</p><p><a href="https://github.com/johnagan/clean-webpack-plugin">CleanWebpackPlugin</a> очищает директорию dist перед началом сборки.</p><p>Также появился раздел <a href="https://webpack.js.org/configuration/optimization/">optimization</a>:</p><p><a href="https://webpack.js.org/plugins/uglifyjs-webpack-plugin/">UglifyjsWebpackPlugin</a> использует <a href="https://github.com/mishoo/UglifyJS2">uglify-js</a> для минификации js файлов.</p><p><a href="https://github.com/Klathmon/imagemin-webpack-plugin">imagemin-webpack-plugin</a> используется для сжатия изображений.</p><p><a href="https://github.com/NMFR/optimize-css-assets-webpack-plugin">optimize-css-assets-webpack-plugin</a> выполняет оптимизацию css файлов.</p><p>Вот собственно и все отличия. Осталось только добавить сточку в файл package.json в секцию scripts для того, чтобы мы могли выполнять сборку.</p><pre>&quot;build&quot;: &quot;webpack --config webpack.config.prod.babel.js&quot;</pre><p>На этом все.</p><p>Исходный код можно взять тут:</p><p><a href="https://github.com/subakaev/reactjs-boilerplate">subakaev/reactjs-boilerplate</a></p><p>Полезные ссылки:</p><ul><li><a href="https://reactjs.org/">React</a></li><li><a href="https://redux.js.org/">Redux - A JS library for predictable and maintainable global state management | Redux</a></li><li><a href="https://getbootstrap.com/">Bootstrap</a></li><li><a href="https://webpack.js.org/">webpack</a></li><li><a href="https://babeljs.io/">Babel</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67a8cd3ec7bb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Создание базового проекта NodeJS с Babel 7, eslint, jest.]]></title>
            <link>https://medium.com/@sergey.bakaev/%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D0%B1%D0%B0%D0%B7%D0%BE%D0%B2%D0%BE%D0%B3%D0%BE-%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B0-nodejs-%D1%81-babel-7-eslint-jest-8164b99777a4?source=rss-5401fa6ede55------2</link>
            <guid isPermaLink="false">https://medium.com/p/8164b99777a4</guid>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[code-climate]]></category>
            <category><![CDATA[travis-ci]]></category>
            <category><![CDATA[babel-7]]></category>
            <dc:creator><![CDATA[Sergey Bakaev]]></dc:creator>
            <pubDate>Thu, 01 Nov 2018 18:57:26 GMT</pubDate>
            <atom:updated>2018-11-03T12:50:33.377Z</atom:updated>
            <content:encoded><![CDATA[<p>В данной статье рассказывается как создать и настроить базовый проект для <strong>NodeJS</strong>.</p><p>Включает в себя:</p><ul><li>Установку и настройку <strong>Babel 7 </strong>для работы с последней на данный момент версией языка <em>JavaScript</em>;</li><li>Установку и настройку линтера <strong>eslint</strong> для автоматической проверки синтаксиса набираемого кода;</li><li>Установку и настройку фреймворка <strong>jest </strong>для тестирования;</li><li>Всякие дополнительные полезности в виде значков (бейджей) от <strong>CodeClimate</strong> и <strong>Travis-ci</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*5CEnCTUqlbcaD_YcSBVqLw.png" /><figcaption>Вот так будет выглядеть главная страница проекта на GitHub</figcaption></figure><p>Все примеры выполнены на компьютере с операционной системой <strong>Linux (Ubuntu) </strong>с устаноленным <strong>git</strong> и <strong>nodejs</strong>. Но, на мой взгляд, не составит никакого труда выполнить эти примеры на <strong>Windows</strong> или <strong>Mac</strong>. Если у вас не установлен <strong>git</strong> или <strong>nodejs</strong>, то это легко исправить, воспользовавшись поиском. В интернете полно информации на эту тему.</p><h4>Что такое NodeJS?</h4><p><strong>NodeJS </strong>— это платформа для работы с <em>JavaScript</em> без использования браузера. <strong>NodeJS</strong>, как правило, выполняет роль веб-сервера. Но также помимо этого позволяет создавать полноценные приложения.</p><h4>Что такое git?</h4><p><strong>Git</strong> — это наиболее распространенная на сегодняшний день система контроля версий. Любой современный разработчик должен уметь им пользоваться.</p><p>Итак, приступим.</p><h3>Инициализация проекта</h3><h4>Создание репозитория</h4><p>Для начала нужно создать новый репозиторий на GitHub.com. После создания <strong><em>пустого</em></strong> репозитория вы попадете на страницу примерно со следующим содержанием:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/987/1*tAEHd-LkgttV9_37ReGHDg.png" /></figure><p>Теперь создадим папку на компьютере, в которой будет храниться проект. После этого в терминале, находясь в этой папке нужно выполнить git init для инициализации нового локального репозитория. После этого добавим в проект файл README.md и добавим его в репозиторий. Также залинкуем локальный репозиторий с созданным на <em>GitHub</em> и сделаем первый коммит.</p><pre>git init<br>echo &quot;# nodejs-start-project&quot; &gt;&gt; README.md<br>git add README.md<br>git commit -m &quot;first commit&quot;<br>git remote add origin &lt;Ссылка на репозиторий&gt;<br>git push -u origin master</pre><p><a href="https://asciinema.org/a/4qc4mUP4jcsJ4JQ0c1FyY6JqL">untitled</a></p><p>Если все сделано верно, то на <em>GitHub</em> появится файл README.md и его содержимое отобразится на странице репозитория.</p><h4>Инициализация NodeJS модуля.</h4><p>Теперь нужно выполнить инициализацию проекта <strong>NodeJS</strong>. Для этого в терминале (или командной строке, если у вас Windows) нужно выполнить команду npm init. После этого вам необходимо ответить на предлагаемые утилитой вопросы для инициализации модуля, такие как название проекта, автор, описание и т.д. В конце необходимо подтвердить, что все правильно.</p><p>Если все сделано верно, то в папке проекта появится файл package.json.</p><p><a href="https://asciinema.org/a/KrVQHNhMXZ0sI0N33qhPcaKxi">NodeJS module initialization</a></p><h3>Установка и настройка Babel 7</h3><p><strong>Babel</strong> — это компилятор языка <em>JavaScript</em> и настраиваемый странспайлер, который используется при разработке на языке <em>JavaScript</em>. Он позволяет использовать все преимущества последних версий языка. Суть работы его такова, что <strong>babel</strong> берет код, написанный на <em>JavaScript</em> версии, выше чем <em>ES5</em> и выполняет преобразование этого кода в версию <em>ES5</em>, которую уже понимают все браузеры.</p><p>На данном этапе нам нужно установить 4 пакета для конфигурирования <strong>babel</strong>:</p><ul><li>@babel/core</li><li>@babel/cli</li><li>@babel/node</li><li>@babel/preset-env</li></ul><p><strong>@babel/core </strong>— непосредственно сам трансплайнер, <strong>@babel/cli</strong>— позволяет нам компилировать файлы с помощью командной строки для преобразования кода к версии языка <em>ES5</em>. <strong>@babel/node </strong>— утилита командной строки, которая работает также, как и <em>Node cli</em>, но дополнительно использует установленные babel-плагины и пресеты, прогоняя код через них перед запуском.<strong> @babel/preset-env</strong> открывает нам доступ к новым возможностям языка <em>JavaScript</em>.</p><p>Для установки перечисленных выше модулей необходимо выполнить следующую команду в терминале:</p><pre>npm i --save-dev @babel/core @babel/cli @babel/node @babel/preset-env</pre><blockquote>Директива --save-dev означает, что зависимости будут установлены в раздел devDependencies файла package.json. Это нужно для того, чтобы при публикации модуля эти зависимости не вошли в сборку, поскольку они нужны только для разработки и не должны быть в финальной публикуемой сборке.</blockquote><p>Теперь необходимо создать конфигурационный файл для <strong>babel</strong>, в котором нужно подключить установленные ранее дополнительные зависимости, т.к. по умолчанию <strong>babel</strong> не будет работать с ними. Файл должен находиться в корне проекта (там же, где и package.json) и называться он должен .babelrc. Вот его содержимое:</p><pre>{  <br>  &quot;presets&quot;: [    <br>    [&quot;@babel/preset-env&quot;,<br>      {         <br>        &quot;targets&quot;: {          <br>          &quot;node&quot;: &quot;current&quot;        <br>        }     <br>      }    <br>    ]  <br>  ]<br>}</pre><h4>Добавление .gitignore</h4><p>При установке зависимостей все они загружаются в папку node_modules, расположенную в корне проекта. Все эти файлы, которых к тому же там очень много, не нужно загружать в репозиторий. Это считается плохой практикой. Их всегда можно восстановить при помощи команды npm install если вы развертываете репозиторий на другом компьютере, например. Поэтому нужно добавить этот каталог в файл .gitignore, который предварительно нужно создать в корне проекта со следующим содержимым:</p><pre>node_modules</pre><h4>Index.js</h4><p>Добавим в проект каталог src, а в нем создадим файл index.js с простой функцией, экспортируемой по умолчанию:</p><pre>export default (a, b) =&gt; a + b;</pre><p>Этот код не может быть распознан браузером, поскольку тут используются возможности версии языка ES6.</p><h4>Конфигурирование</h4><p>Откроем файл package.json и добавим следующие строки в раздел scripts:</p><pre>&quot;babel-node&quot;: &quot;babel-node&quot;,    <br>&quot;build&quot;: &quot;NODE_ENV=production babel src --out-dir dist --source-maps inline&quot;,    <br>&quot;prepublishOnly&quot;: &quot;npm run build&quot;</pre><p>Первая строка добавляет возможность выполнять запуск babel и передавать туда файлы, код которых нужно выполнить. Для примера можно создать файл some-script.js со следующим содержимым:</p><pre>const sum = (a, b) =&gt; a + b;</pre><pre>console.log(1, 3);</pre><p>Затем если в терминале (находясь в корневом каталоге проекта) выполнить команду npm run babel-node src/some-script.js, то будет выведено значение 4. Также можно выполнить команду npm run babel-node без параметров. В этом случае мы войдем в режим работы, в котором сможем вводить различный код, который будет выполняться. Иногда это бывает полезным, если вам, например нужно проверить какой-либо небольшой кусок кода. В представленном ниже видео показан пример.</p><p><a href="https://asciinema.org/a/V1Ug5UP4UWkI4Tjy1f1XJ7eLD">npm run babel demostration</a></p><p>Вторая добавленная в раздел scripts строка отвечает за построение продакшн версии кода. Весь код при этом помещается в папку dist, которая появляется в корне проекта. При этом эту папку следует добавить в виде исключения в файл .gitignore, поскольку в репозитории на сервере она не нужна. Скрипт prepublishOnly предназначен для построения проекта непосредственно перед публикацией. Специально запускать этот скрипт не требуется.</p><h3>Установка и настройка линтера eslint</h3><p><strong>Eslint</strong> — это линтер, предназначенный для проверки корректности синтаксиса кода, который вы пишете. Он включает в себя множество правил.</p><p>Для начала нужно установить следующие пакеты:</p><pre>npm i --save-dev eslint eslint-config-airbnb-base eslint-plugin-import babel-eslint eslint-plugin-babel</pre><p>После этого нужно выполнить настройку линтера. Для этого нужно создать файл .eslintrc.yml со следующим содержимым:</p><pre>plugins:<br>  - babel</pre><pre>env:<br>  node: true</pre><pre>parser: babel-eslint</pre><pre>extends:<br>  - &#39;airbnb-base&#39;</pre><pre>rules:<br>  no-console: 0</pre><p>По сути конфигурация означает, что мы хотим использовать линтер применительно к <strong>babel</strong> в окружении <strong>nodejs</strong> с расширением <strong>airbnb</strong>. Расширение определяет набор правил, которые должны применяться к нашему коду. Существуют и другие наборы правил, но этот является наверное самым популярным.</p><p>Секция rules позволяет нам управлять набором правил. В данном случае no-console: 0 говорит нам о том, что <strong>eslint</strong> не будет показывать ошибку на вызов console.log().</p><p>Если все сделано верно, то теперь можно в терминале выполнить следующую команду: npm run eslint . или npx eslint .. Не забудьте точку в конце! Точка говорит о том, что нужно проверять все файлы в проекте. Если есть ошибки, то они будут выведены в терминал, если все в порядке, то вы ничего не увидите — управление снова вернется в терминал.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/1*aXf37aWia-v-e2-BzmJQSA.png" /><figcaption>Результат работы линтера с выводом ошибок</figcaption></figure><p>Если вы работаете в какой-либо IDE, например <em>Visual Studio Code</em>, то можно установить еще расширение <strong>eslint</strong> и тогда ошибки будут подсвечиваться прямо в редакторе с возможностью автоматического исправления.</p><h3>Конфигурируем jest</h3><p><strong>Jest</strong> — это фреймворк для написания и выполнения тестов к <em>JavaScript</em> коду. Был придуман компанией <em>Facebook</em> для тестирования <em>React</em>-приложений.</p><p>Для того, чтобы мы могли писать тесты и запускать их и чтобы все это работало с <strong>babel</strong> и чтобы не ругался <strong>eslint</strong>, необходимо установить следующие пакеты:</p><pre>npm i --save-dev jest jest-cli eslint-plugin-jest babel-jest</pre><p>Но! Поскольку мы работаем с <strong>babel 7</strong> в настоящее время нам нужно поставить еще одну дополнительную библиотеку, чтобы <strong>jest</strong> смог работать с <strong>babel 7</strong>. В будущем я думаю эту проблему решат, но на данный момент она актуальна.</p><pre>npm i --save-dev babel-core@^7.0.0-0</pre><p>Если этого не сделать, но при запуске тестов можно получить ошибку примерно следующего содержания:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uydy9tt5gGxZ79qHCQvL-g.png" /></figure><p>Теперь нужно настроить <strong>jest</strong>. Для запуска тестов нужно добавить следующую строчку в раздел scripts файла package.json:</p><pre>&quot;test&quot;: &quot;jest&quot;</pre><p>Также необходимо внести следующие корректировки в настройки .eslintrc.yml (выделены жирным):</p><pre>plugins:<br>  - babel<br>  <strong>- jest</strong></pre><pre>env:<br>  node: true<br>  <strong>jest: true</strong></pre><pre>parser: babel-eslint</pre><pre>extends:<br>  - &#39;airbnb-base&#39;<br>  <strong>- &#39;plugin:jest/recommended&#39;</strong></pre><pre>rules:<br>  no-console: 0</pre><p>Теперь создадим в корне проекта папку __tests__. Это общепринятое название папки и по умолчанию <strong>jest</strong> ищет тесты именно в этой папке. Это можно, конечно, изменить, но лучше придерживаться общепринятых норм. Файлы с тестовыми сценариями должны оканчиваться на *.test.js, чтобы <strong>jest</strong> их распознал.</p><p>Создадим в папке __tests__ файл с названием index.test.js со следующим содержимым:</p><pre>import sum from &#39;../src&#39;;</pre><pre>test(&#39;1 + 2 should return 3&#39;, () =&gt; {<br>  expect(sum(1, 2)).toBe(3);<br>});</pre><p>Теперь можно осуществить запуск тестов, выполнив в терминале следующую команду (находясь при этом в корне проекта):</p><pre>npm test</pre><p>И если все было сделано правильно, то вы увидите в терминале отчет о выполнении или невыполнении тестов.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/906/1*hp-UJuzZuZW9cl8qgmtbKA.png" /></figure><h3>Makefile</h3><p>Работая в POSIX совместимых операционных системах, удобно создать и использовать Makefile. По сути — это набор директив, которые вы можете в нем определять и затем выполнять в терминале, используя команду make &lt;название определенной вами директивы&gt;.</p><p>Приведу пример базового Makefile&#39;a для данного проекта:</p><pre>install:<br>  npm install</pre><pre>start:<br>  npx babel-node src/index.js</pre><pre>build:<br>  rm -rf dist<br>  npm run build</pre><pre>publish:<br>  npm publish</pre><pre>lint:<br>  npx eslint .</pre><pre>test:<br>  npm test</pre><pre>test-coverage:<br>  npm test -- --coverage</pre><p>В листинге выше сначала идет название директивы, после которой ставится двоеточие, затем на следующих строках пишутся команды, которые нужно выполнить. Отступы обязательны!</p><h3>Найстройка бейджей</h3><p>На данном этапе мы уже имеем полностью готовый базовый проект <strong>NodeJS</strong>. Осталось лишь приукрасить его :) и добавить полезных функций.</p><p>Не стоит думать, что это бесполезное занятие. Данные опции достаточно важны для любого проекта. Мы научимся конфигурировать <strong>Travis-ci</strong> и узнаем что такое <strong>CodeClimate</strong>. Все это бесплатно для публичных репозиториев на github.</p><h4>Travis-ci</h4><p><strong>Travis-ci</strong> — это сервис, предназначенный для построения и тестирования проектов, расположенных на <em>github</em>. Это очень удобная штука, которая запускает построение или тесты проекта как только вы что-то залили на <em>Github</em> и возвращает результат, который можно при помощи бейджика прикрепить к проекту.</p><p>Займемся его настройкой.</p><p>Для начала вам необходимо зарегистрироваться на сайте <a href="https://travis-ci.org/">https://travis-ci.org/</a> и привязать свой Github-аккаунт. После этого на странице <a href="https://travis-ci.org/account/repositories">https://travis-ci.org/account/repositories</a> вам нужно подключить ваш репозиторий к travis-ci.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*-Yu7radfvX18DjWq5Xb2ug.png" /><figcaption>Просто найдите репозиторий и “активируйте” его</figcaption></figure><p>После этого можете кликнуть по названию вашего репозитория и попадете на страницу с информацией о нем. Нам это понадобится в последствии.</p><p>Вернемся к коду. В корне проекта необходимо создать файл .travis.yml для конфигурирования <strong>travis-ci</strong> со следующим содержимым:</p><pre>language: node_js</pre><pre>node_js:<br>  - node</pre><pre>script:<br>  - make lint<br>  - make test</pre><pre>notifications:<br>  email: false</pre><p>Самый важный разде для нас — это script. В нем как раз описывается то, что будет делать <strong>travis-ci</strong>. В данном случае он проверит код линтером на наличие синтаксических ошибок и запустит тесты и дождется их выполнения.</p><p>Теперь нужно закомитить этот файл с настройками на <em>github</em> и через небольшой промежуток времени <strong>travis-ci</strong> автоматически запустит скрипты. И если все сделано правильно и нет ошибок в коде, то результат выполнения должен быть успешным. Это легко проверить на странице проекта на сайте <strong>travis-ci</strong>.</p><p>Осталось добавить бейдж на страницу README.md нашего репозитория. Для этого на странице с проектом на сайте <strong>travis-ci</strong> вам нужно кликнуть на иконку значка (как на рисунке)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/672/1*6xGFj0G_9W_pW5R8k3KH0w.png" /><figcaption>Диалоговое окно при клике на значок</figcaption></figure><p>После этого вам нужно выбрать Markdown во втором выпадающем списке и скопировать ниже ссылку на значок. Затем нужно вставить эту ссылку в файл README.md, находящийся в корне проекта. И залить на <em>github</em>. Теперь у вас на главной странице проекта на <em>github</em> есть бейдж тревиса.</p><h4>CodeClimate</h4><p><strong>CodeClimate</strong> — это сервис для автоматизированной оценки качества вашего кода и покрытия его тестами.</p><p>Для начала авторизуйтесь на сайте с помощью вашего <em>github</em> аккаунта на странице <a href="https://codeclimate.com/login/github/join">https://codeclimate.com/login/github/join</a> и выберите пункт OpenSource. После этого вам нужно добавить ваш репозиторий в <strong>CodeClimate</strong>. Сразу после добавления сервис запустит анализатор вашего кода и покажет результат.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AGyQHXkjzOXVnml0kP0erA.png" /><figcaption>Результат работы анализатора кода от CodeClimate</figcaption></figure><p>Как видно, покрытие тестами у нас сделано не было. И по умолчанию сервис не умеет этого делать. Мы это настроим позже. А пока добавим бейджи в наш репозиторий. Для этого находясь на странице с проектом на сайте <strong>CodeClimate</strong> (показана на рисунке выше) нужно перейти во вкладку <strong>Repo Settings</strong> и слева в меню выбрать <strong>Badges</strong>. Откроются ссылки на значки, которые нужно добавить в ваш README.md. Только не забудьте выбрать <strong><em>Markdown</em></strong> для ссылок на значки!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*8c2DNUm05cze1prTR4g06w.png" /><figcaption>Страница с настройками бейджиков</figcaption></figure><p>Осталось только заставить работать покрытие тестами (test coverage). А без <strong>travis-ci</strong> нам тут не обойтись. Для начала на сайте <strong>CodeClimate</strong> на странице с вашим проектов перейдите во вкладку <strong>Repo Settings</strong> (если вы с нее уже ушли) и выберите в меню пункт <strong>Test coverage</strong>. Там вам нужно найти поле TEST REPORTER ID. Скопируйте его. Оно на понадобится для конфигурации <strong>travis-ci</strong>. После этого нужно внести корректировки в конфигурацию .travis.yml (выделено жирным):</p><pre>language: node_js</pre><pre>node_js:<br>  - node </pre><pre><strong>env:<br>  global:<br>    - CC_TEST_REPORTER_ID=<em>&lt;your TEST REPORTER ID must be here&gt;</em></strong></pre><pre><strong>before_script:<br>  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 &gt; ./cc-test-reporter<br>  - chmod +x ./cc-test-reporter<br>  - ./cc-test-reporter before-build</strong></pre><pre>script:<br>  - make lint<br>  - make test<strong>-coverage</strong></pre><pre><strong>after_script:<br>  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT </strong></pre><pre>notifications:<br>  email: false</pre><p>Говоря простым языком в данном скрипте выполняется прогон тестов с покрытием кода и результат отправляется в <strong>CodeClimate</strong>.</p><p>В итоге зайдя на главную страницу с проектом вы должны видеть приблизительно такую картину:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*5CEnCTUqlbcaD_YcSBVqLw.png" /></figure><ul><li><a href="https://github.com/subakaev/nodejs-boilerplate">subakaev/nodejs-boilerplate</a></li><li><a href="https://babeljs.io/">Babel</a></li><li><a href="https://eslint.org/">Find and fix problems in your JavaScript code - ESLint - Pluggable JavaScript Linter</a></li><li><a href="https://jestjs.io/">Jest</a></li><li><a href="https://codeclimate.com/">Software Engineering Intelligence</a></li><li><a href="https://travis-ci.org/">Home - Travis-CI</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8164b99777a4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TypeScript: Вывод типов]]></title>
            <link>https://medium.com/@sergey.bakaev/typescript-%D0%B2%D1%8B%D0%B2%D0%BE%D0%B4-%D1%82%D0%B8%D0%BF%D0%BE%D0%B2-c718e951da7d?source=rss-5401fa6ede55------2</link>
            <guid isPermaLink="false">https://medium.com/p/c718e951da7d</guid>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Sergey Bakaev]]></dc:creator>
            <pubDate>Thu, 05 Apr 2018 18:39:22 GMT</pubDate>
            <atom:updated>2018-04-05T18:39:22.517Z</atom:updated>
            <content:encoded><![CDATA[<p>В TypeScript есть несколько мест, где используется автоматический вывод типа, когда тип данных в явном виде не указан. Рассмотрим простой пример:</p><pre><strong>let</strong> x = 3;</pre><p>В данном случае переменная x будет иметь тип number.</p><p>Вывод типа происходит при инициализации переменных, при установке значений по умолчанию и также при определении типов возвращаемых функциями значений.</p><p>В большинстве случаев вывод типа является очевидным и простым. Однако есть некоторые нюансы.</p><h4>Наиболее подходящий тип</h4><p>Рассмотрим пример:</p><pre><strong>let</strong> x = [0, 1, null];</pre><p>В том случае, когда вывод типа должен осуществляться на основе нескольких выражений, типы этих выражений будут использоваться для вывода “наиболее подходящего типа” данных. В данном примере для первых двух элементов массива типом данных будет являться number, для последнего — null. Поэтому результирующим типом данных для переменной x будет являться тип (number | null)[].</p><p>Теперь рассмотрим другой пример:</p><pre><strong>let</strong> zoo = [<strong>new</strong> Rhino(), <strong>new</strong> Elephant(), <strong>new</strong> Snake()];</pre><p><em>(реализация классов Rhino, Elephant, Snake, Animal здесь опущена)</em></p><p>Согласно правилу “наиболее подходящего типа” типом переменной zoo будет являться тип (Rhino | Elephant | Snake)[].</p><p>Однако в данном случае мы бы хотели, чтобы для всех элементов массива был осуществлен вывод типа Animal, наследниками которого они являются. И этот тип в действительности больше подходит в данном конкретном случае, чем тот, который был выведен автоматически. Поэтому в этом примере мы должны указать явным образом базовый тип данных для переменной zoo:</p><pre><strong>let</strong> zoo: Animal[] = [<strong>new</strong> Rhino(), <strong>new</strong> Elephant(), <strong>new</strong> Snake()];</pre><h3>Контекстный тип</h3><p>Контекстная типизация — это вывод типа “в обратном направлении”, когда, например, на основе описания типа мы можем сделать догадку о том, каким должен быть тип аргументов функции или ее возвращаемого значения. Рассмотрим пример:</p><pre>window.onmousedown = <strong>function</strong>(mouseEvent) {<br>    console.log(mouseEvent.buton);  //&lt;- Ошибка!<br>};</pre><p><em>Здесь намеренно указывается обращение к несуществующему свойству </em><em>mouseEvent.buton.</em></p><p>В этом случае компилятор выдаст сообщение об ошибке, поскольку TypeScript будет определять тип выражения, записанного справа от знака равенства исходя из типа функции window.onmousedown, в котором аргумент функции mouseEvent имеет тип MouseEvent и в котором не описано свойство buton:</p><pre><strong>onmousedown</strong>: (this: Window, ev: <strong>MouseEvent</strong>) =&gt; any;</pre><pre>interface <strong>MouseEvent </strong>extends UIEvent {</pre><pre>readonly altKey: boolean;<br>readonly <strong>button</strong>: number;<br>readonly buttons: number;<br>readonly clientX: number;</pre><pre>...</pre><pre>}</pre><p>Но это все для тех случаев, когда мы явно не указываем тип данных. Если для аргумента функции явно указать тип any, то данный пример будет работать и компилятор не выдаст никаких сообщений. Явное указание типа является более приоритетным, нежели контекстный тип, и он будет всегда игнорироваться, если тип данных указан явным образом.</p><pre>window.onmousedown = <strong>function</strong>(mouseEvent: any) {<br>    console.log(mouseEvent.button);  //&lt;- Никаких ошибок не будет<br>};</pre><p>Контекстная типизация используется во многих случаях. Наиболее распространенные из них включают аргументы вызова функций, присваиваемые выражения (то, что стоит справа от знака равно), конкретизацию типов, поля и свойства объектов и литералы массивов, а также, возвращаемые функциями значения. Также контекстный тип используется при явном указании “наиболее подходящего типа”, как в примере:</p><pre><strong>function</strong> <strong>createZoo</strong>(): <strong>Animal</strong>[] {<br>    <strong>return</strong> [<strong>new</strong> Rhino(), <strong>new</strong> Elephant(), <strong>new</strong> Snake()];<br>}</pre><p>В этом случае при попытке добавить в массив значение, которое не является производным типом от Animal компилятор выдаст сообщение об ошибке. И это все благодаря контекстной типизации.</p><ul><li><a href="http://www.typescriptlang.org/docs/handbook/type-inference.html">Type Inference · TypeScript</a></li><li><a href="https://medium.com/@sergey.bakaev/typescript-1-5-%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%BD%D0%B0%D1%8F-%D1%82%D0%B8%D0%BF%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-contextual-typing-f6a4f177421a">TypeScript 1.5: Контекстная типизация (Contextual Typing)</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c718e951da7d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Перечисления (Enums) в TypeScript]]></title>
            <link>https://medium.com/@sergey.bakaev/%D0%BF%D0%B5%D1%80%D0%B5%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F-enums-%D0%B2-typescript-2c264c6965c2?source=rss-5401fa6ede55------2</link>
            <guid isPermaLink="false">https://medium.com/p/2c264c6965c2</guid>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Sergey Bakaev]]></dc:creator>
            <pubDate>Wed, 27 Sep 2017 16:43:11 GMT</pubDate>
            <atom:updated>2017-09-27T16:43:11.959Z</atom:updated>
            <content:encoded><![CDATA[<p>Перечисления позволяют нам определять набор именованных числовых констант и определяются при помощи ключевого слова enum. Перечисления являются подтипами примитивного типа number.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/747c3d6f20e030fd302cfdd52ae15d51/href">https://medium.com/media/747c3d6f20e030fd302cfdd52ae15d51/href</a></iframe><p>Тело перечисления состоит из нуля или более членов, каждый из которых имеет ассоциированное с ним значение, которое может быть либо постоянным, либо вычисляемым. Постоянным значение будет в случае:</p><ul><li>если значение не определено явно и значение предыдущего члена является постоянным. В этом случае значение будет равно числовому значению предыдущего члена плюс 1. Исключение составляет только первый элемент. Если значение не указано, то оно становится равным 0;</li><li>если элемент перечисления определяется с помощью константного выражения. Такие выражения представляют собой разновидность выражений TypeScript, которые могут быть вычислены на этапе компиляции.</li></ul><p>Выражение перечисления является константным, если:</p><ul><li>это вычисляемый литерал;</li><li>это ссылка на определенное ранее константное значение члена перечисления (может быть даже в другом перечислении). Если элемент определен в том же перечислении, то на него можно ссылаться по имени;</li><li>это константное выражение перечисления, заключенное в скобки;</li><li>содержит унарные операторы +, -, ~;</li><li>содержит бинарные операторы +, -, *, /, %, &lt;&lt;, &gt;&gt;, &gt;&gt;&gt;, &amp;, |, ^. Если результатом выражения будет NaN или Infinity, то будет ошибка компиляции.</li></ul><p>Во всех остальных случаях член перечисления считается вычисляемым и его значение вычисляется во время выполнения программы.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ff49c40219ae7d312fa488a9eb3460a9/href">https://medium.com/media/ff49c40219ae7d312fa488a9eb3460a9/href</a></iframe><p>Перечисления являются реальными объектами, которые существуют в runtime. Поэтому перечисления поддерживают обратное сопоставление значений по имени.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/81c3d8e103b7cec7d9ad5f6989d805b5/href">https://medium.com/media/81c3d8e103b7cec7d9ad5f6989d805b5/href</a></iframe><p>После компиляции мы получим следующий код:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e00d7a1743ea24e449eb639448c4d0c/href">https://medium.com/media/1e00d7a1743ea24e449eb639448c4d0c/href</a></iframe><p>В сгенерированном коде перечисление превращается в объект, который хранит как прямые (name — value), так и обратные (value-name) связи между значением и именем элемента. Члены объекта перечисления по сути являются его свойствами.</p><p>Перечислению можно присвоить значение типа number, и наоборот, однако различные типы перечислений нельзя присваивать и сравнивать друг с другом. Например следующий код приведет к ошибкам компиляции:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a6336d679a2a6dd0104c1e7300a9ac15/href">https://medium.com/media/a6336d679a2a6dd0104c1e7300a9ac15/href</a></iframe><h4>Константные перечисления</h4><p>Для того, чтобы не генерировать дополнительный код и лишние ссылки для доступа к значениям перечислений, можно использовать константные перечисления. Они определяются с помощью ключевого слова const, которое ставится перед enum. Использование константных перечислений увеличивает производительность кода, поскольку вместо элемента перечисления используется ассоциированная с ним константа.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b983f0c620dcf686dc4ad3adec790e80/href">https://medium.com/media/b983f0c620dcf686dc4ad3adec790e80/href</a></iframe><p>Такие перечисления должны иметь только константные выражения и в процессе компиляции ссылки на свойства объекта-перечисления заменяются значениями:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/103e61cb3fd2ac71a854e2f8247e0a3e/href">https://medium.com/media/103e61cb3fd2ac71a854e2f8247e0a3e/href</a></iframe><p>Если сделать данное перечисление обычным, то есть убрать const, то получим:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/888a4378f64dc9c9fc1b85a8bc184ffa/href">https://medium.com/media/888a4378f64dc9c9fc1b85a8bc184ffa/href</a></iframe><p>Рассмотрим еще пример:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2fed2d937e2a164db4843f54dbc6e116/href">https://medium.com/media/2fed2d937e2a164db4843f54dbc6e116/href</a></iframe><p>Теперь посмотрим, как будет выглядеть функция someFunc после компиляции:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c9458b0185cafdeefd00160e3854e041/href">https://medium.com/media/c9458b0185cafdeefd00160e3854e041/href</a></iframe><p>Как видно, вместо элементов перечисления были подставлены соответствующие константы.</p><h4>“Окружающие” перечисления</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/455553e010022e72a38e1fbde8b4b3f3/href">https://medium.com/media/455553e010022e72a38e1fbde8b4b3f3/href</a></iframe><p>Такие перечисления определяются с помощью ключевого слова declare. Они используются для описания формы уже существующих перечислений.</p><p>Отличием таких перечислений является то, что если элемент у такого перечисления не имеет инициализатора, то он считается вычисляемым. В обычных перечислениях — наоборот.</p><p>Компилятор не будет генерировать код для таких перечислений. Это может быть полезным при использовании сторонних библиотек (например jQuery, в которой определен какой-то объект (напр. $) когда вам нужна информация об объекте, но не нужно генерировать код.</p><ul><li><a href="http://www.typescriptlang.org/docs/handbook/enums.html">Enums · TypeScript</a></li><li><a href="https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md">Microsoft/TypeScript</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2c264c6965c2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Обобщения (Generics) в TypeScript]]></title>
            <link>https://medium.com/@sergey.bakaev/%D0%BE%D0%B1%D0%BE%D0%B1%D1%89%D0%B5%D0%BD%D0%B8%D1%8F-generics-%D0%B2-typescript-b32b4aa8f810?source=rss-5401fa6ede55------2</link>
            <guid isPermaLink="false">https://medium.com/p/b32b4aa8f810</guid>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Sergey Bakaev]]></dc:creator>
            <pubDate>Mon, 25 Sep 2017 13:36:00 GMT</pubDate>
            <atom:updated>2017-09-25T13:44:19.549Z</atom:updated>
            <content:encoded><![CDATA[<h3>Введение</h3><p>Одной из важнейших сторон при разработке программного обеспечения является создание компонентов с хорошо продуманной структурой и API. Но не менее важной частью является и возможность повторного использования этих компонентов. Компоненты, умеющие работать с разными наборами данных, предоставляют разработчикам дополнительные возможности при проектировании больших и сложных систем.</p><p>В таких языках, как Java или C#, одним из основных способов создания повторно используемых компонентов является использование обобщений (generics). Обобщения позволяют компоненту работать с различными типами данных в зависимости от потребностей разработчиков.</p><h3>Самый простой пример с обобщениями в TypeScript</h3><p>Для начала напишем функцию “идентичности” (это такая функция, которая возвращает то, что ей было передано в качестве параметра). Без использования обобщений, мы должны определить тип, который принимают аргументы функции и тип возвращаемого значения:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b7341f054802f145a98188abace91aa2/href">https://medium.com/media/b7341f054802f145a98188abace91aa2/href</a></iframe><p>Конечно, в TypeScript мы можем указать any чтобы функцию можно было использовать для любого типа данных:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ec1244f06e51503a1f41f55094457a73/href">https://medium.com/media/ec1244f06e51503a1f41f55094457a73/href</a></iframe><p>Можно сказать, что данная функция и является обобщением, поскольку может работать с любым типом данных. Но в данном случае у нас нет абсолютно никакой информации о типе возвращаемого значения. Например, мы передаем в качестве arg число (number), но мы ничего не знаем о конкретном типе, который вернет функция, поскольку он any.</p><p>При использовании обобщений, мы можем явно указать тип аргумента и тем самым, в рамках нашего примера, определить тип возвращаемого значения. Для этого нам нужно воспользоваться специальной <strong>переменной типа</strong>, которая работает только с типами данных, а не их значениями:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/872236fb61f6c6a4017f8372e44c327e/href">https://medium.com/media/872236fb61f6c6a4017f8372e44c327e/href</a></iframe><p>Мы добавили переменную типа T к нашей функции. Эта переменная позволяет нам указывать конкретный тип при использовании функции. Помимо этого, мы указали и тип возвращаемого значения. И теперь мы знаем, что функция будет возвращать результат с тем же типом данных, что и у переданного аргумента.</p><p>Теперь посмотрим, как можно использовать нашу функцию. Есть два способа это сделать. Рассмотрим первый:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e712df38ee8da4f8848db3f5750f9c6/href">https://medium.com/media/1e712df38ee8da4f8848db3f5750f9c6/href</a></iframe><p>При вызове функции в угловых скобках &lt; &gt; мы явно указали тип данных, с которым будет работать функция.</p><p>Второй способ, — не указывать тип данных в угловых скобках, а просто передать переменную в качестве аргумента в функцию. В этом случае TypeScript задействует механизм, который называется <em>автоматическим выводов типа</em>, согласно значению, переданному в качестве аргумента.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8e85716e8ae15f4725b903939610e75d/href">https://medium.com/media/8e85716e8ae15f4725b903939610e75d/href</a></iframe><p>Второй способ, с одной стороны, делает код короче, его легче читать, но, с другой стороны, это может привести к ошибкам. Ведь в этом случае можно передать в функцию значение, которого там не ожидается, и это может привести к ошибке во время выполнения.</p><h3>Работа с обобщенными переменными типа</h3><p>При использовании обобщений, компилятор подразумевает, что обобщенные параметры, переданные в функцию, используются правильно. Фактически, компилятор трактует их как “любой тип данных” или any.</p><p>Снова рассмотрим функцию из предыдущего раздела:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/872236fb61f6c6a4017f8372e44c327e/href">https://medium.com/media/872236fb61f6c6a4017f8372e44c327e/href</a></iframe><p>Что, если мы в качестве аргумента передали массив и теперь хотим вывести в консоль его длину?:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1390066ae57d89c441095d16cf42ca1d/href">https://medium.com/media/1390066ae57d89c441095d16cf42ca1d/href</a></iframe><p>В таком случае компилятор выдаст сообщение об ошибке. Ведь помимо массива, например, мы можем передать в эту функцию число (number), а у числа нет свойства length.</p><p>Как же быть в ситуации, когда нам все-таки необходимо иметь доступ к свойству массиваlength. Нужно переписать объявление функции, указав, что мы работаем именно с массивами T[], а не с любыми типами данных. При этом тип элементов массива по прежнему может быть любым:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ffff39430034a90836ed8d27fbbf3ca7/href">https://medium.com/media/ffff39430034a90836ed8d27fbbf3ca7/href</a></iframe><p>В данном примере мы по прежнему указываем, что функция работает с переменными типа T, но в качестве аргумента и возвращаемого значения используется массив значений этого типа. Можно сказать в данном случае, что мы используем T для указания “части” типа, передаваемого в функцию, что дает нам определенную гибкость.</p><p>Функцию, описанную выше, мы также можем переписать с использованием обобщенного типа данных Array&lt;T&gt; языка TypeScript:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/242ea298688e3ee274c94b8785607145/href">https://medium.com/media/242ea298688e3ee274c94b8785607145/href</a></iframe><h3>Обобщенные типы</h3><p>В этом разделе мы рассмотрим, как создавать обобщенные типы функций и обобщенные интерфейсы.</p><p>Определение обобщенного типа функции очень похоже на определение типа для обычной функции. Отличием является лишь то, что нужно сначала указать тип передаваемых параметров и возвращаемого значения, как и при создании обобщенной функции:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3fb58343fcc9c392c4155f79b5cd72e2/href">https://medium.com/media/3fb58343fcc9c392c4155f79b5cd72e2/href</a></iframe><p>Стоит отметить, что символT при создании обобщений можно заменить на любой другой, если это необходимо. Иногда это помогает сделать код более понятным.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7c1e47cfccb72b43e0bf3f4795ffd51d/href">https://medium.com/media/7c1e47cfccb72b43e0bf3f4795ffd51d/href</a></iframe><p>В данном примере использование U вместо T не очень правильно с точки зрения принятых стандартов программирования. Правильно называть обобщенный тип так, чтобы он всегда начинался с символа T (что означает тип — Type).</p><p>Тип обобщенной функции также можно записать с использованием объектного литерала:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5e2f8e7fb4de482f43895df0256ea664/href">https://medium.com/media/5e2f8e7fb4de482f43895df0256ea664/href</a></iframe><p>По сути, это и есть обобщенный интерфейс. Давайте возьмем этот литерал и превратим в интерфейс:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/22c38b2a398ea161f8fd4ec07b71d16d/href">https://medium.com/media/22c38b2a398ea161f8fd4ec07b71d16d/href</a></iframe><p>Более того, мы можем указать обобщенный тип для всего интерфейса, что сделает этот параметр доступным для всех его методов. После этого мы сможем использовать обобщенную версию интерфейса, указывая конкретный тип данных (например, Dictionary&lt;string&gt; вместо Dictionary):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6f47ae0b5df3bccbd2386d65a7cfc282/href">https://medium.com/media/6f47ae0b5df3bccbd2386d65a7cfc282/href</a></iframe><p>Заметьте, что здесь уже вместо описания обобщенной функции будет описана обычная функция, которая является частью обобщенного типа. Это происходит, когда мы явно указываем тип аргумента Number при объявлении интерфейса и вместо identity&lt;T&gt; у нас будет identity&lt;Nubmer&gt;.</p><h3>Обобщенные классы</h3><p>Обобщенные классы описываются примерно также, как и обобщенные интерфейсы. Рассмотрим простой пример такого класса:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ba9c4a8f706055cc81967c4638df9b1d/href">https://medium.com/media/ba9c4a8f706055cc81967c4638df9b1d/href</a></iframe><p>Поскольку это обобщенный класс, никто не запрещает нам вместо number использовать любой другой тип, например, string:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/be4923d5661c411e879269deab4755d5/href">https://medium.com/media/be4923d5661c411e879269deab4755d5/href</a></iframe><p>Как и в обобщенном интерфейсе, объявление параметра типа в названии класса говорит нам о том, что все свойства класса будут работать с данным типом данных.</p><p><a href="https://medium.com/@sergey.bakaev/%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D1%8B-%D0%B2-typescript-b6e2e0e86864">В статье о классах языка TypeScript</a> говорилось, что класс условно можно подразделить на две части: статическую и сам экземпляр. Так вот обобщения относятся только к части экземпляра класса. Статические же свойства не могут использовать параметр типа, указываемый в названии класса.</p><h3>Ограничения обобщений</h3><p>Давайте вспомним пример, рассмотренный выше в этой статье:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1390066ae57d89c441095d16cf42ca1d/href">https://medium.com/media/1390066ae57d89c441095d16cf42ca1d/href</a></iframe><p>В этом примере мы не могли получить доступ к свойству length, поскольку было неизвестно, будет ли оно у передаваемого типа при вызове функции. Тогда мы решили проблему, указав, что в качестве аргумента у нас подразумевается массив T[].</p><p>А что если есть еще такой тип данный, у которого есть такое же свойство и он не является массивом? Для решения этой проблемы TypeScript позволяет нам накладывать ограничения на обобщенные типы, т.е. мы можем указать для переменной типа базовый класс или интерфейс. Это будет означать, что в данную функцию можно будет передавать только удовлетворяющие установленным ограничениям типы данных.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9ac4083ef43210d79daae157701b97fe/href">https://medium.com/media/9ac4083ef43210d79daae157701b97fe/href</a></iframe><h4>Использование параметров типа в ограничениях</h4><p>Можно определить параметр типа, который будет ограничен типом другого параметра типа. Например, мы хотим получить свойство объекта по его имени. И нам очень не хотелось бы, чтобы мы пытались получить свойство, которого на самом деле не существует. Для этого нужно ввести ограничение на второй параметр типа. Например:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/97a2488a320206a75818b2ce45975ac2/href">https://medium.com/media/97a2488a320206a75818b2ce45975ac2/href</a></iframe><h4>Использование типов классов в обобщениях</h4><p>При создании фабрик объектов в TypeScript с использованием обобщений, необходимо ссылаться на типы классов в функциях-конструкторах. Например:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8841da631649c7c60d32019926b2176d/href">https://medium.com/media/8841da631649c7c60d32019926b2176d/href</a></iframe><p>В следующем примере показано как накладывать ограничения на типы создаваемых с помощью фабрики классов:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/34b427970c26a39646d3d430bac432cb/href">https://medium.com/media/34b427970c26a39646d3d430bac432cb/href</a></iframe><h3>Примечание</h3><p>В русскоязычной литературе по языкам программирования, в которых есть обобщения (например, C#), <em>Generics </em>чаще всего переводят как раз как “<em>обобщения</em>”. И, как правило, так учат в ВУЗах. Лично мне ближе использование слова “<em>дженерики</em>” вместо “<em>обобщения</em>”. На мой взгляд это более понятно и правильно.</p><p><a href="http://www.typescriptlang.org/docs/handbook/generics.html">Generics · TypeScript</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b32b4aa8f810" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Функции в языке TypeScript]]></title>
            <link>https://medium.com/@sergey.bakaev/%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B8-%D0%B2-%D1%8F%D0%B7%D1%8B%D0%BA%D0%B5-typescript-1cb853e09020?source=rss-5401fa6ede55------2</link>
            <guid isPermaLink="false">https://medium.com/p/1cb853e09020</guid>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Sergey Bakaev]]></dc:creator>
            <pubDate>Tue, 19 Sep 2017 19:16:52 GMT</pubDate>
            <atom:updated>2017-09-19T19:16:52.946Z</atom:updated>
            <content:encoded><![CDATA[<h3>Введение</h3><p>Функции — это одна из фундаментальных основ любого приложения на языке JavaScript. С помощью них строятся уровни абстракции, классы, сокрытие информации и модули. В TypeScript есть классы, пространства имен, модули, но функции при всем этом играют ключевую роль. Язык TypeScript немного расширяет возможности функций по сравнению с JavaScript, делая работу с ними еще удобнее.</p><h3>Функции</h3><p>Как и в JavaScript, функции в TypeScript могут быть как именованные, так и анонимные. Это позволяет вам выбрать наиболее удобный подход для разработки вашего приложения, будь то выстраивание списка в функций в API, либо вкладывая одну функцию в другую.</p><p>Рассмотрим простой пример именованной и анонимной функции:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0251551d6e3915bab7ccc1f9a4a2c4d6/href">https://medium.com/media/0251551d6e3915bab7ccc1f9a4a2c4d6/href</a></iframe><p>Функции могут использовать переменные, определенные вне тела функции. В этом случае говорят, что функция <em>захватывает </em>эти переменные. Понимание того, как это происходит, выходит за рамки данной статьи. Но вы должны понимать, как работает этот механизм, поскольку это очень важная часть при работе с JavaScript и TypeScript.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a6c01e3faa86ed915310aa37625bb8ad/href">https://medium.com/media/a6c01e3faa86ed915310aa37625bb8ad/href</a></iframe><h3>Функциональные типы</h3><p>Добавим типы для функций из первого примера:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d829d20a81b72e1a7f6a61fa07d5205e/href">https://medium.com/media/d829d20a81b72e1a7f6a61fa07d5205e/href</a></iframe><p>Как видно, мы добавили типы не только к параметрам, передаваемым в функцию, но и на возвращаемое функцией значение.</p><p>Теперь опишем полный тип этой функции:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6ac8c4ce8af6646072db147819f00bf1/href">https://medium.com/media/6ac8c4ce8af6646072db147819f00bf1/href</a></iframe><p>Функциональный тип состоит из двух частей: типов аргументов и типом возвращаемого значения. Тип возвращаемого значения определяется после =&gt;. В том случае, если функция не возвращает никакого значения, должно быть указано void.</p><p>Также в примере выше мы изменили названия параметров, передаваемых в функцию. Это сделано для лучшей читабельности кода. Нужно стараться всегда давать “говорящие” или понятные имена параметрам. Так будет легче другим читать ваш код, также как и вам, когда вернетесь к нему спустя какое-то время.</p><p>Стоит отметить, что только параметры, передаваемые в функцию и возвращаемое значение определяют ее тип. Захваченные переменные не входят в описание типа. Поэтому они являются частью некого “скрытого состояния” функции и не входят в API.</p><h4>Вывод типов</h4><p>Рассмотрим пример:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/379bbf3cd438d04c5718a72074a84bc4/href">https://medium.com/media/379bbf3cd438d04c5718a72074a84bc4/href</a></iframe><p>TypeScript может автоматически вычислять тип, если вы описали типы в одной части выражения, а в другой — нет. Это называется “контекстной типизацией” . Это помогает упростить код и в тоже время поддерживать код типизированным.</p><h3>Необязательные параметры и параметры по умолчанию</h3><p>При вызове функции, в нее нужно передавать все описанные параметры. Это не означает, что вы не можете передать вместо значения параметраnull или undefined, но в любом случае компилятор проверит количество параметров, переданных в функцию с ее описанием. Помимо этого, компилятор также убедится, что тип параметров соответствует описанным типам данных.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6e034d7a894f4443b0823c09c39b0a6f/href">https://medium.com/media/6e034d7a894f4443b0823c09c39b0a6f/href</a></iframe><p>В Javascript, каждый параметр, передаваемый в функцию, является необязательным. Если он не указан, то передается undefined. Для того, чтобы добавить данную возможность в TypeScript, нужно поставить ? в конце имени параметра перед :. Например:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0fbbc0d41291c01af7cc825a629d4501/href">https://medium.com/media/0fbbc0d41291c01af7cc825a629d4501/href</a></iframe><p>Необязательные параметры всегда должны следовать после обязательных при описании функции. Нельзя сделать первый параметр необязательным, а второй — наоборот. Если необходимо именно первый параметр сделать необязательным, то нужно поменять их местами при описании функции.</p><p>В языке TypeScript также можно задать <strong>значение параметра по умолчанию</strong>, которое будет передано в функцию, если значение будет не указано или вместо него будет передано undefined. Например:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/eae3bc33f9482661ecbfec9744049931/href">https://medium.com/media/eae3bc33f9482661ecbfec9744049931/href</a></iframe><p>Параметры по умолчанию, которые идут после всех обязательных параметров в описании функции, являются необязательными и могут не указываться при вызове функции. В данном конкретном случае их отличием от необязательных параметров, описанных выше, является наличие значения по умолчанию.</p><p>Таким образом, функции</p><pre><strong>function</strong> <strong>concat</strong>(s1: string, s2?: string) { //... }<br>и<br><strong>function</strong> <strong>concat</strong>(s1: string, s2 = &quot;string2&quot;) { //... }</pre><p>имеют один и тот же тип: (s1: string, s2?: string) =&gt; string.</p><p>Однако в отличие от необязательных параметров, параметры по умолчанию не обязательно должны следовать после обязательных. Они могут идти и до обязательных, но в этом случае, если пользователь хочет пропустить такой параметр и использовать значение по умолчанию, то вместо значения следует указать undefined. Например:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f1c92455cd591d7debe3ef270da4b3b4/href">https://medium.com/media/f1c92455cd591d7debe3ef270da4b3b4/href</a></iframe><h3>Оставшиеся (Rest) параметры</h3><p>Об обязательных, необязательных и параметрах по умолчанию говорится в контексте только одного конкретного параметра. Но иногда требуется работать сразу с несколькими параметрами, как с группой, поскольку, например, вы можете не знать сколько параметров должна принимать функция. В JavaScript можно работать с набором таких параметров, используя одну переменную, передаваемую в функцию, используя оператор расширения …(<a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a>). Например:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4d42b499ee9115b5b1392bf4c337f748/href">https://medium.com/media/4d42b499ee9115b5b1392bf4c337f748/href</a></iframe><p><em>Оставшиеся параметры </em>представляют собой неограниченное число необязательных параметров. Можно передавать сколько угодно таких параметров, разделяя их запятой. Компилятор построит массив, в котором будут находится все переданные значения, и передаст его в функцию в качестве параметра. В самой функции с этим набором можно работать как с обычным массивом.</p><p>Функция, описанная выше, будет иметь тип:<br>(fname: string, …rest: string[]) =&gt; string;</p><h3>this</h3><p>При использовании this внутри функций JavaScript вы должны четко понимать, на что в данный момент эта переменная ссылается. Ну а поскольку TypeScript — надстройка над JavaScript, разработчикам также необходимо знать, как правильно пользоваться этой переменной. К счастью, TypeScript позволяет отлавливать неправильное использование this.</p><h4>this and arrow functions</h4><p>В языке JavaScript this — это переменная, которая инициализируется в момент вызова функции. Это очень мощная и гибкая особенность языка, за которую приходится платить тем, что программист всегда должен помнить про контекст вызова самой функции, понимать, что за значение будет в this. Это может показаться достаточно запутанным, особенно если функция возвращает другую функцию или функция передается в качестве аргумента.</p><p>Рассмотрим пример:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3ab4c4504277b0c0da68b9078f1ab8cd/href">https://medium.com/media/3ab4c4504277b0c0da68b9078f1ab8cd/href</a></iframe><p>В данном примере createCardPicker — это функция, которая возвращает другую функцию. Если запустить пример, то будет получено сообщение об ошибке вместо ожидаемого вывода в консоль. А все потому, что значение this, используемое в функции, созданной в createCardPicker будет установлено в window, хотя подразумевалось, что оно будет равно объекту deck. Потому что мы вызвали cardPicker() отдельно. А в этом случае в значении this будет window(если, конечно, не используется strict mode — в этом случае значением this будет undefined).</p><p>Это можно исправить если использовать в выражении <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Functions/Arrow_functions"><em>“стрелочные функции” (arrow functions)</em></a> из ECMAScript 6. Данные функции захватывают значение this при создании функции, а не при выполнении:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f82088581ee0e13e6abcdfb2ab394071/href">https://medium.com/media/f82088581ee0e13e6abcdfb2ab394071/href</a></iframe><p>Более того, если установить флаг компиляции --noImplicitThis, то вы получите уведомление от компилятора о возможной ошибке.</p><p>В нашем примере this вthis.suits[pickedSuit] имеет тип any.</p><h3>this параметры</h3><p>К сожалению, тип this.suits[pickedSuit] все ещеany. Это потому, что this приходит и функционального выражения внутри литерала объекта. Для того, чтобы это исправить, мы должны явно передать this в качестве параметра. this параметры — “не настоящие, ложные” параметры, которые приходят первыми в списке параметров функции:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/10c096151c181d696b5162829bf6a066/href">https://medium.com/media/10c096151c181d696b5162829bf6a066/href</a></iframe><p>Добавим к нашему примеру описание интерфейсов Card и Deck:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/874e87448963a530f7a266e35809f567/href">https://medium.com/media/874e87448963a530f7a266e35809f567/href</a></iframe><p>Теперь TypeScript знает, что при вызовеcreateCardPicker в качестве this ожидается объект типа Deck. В этом случае флаг --noImplicitThis не приведет к появлению никаких ошибок.</p><h4>this параметры в функциях обратного вызова (callbacks)</h4><p>Вы можете столкнуться с ошибками при использовании this в функциях обратного вызова, когда передаете функцию в библиотеку, которая будет позже ее выполнять. Поскольку библиотека, которая вызывает вашу функцию, вызовет ее как обычную, this будет иметь значение undefined. Однако, используя this в качестве параметра, можно избавиться от ошибок. Первое, что нужно — это чтобы у функции обратного вызова был определен тип с использованием this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/55fa2d4a48b9d645dc9bbfc4af1806de/href">https://medium.com/media/55fa2d4a48b9d645dc9bbfc4af1806de/href</a></iframe><p>this: void означает, что addClickListener ожидает, чтоonclick — функция, которой не требуется тип this. Второе, что вы должны сделать — написать функцию, которая будет передана в addClickListener:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/533e653cd5874d35b00242b096a5c4ce/href">https://medium.com/media/533e653cd5874d35b00242b096a5c4ce/href</a></iframe><p>Согласно описанию, функция onClickBad должна быть вызвана как экземпляр Handler. После этого TypeScript определит, что addClickListener принимает функцию с описанием this: void, что приведет к ошибке. Для того, чтобы это исправить, нужно поменять тип this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1121e6373e3bfc1e780656537f3d527a/href">https://medium.com/media/1121e6373e3bfc1e780656537f3d527a/href</a></iframe><p>Теперь все в порядке. Но это также означает, что мы не можем использовать this.info. Если все же нам нужно его использовать, то стоит воспользоваться стрелочной функцией:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2510e26f4fa5e698b25e9e4c524f76b2/href">https://medium.com/media/2510e26f4fa5e698b25e9e4c524f76b2/href</a></iframe><p>Этот пример сработает, поскольку стрелочные функции не захватывают this, так что всегда можно передавать такую функцию туда, где ожидается this: void. С одной стороны, стрелочная функция создается для каждого объекта с типом Handler. С другой, — методы создаются только один раз и привязываются к прототипу Handler&#39;a и являются общими для всех объектов типа Handler.</p><h3>Перегрузка</h3><p>В JavaScript не является редкостью, когда одна функция может возвращать различные типы объектов в зависимости от входных параметров. Например:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/103f143d669fa6be1111d928243456d1/href">https://medium.com/media/103f143d669fa6be1111d928243456d1/href</a></iframe><p>Функция pickCard возвращает два различных результата в зависимости от того, что передано в функцию. Если передается объект, который представляет собой колоду карт, функция вернет карту из этой колоды. Если нет, карта сгенерируется случайным образом. Как это можно описать по-другому в TypeScript?</p><p>Нужно использовать перегрузку функций. Перегрузка функций — это набор одноименных функций с разным набором параметров. Перепишем пример, рассмотренный выше:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e5160a55a5ad8545abd577119b67e58f/href">https://medium.com/media/e5160a55a5ad8545abd577119b67e58f/href</a></iframe><p>Теперь мы можем вызывать функции с проверкой типов передаваемых аргументов.</p><p>Компилятор при выборе нужной функции действует аналогично JavaScript. Он смотрит на список перегруженных функций и пробует вызвать первую. Если удачно, то это корректная перегрузка. Если нет — идет дальше. Поэтому важно указывать перегрузки в порядке, начиная от наиболее часто используемой.</p><p>Стоит также отметить, что function pickCard(x): any не входит в список перегрузок. В нашем примере только две перегрузки функции: одна принимает объект, другая — число. Попытка вызвать функцию pickCard с другими параметрами приведет к ошибке.</p><ul><li><a href="http://www.typescriptlang.org/docs/handbook/functions.html">Functions · TypeScript</a></li><li><a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Стрелочные функции</a></li><li><a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Spread_operator">Spread</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1cb853e09020" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Классы в TypeScript]]></title>
            <link>https://medium.com/@sergey.bakaev/%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D1%8B-%D0%B2-typescript-b6e2e0e86864?source=rss-5401fa6ede55------2</link>
            <guid isPermaLink="false">https://medium.com/p/b6e2e0e86864</guid>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Sergey Bakaev]]></dc:creator>
            <pubDate>Wed, 13 Sep 2017 19:25:28 GMT</pubDate>
            <atom:updated>2017-09-13T19:25:28.079Z</atom:updated>
            <content:encoded><![CDATA[<h3>Введение</h3><p>В традиционном JavaScript для построения повторно используемых компонентов применяются функции и наследование на прототипах. Это может показаться несколько сложным для программистов, которым ближе объектно-ориентированный подход, где классы могут наследовать функционал класса-родителя. Начиная с ECMAScript 6, JavaScript также позволяет использовать объектно-ориентированный подход, но потом все равно придется применять различные конвертеры из ECMAScript 6 в традиционный JavaScript, поскольку новые форматы языка не везде поддерживаются. TypeScript позволяет использовать эти преимущества разработки уже сейчас, а компилятор сам позаботится о том, чтобы превратить код в формат, который будут поддерживать все основные браузеры.</p><h3>Простой пример класса</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/59dae5a7d02f69aff2213e75e4da354b/href">https://medium.com/media/59dae5a7d02f69aff2213e75e4da354b/href</a></iframe><p>Синтаксис может показаться очень знакомым, если ранее вы использовали C# или Java. В данном примере мы определили класс Greeter. Он имеет три члена: свойство greeting, конструктор и метод greet.</p><p>Для доступа к членам класса внутри него самого нужно использовать ключевое слово this перед именем свойства или метода.</p><p>В последней строке примера мы создаем экземпляр класса Greeter, используя ключевое слово new. Далее указываем конструктор, определенный ранее в классе и передаем туда параметр message.</p><h3>Наследование</h3><p>Одним из основных шаблонов объектно-ориентированного программирования является наследование классов. С помощью него можно создавать новые классы на основе существующих.</p><p>Рассмотрим пример:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5d323987e93fbb2d22eb53d913b798ae/href">https://medium.com/media/5d323987e93fbb2d22eb53d913b798ae/href</a></iframe><p>Ключевое слово extends используется для создания подкласса на основе другого класса, который еще называют базовым. В нашем примере Shape — базовый класс, а Circle и Rect являются его подклассами. Производные классы получают доступ к методам и свойствам базового класса.</p><p>В конструкторе производного класса <strong>обязательно должен </strong>быть вызван метод super(), который вызовет конструктор базового класса. В противном случае компилятор выдаст сообщение об ошибке.</p><p>Данный пример также демонстрирует, как осуществляется переопределение методов базового класса. Классы Circle и Rect переопределяют метод translate(point: Point), позволяя изменять поведение метода. Обратите внимание, что экземпляр класса Rect объявлен как let rect: Shape, т.е. имеет тип Shape, но при вызове translate() будет вызван метод, переопределенный в производном классе.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/528/1*p4oUNblnte1dF_CInegxvQ.png" /><figcaption>Результат работы программы</figcaption></figure><p>Для вызова метода базового класса, также как и для конструктора, используется ключевое слово super. При этом, в отличие от конструктора, оно не является обязательным. В этом случае можно сказать, что переопределенный метод полностью скрывает функционал базового метода.</p><h3>Модификаторы доступа (public, protected, private)</h3><h4>public по умолчанию</h4><p>В примере выше, мы имели доступ ко всем свойствам и методам классов. Если вы знакомы с другими языками объектно-ориентированного программирования, то это могло показаться вам немного странным. Ведь для этого вам пришлось бы использовать ключевое слово public, как, например, в языке C#. В языке TypeScript все свойства и методы являются публичными по умолчанию.</p><p>Однако ничего не мешает вам указывать публичность метода или свойства явно. Например, для класс Shape из примера выше мы могли бы переписать следующим образом:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0fbde0839f785dc1c6260868d83fc3df/href">https://medium.com/media/0fbde0839f785dc1c6260868d83fc3df/href</a></iframe><h4>Модификатор private</h4><p>Если член класса помечен как private, то он будет доступен только в пределах самого класса. Например:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ab2d175167c695475863df6f037b1dad/href">https://medium.com/media/ab2d175167c695475863df6f037b1dad/href</a></iframe><p>Язык TypeScript — это структурная система типов. Когда сравниваются два различных типа, то даже несмотря на то, что неизвестно откуда они взяты, если типы всех членов совместимы, то можно говорить о совместимости самих типов друг с другом.</p><p>Однако все обстоит несколько иначе с теми типами, которые имеют модификаторы доступа, такие как private и protected. Если один тип имеет private поле, то для того, чтобы два типа были совместимы, второй тип должен иметь такое же поле, объявленное точно там же, где и у первого. Проще пояснить на примере:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7fb68390390a987519f3317ab64bff2a/href">https://medium.com/media/7fb68390390a987519f3317ab64bff2a/href</a></iframe><p>Даже несмотря на то, что класс OtherShape имеет точно такую же структуру, как и Shape, присвоение переменной shape экземпляра ExtendedShape вызовет ошибку компиляции.</p><p>Все сказанное выше относится и к модификатору protected.</p><h4>Модификатор protected</h4><p>Данный модификатор отличается от private тем, что определенные с помощью него члены класса, будут доступны в производных классах.</p><p>Рассмотрим пример:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8076fe8e76fa4a9b3487abe60d54b9ab/href">https://medium.com/media/8076fe8e76fa4a9b3487abe60d54b9ab/href</a></iframe><p>В производном классе Circle у нас есть доступ к переменной center, однако вне класса обращение к ней вызовет ошибку компиляции.</p><p>Конструктор также может быть помечен модификатором protected. В этом случае класс не может быть инициализирован, но может быть унаследован. Например:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6bb517819b665748ffed6c5c6eec8ea5/href">https://medium.com/media/6bb517819b665748ffed6c5c6eec8ea5/href</a></iframe><h4>Модификатор readonly</h4><p>Можно сделать свойства класса доступными только для чтения. Для этих целей предназначен модификатор readonly. Такие свойства могут быть инициализированы только в конструкторе:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6289bf184cdf3b3533a08c8ff4c11a8e/href">https://medium.com/media/6289bf184cdf3b3533a08c8ff4c11a8e/href</a></iframe><p>readonly можно использовать совместно с private, public и protected. Например, если нужно сделать доступным только для чтения закрытое (private) свойство класса, то нужно написать private readonly prop: SomeType:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cfdd88767cee8d108c0e83b850fc27a0/href">https://medium.com/media/cfdd88767cee8d108c0e83b850fc27a0/href</a></iframe><h4>Свойства — параметры (конструктора)</h4><p>В предыдущем примере мы определили свойство name, доступное только для чтения, а затем инициализировали его в конструкторе. Это достаточно распространенная практика. Однако, используя свойства-параметры, можно создать и инициализировать свойство в одном месте — параметре конструктора:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/587b4254e0f7ffcc2ce11a95997314aa/href">https://medium.com/media/587b4254e0f7ffcc2ce11a95997314aa/href</a></iframe><p>Данное определение класса будет полностью аналогично определению из примера выше.</p><p>Также можно использовать и другие модификаторы для создания свойств. Например, если вместо readonly использовать private, то будет создано закрытое свойство класса.</p><h3>Методы доступа (Accessors)</h3><p>TypeScript поддерживает геттеры и сеттеры для того, чтобы перехватить доступ к свойствам объектов. Это позволяет нам более тщательно контролировать доступ к свойствам объекта.</p><p>Рассмотрим пример использования геттеров и сеттеров. Для начала начнем с класса без них:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6c3cf648b6575e4af9a7d87c974d87cd/href">https://medium.com/media/6c3cf648b6575e4af9a7d87c974d87cd/href</a></iframe><p>В данном примере пользователь может менять значения свойства name в любом месте и когда захочет.</p><p>Но что если нам нужно ограничить доступ к установке нового значения этого свойства. Скажем, его можно установить только если оно удовлетворяет определенным критериям, например, не может быть равно some name. Помимо этого мы хотим, чтобы при получении значения свойства (даже если значение не было установлено), возвращалась пустая строка вместо undefined. Для всего этого удобно использовать геттеры и сеттеры.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/30b779d4f855106ede7da24c328a8512/href">https://medium.com/media/30b779d4f855106ede7da24c328a8512/href</a></iframe><p>Для работы геттеров и сеттеров должен быть установлен ECMAScript5 или выше в качестве выходного формата компиляции в JavaScript.</p><p>Свойства, которые имеют только геттер автоматически интерпретируются как readonly. Это может быть полезным при генерации .d.ts файла, чтобы пользователи видели, что эти свойства доступны только для чтения и их значения нельзя изменять.</p><h3>Статичные свойства</h3><p>Статичные свойства — это свойства, значения которых одинаковы для всех экземпляров класса. Определяются такие свойства с помощью ключевого слова static. Доступ к таким свойствам осуществляется по шаблону &lt;ClassName&gt;.&lt;PropertyName&gt;.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ac0825fdb5e4d90fe4e55b5e62532361/href">https://medium.com/media/ac0825fdb5e4d90fe4e55b5e62532361/href</a></iframe><h3>Абстрактные классы</h3><p>Абстрактные класс — это базовый класс, на основе которого могут быть созданы другие классы при помощи наследования. В отличие от обычных классов, экземпляр абстрактного создать нельзя. Для объявления абстрактного класса используется ключевое слово abstract. Тоже самое применимо и для методов и свойств.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7c6c3111f2db4f05de50556bf0f9ec30/href">https://medium.com/media/7c6c3111f2db4f05de50556bf0f9ec30/href</a></iframe><p>Абстрактные методы не должны быть реализованы и должны быть переопределены в производном классе. Они похоже по синтаксису на определение методов в интерфейсе. И интерфейс, и абстрактный класс определяют сигнатуру метода без реализации, но абстрактные методы должны быть определены с помощью ключевого слова abstract и могут иметь модификаторы доступа.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fef1d71f11abb17bb79ec3126a6f309c/href">https://medium.com/media/fef1d71f11abb17bb79ec3126a6f309c/href</a></iframe><h3>Дополнительно</h3><h4>Функции конструктора</h4><p>Рассмотрим пример:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/38d748b9470e4beb7eaa070f3574dee1/href">https://medium.com/media/38d748b9470e4beb7eaa070f3574dee1/href</a></iframe><p>Что же происходит в этом примере? Сначала мы определяем тип, который будут иметь экземпляры класса — SomeClass. Затем мы определяем переменную, которая будет экземпляром SomeClass. Также помимо этого мы создаем <em>функцию конструктора</em>, которая будет выполнена, когда мы с помощью ключевого слова new создадим экземпляр класса. Для лучшего понимания посмотрим на скомпилированный код из нашего примера:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/701e0c581a2266e11f0f398033e37680/href">https://medium.com/media/701e0c581a2266e11f0f398033e37680/href</a></iframe><p>Как видно из кода выше, переменной greeter присваивается функция конструктора. Затем с помощью new эта функция вызывается и таким образом создается экземпляр класса. Функция конструктора также будет содержать все статические члены класса. Можно сказать, что класс состоит из статической части и части экземпляра класса.</p><h4>Использование класса в качестве интерфейса</h4><p>Поскольку класс представляет собой тип данных с определенной структурой, можно использовать его так, как будто это интерфейс. Например:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/269b6308ecae18c6ffbba20ff0ac328d/href">https://medium.com/media/269b6308ecae18c6ffbba20ff0ac328d/href</a></iframe><h3>Ссылки</h3><p><a href="http://www.typescriptlang.org/docs/handbook/classes.html">Classes · TypeScript</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6e2e0e86864" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Интерфейсы в TypeScript]]></title>
            <link>https://medium.com/@sergey.bakaev/%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81%D1%8B-%D0%B2-typescript-5ac4ae1de797?source=rss-5401fa6ede55------2</link>
            <guid isPermaLink="false">https://medium.com/p/5ac4ae1de797</guid>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Sergey Bakaev]]></dc:creator>
            <pubDate>Thu, 27 Oct 2016 17:19:28 GMT</pubDate>
            <atom:updated>2018-11-10T07:52:07.192Z</atom:updated>
            <content:encoded><![CDATA[<h3>Введение</h3><p>Одним из ключевых принципов языка TypeScript является проверка типов, сфокусированная на форме, которую имеют значения. Иногда этот принцип называют “утиной типизацией” или “структурным подтипированием”. Интерфейсы в TypeScript играют роль именования типов и являются мощным способом определения контрактов в коде.</p><h3>Пример интерфейса</h3><p>Для того, чтобы понять что такое интерфейсы и как с ними работать, рассмотрим пример:</p><pre><strong>function</strong> <strong>printLabel</strong>(labelledObj: { label: string }) {<br>    console.log(labelledObj.label);<br>}</pre><pre><strong>let</strong> myObj = {size: 10, label: &quot;Size 10 Object&quot;};<br>printLabel(myObj);</pre><p>Анализатор типов проверяет вызов функции <strong><em>printLabel</em></strong>. Данная функция имеет один параметр, который должен являться объектом и иметь свойство <strong><em>label </em></strong>с типом <strong><em>string</em></strong>. Стоит отметить, что объект, передаваемый в качестве параметра функции, может иметь и другие свойства, но компилятор проверяет только наличие указанных свойств и совпадение их типов. Однако в некоторых случаях, TypeScript не будет столь снисходителен, в чем мы убедимся позднее.</p><p>Теперь мы можем переписать тот же самый пример уже с использованием интерфейса. Как мы уже знаем это должен быть объект, у которого должно быть определено свойство <strong><em>label </em></strong>с типом <strong><em>string</em></strong>.</p><pre><strong>interface</strong> LabelledValue {<br>    label: string;<br>}</pre><pre><strong>function</strong> <strong>printLabel</strong>(labelledObj: LabelledValue) {<br>    console.log(labelledObj.label);<br>}</pre><pre><strong>let</strong> myObj = {size: 10, label: &quot;Size 10 Object&quot;};<br>printLabel(myObj);</pre><p>Интерфейс <strong><em>LabeledValue </em></strong>— это имя, которое мы теперь можем использовать для описания требований параметра. Стоит отметить, что по сравнению с другими языками программирования, мы не можем сказать, что объект, который мы передаем в функцию <strong>printLabel</strong>, реализует интерфейс <strong><em>LabeledValue</em></strong>. В этом случае это просто форма, которую объект должен иметь. Если объект, передаваемый в функцию удовлетворяет описанным условиям, то он проходит проверку.</p><p>Анализатор типов языка TypeScript не требует, чтобы свойства объекта были отсортированы в определенном порядке (как указано в интерфейсе). Проверяется только наличие свойства и его тип.</p><h3>Необязательные свойства</h3><p>Не всегда все свойства интерфейса являются обязательными. Некоторые нужны только при определенных условиях. Необязательные свойства могут использоваться, например, когда объект, передаваемый в функцию, имеет только часть заполненных свойств.</p><p>Рассмотрим пример:</p><pre><strong>interface</strong> SquareConfig {<br>    color?: string;<br>    width?: number;<br>}</pre><pre><strong>function</strong> <strong>createSquare</strong>(config: SquareConfig): {color: string; area: number} {<br>    <strong>let</strong> newSquare = {color: &quot;white&quot;, area: 100};<br>    <strong>if</strong> (config.color) {<br>        newSquare.color = config.color;<br>    }<br>    <strong>if</strong> (config.width) {<br>        newSquare.area = config.width * config.width;<br>    }<br>    <strong>return</strong> newSquare;<br>}</pre><pre><strong>let</strong> mySquare = createSquare({color: &quot;black&quot;});</pre><p>Интерфейсы с необязательными свойствами записываются также, как и обычные, за исключением того, что на конце имени каждого свойства ставится знак <strong><em>?</em></strong>.</p><p>Преимуществом необязательных свойств является возможность описать все доступные свойства интерфейса и предотвратить использование свойств, которые не являются частью данного интерфейса. Например, если попытаться использовать свойство с именем, которого нет в интерфейсе, то мы получим соответствующее сообщение об ошибке.</p><pre><strong>interface</strong> SquareConfig {<br>    color?: string;<br>    width?: number;<br>}</pre><pre><strong>function</strong> <strong>createSquare</strong>(config: SquareConfig): { color: string; area: number } {<br>    <strong>let</strong> newSquare = {color: &quot;white&quot;, area: 100};<br>    <strong>if</strong> (config.color) {<br>        // Ошибка: Свойство &#39;collor&#39; не существует <br>        // в интерфейсе &#39;SquareConfig&#39;<br>        newSquare.color = config.collor;<br>    }<br>    <strong>if</strong> (config.width) {<br>        newSquare.area = config.width * config.width;<br>    }<br>    <strong>return</strong> newSquare;<br>}</pre><pre><strong>let</strong> mySquare = createSquare({color: &quot;black&quot;});</pre><h3>Свойства только для чтения</h3><p>Некоторые свойства должны изменяться один раз при создании объекта. Этого можно добиться, поместив ключевое слово <strong><em>readonly </em></strong>перед именем свойства.</p><pre><strong>interface</strong> Point {<br>    readonly x: number;<br>    readonly y: number;<br>}</pre><p>Можно создать переменную c типом <strong><em>Point</em></strong>, присвоив ей литерал объекта. После этого значения свойств <strong><em>x </em></strong>и <strong><em>y </em></strong>изменять будет нельзя.</p><pre><strong>let</strong> p1: Point = { x: 10, y: 20 };<br>p1.x = 5; // error!</pre><p>В TypeScript есть тип <strong><em>ReadonlyArray&lt;T&gt;</em></strong>, который по сути тоже самое что и <strong><em>Array&lt;T&gt;</em></strong>, но без методов, которые могут изменить массив после создания:</p><pre><strong>let</strong> a: number[] = [1, 2, 3, 4];<br><strong>let</strong> ro: ReadonlyArray&lt;number&gt; = a;<br>ro[0] = 12; // error!<br>ro.push(5); // error!<br>ro.length = 100; // error!<br>a = ro; // error!</pre><p>В последней строчке примера видно, что даже присваивание целого <strong><em>ReadonlyArray </em></strong>к нормальному массиву недопустимо. Однако это можно сделать через приведение типов:</p><pre>a = ro as number[];</pre><h3>readonly vs const</h3><p>Когда использовать <strong><em>readonly</em></strong>, а когда <strong><em>const</em></strong>? Для переменных используется <strong>const</strong>; для свойств — <strong><em>readonly</em></strong></p><h3>Проверка лишних свойств</h3><p>В первом примере данной статьи, TypeScript позволяет нам передать в качестве аргумента конструкцию вида</p><pre>{ size: number; label: string; }</pre><p>Хотя на самом деле ожидается конструкция вида</p><pre>{ label: string }</pre><p>Также мы знаем о необязательных свойствах, которые можно использовать для описания возможных параметров, которые могут быть переданы в функцию.</p><p>Однако, комбинируя два этих подхода ничто не помешает выстрелить себе в ногу, как и в JavaScript. Рассмотрим пример:</p><pre><strong>interface</strong> SquareConfig {<br>    color?: string;<br>    width?: number;<br>}</pre><pre><strong>function</strong> <strong>createSquare</strong>(config: SquareConfig): { color: string; area: number } {<br>    // ...<br>}</pre><pre><strong>let</strong> mySquare = createSquare({ colour: &quot;red&quot;, width: 100 });</pre><p>Заметьте, что в качестве аргумента в функцию <strong><em>createSquare </em></strong>передается литерал объекта, свойство которого называется <strong><em>colour </em></strong>вместо <strong><em>color</em></strong>. В чистом JavaScript, это приведет к ошибке работы программы, но никаких сообщений об этом вы не получите!</p><p>В данном случае можно утверждать, что аргумент передан правильно в функцию: свойство <strong><em>width </em></strong>присутствует в интерфейсе аргумента, свойства <strong><em>color </em></strong>там нет, а свойство <strong><em>colour </em></strong>игнорируется, т.к. его нет в описании интерфейса.</p><p>Но в этом случае TypeScript все равно выдаст сообщение об ошибке. Когда литералы объектов присваиваются к другим переменным или передаются как аргументы, они проходят через <em>проверку лишних свойств</em>. Это значит, что если в литерале объекта есть какое-либо свойство, которого нет у аргумента или переменной, вы получите сообщение об ошибке.</p><pre>// error: &#39;colour&#39; not expected in type &#39;SquareConfig&#39;<br><strong>let</strong> mySquare = createSquare({ colour: &quot;red&quot;, width: 100 });</pre><p>Обойти такое поведение очень просто. Самый простой — использовать приведение типов:</p><pre><strong>let</strong> mySquare = createSquare({ width: 100, opacity: 0.5 } as SquareConfig);</pre><p>Но лучшим решением является использование сигнатуры строкового индекса, если вы уверены, что объект может иметь дополнительные свойства, которые могут быть использованы каким-то особенным образом. Если <strong><em>SquareConfig </em></strong>имеет свойства <strong><em>color </em></strong>и <strong><em>width</em></strong>, но также может иметь любое число других свойств, нужно сделать следующее:</p><pre><strong>interface</strong> SquareConfig {<br>    color?: string;<br>    width?: number;<br>    <strong>[propName: string]: any;</strong><br>}</pre><p>Теперь можно сказать, что <strong>SquareConfig </strong>имеет любое число свойств и если имена этих свойств не <strong><em>color </em></strong>и не <strong><em>width</em></strong>, то их тип — <strong><em>any</em></strong>.</p><p>Есть еще один способ, позволяющий обойти проверку лишних свойств, который может быть немного неожиданным. Это присвоение объекта другой переменной и передача такой переменной в качестве аргумента. В этом случае сообщения об ошибке не будет.</p><pre><strong>let</strong> squareOptions = { colour: &quot;red&quot;, width: 100 };<br><strong>let</strong> mySquare = createSquare(squareOptions);</pre><p>Стоит иметь ввиду, что для простого кода не стоит обходить данные проверки свойств. Для более сложных литералов объектов, которые содержат в себе методы, параметры состояния и др., стоит держать в памяти данные способы обхода проверок, но все же большинство ошибок, связанных с проверкой лишних свойств, как правило, на самом деле являются ошибками. Если у вас возникает такая ошибка, возможно стоит пересмотреть объявление типа.</p><h3>Типы функций</h3><p>Интерфейсы позволяют описывать всевозможные поведения JavaScript объектов. Помимо описания свойств, интерфейсы также позволяют описывать типы функций.</p><p>Для описания типа функции в интерфейсе, в нем нужно определить сигнатуру вызова. Это похоже на объявление функции только со списком параметров и типом возвращаемого значения. Каждый параметр в списке должен иметь имя и тип.</p><pre><strong>interface</strong> SearchFunc {<br>    (source: string, subString: string): boolean;<br>}</pre><p>Определив такой интерфейс один раз, мы можем его использовать также как и все другие интерфейсы. Пример ниже показывает, как определить переменную с типом функции и присвоить ей значение.</p><pre><strong>let</strong> mySearch: SearchFunc;<br>mySearch = <strong>function</strong>(source: string, subString: string) {<br>    <strong>let</strong> result = source.search(subString);<br>    <strong>if</strong> (result == -1) {<br>        <strong>return</strong> false;<br>    }<br>    <strong>else</strong> {<br>        <strong>return</strong> true;<br>    }<br>}</pre><p>Для типов функций имена параметров необязательно должны совпадать для корректной проверки типов. Например, мы можем использовать следующий вариант записи:</p><pre><strong>let</strong> mySearch: SearchFunc;<br>mySearch = <strong>function</strong>(src: string, sub: string): <strong>boolean</strong> {<br>    <strong>let</strong> result = src.search(sub);<br>    <strong>if</strong> (result == -1) {<br>        <strong>return</strong> false;<br>    }<br>    <strong>else</strong> {<br>        <strong>return</strong> true;<br>    }<br>}</pre><p>Параметры функции сравниваются по одному с типом каждого соответствующего параметра, который находится на такой же позиции. Если вы не укажете типы параметров, контекстная типизация языка TypeScript выведет типы аргументов согласно типам, определенным в объявлении интерфейса. Тип возвращаемого значения также выводится из значений, которые возвращает функция. Если функция вернет значение, которое не совпадает с объявленным типом, будет выдано сообщение, что возвращаемый тип не соответствует указанному в объявлении интерфейса.</p><pre><strong>let</strong> mySearch: SearchFunc;<br>mySearch = <strong>function</strong>(src, sub) {<br>    <strong>let</strong> result = src.search(sub);<br>    <strong>if</strong> (result == -1) {<br>        <strong>return</strong> false;<br>    }<br>    <strong>else</strong> {<br>        <strong>return</strong> true;<br>    }<br>}</pre><h3>Индексируемые типы Indexable Types</h3><p>Индексируемые типы имеют сигнатуру, которая описывает, что доступ к значениям объекта может быть получен с использованием индекса определенного типа. Также определяется и возвращаемый тип значения, полученного по индексу. Рассмотрим пример:</p><pre><strong>interface</strong> StringArray {<br>    [index: number]: string;<br>}</pre><pre><strong>let</strong> myArray: StringArray;<br>myArray = [&quot;Bob&quot;, &quot;Fred&quot;];</pre><pre><strong>let</strong> myStr: string = myArray[0];</pre><p>Указанная в StringArray сигнатура говорит нам о том, что при использовании индекса с типом number мы получаем значение, которое имеет тип string.</p><p>Для сигнатур индекса поддерживается только два типа для самого индекса — это string и number. Возможно использование обоих типов для индексов одновременно, но в этом случае тип, возвращаемый числовым индексом должен являться подтипом типа, возвращаемого строковым индексом. Все это потому, что числовой индекс в JavaScript конвертируется в строковое представление перед использованием. Это означает, что числовой индекс 100 — тоже самое, что и строковый индекс “100”</p><pre><strong>class</strong> Animal {<br>    name: string;<br>}<br><strong>class</strong> Dog extends Animal {<br>    breed: string;<br>}</pre><pre>// Error: indexing with a &#39;string&#39; will sometimes get you a Dog!<br><strong>interface</strong> NotOkay {<br>    [x: number]: Animal;<br>    [x: string]: Dog;<br>}</pre><p>С одной стороны, сигнатуры индексов — мощный способ для описания <em>“словарей” (dictionary)</em>, с другой, они обеспечивают соблюдение правило, согласно которому тип всех свойств должен совпадать с типом, который возвращает индекс. Это потому, что свойство объекта <strong><em>obj.property</em></strong> также доступно и по строковому индексу <strong><em>obj[“property”]</em></strong>. В следующем примере тип свойства name не совпадает с типом, который возвращает индекс, что приведет к ошибке:</p><pre><strong>interface</strong> NumberDictionary {<br>    [index: string]: number;<br>    length: number;    // ok, length is a number<br>    name: string;      // error, the type of &#39;name&#39; is not a subtype of the indexer<br>}</pre><p>Сигнатуры индексов можно сделать доступными только для чтения для предотвращения создания новых индексов:</p><pre><strong>interface</strong> ReadonlyStringArray {<br>    readonly [index: number]: string;<br>}<br><strong>let</strong> myArray: ReadonlyStringArray = [&quot;Alice&quot;, &quot;Bob&quot;];<br>myArray[2] = &quot;Mallory&quot;; // error!</pre><h3>Классы</h3><h4>Реализация интерфейса</h4><p>Одним из наиболее распространенных видов использования интерфейсов в таких языках, как C# и Java, является явное указание того, что класс имеет определенный контракт или поведение, также возможно и в TypeScript.</p><pre><strong>interface</strong> ClockInterface {<br>    currentTime: Date;<br>}</pre><pre><strong>class</strong> Clock <strong>implements</strong> ClockInterface {<br>    currentTime: Date;<br>    <strong>constructor</strong>(h: number, m: number) { }<br>}</pre><p>Также можно определять и методы у интерфейса, который реализует класс:</p><pre><strong>interface</strong> ClockInterface {<br>    currentTime: Date;<br>    setTime(d: Date);<br>}</pre><pre><strong>class</strong> Clock <strong>implements</strong> ClockInterface {<br>    currentTime: Date;<br>    setTime(d: Date) {<br>        <strong>this</strong>.currentTime = d;<br>    }<br>    <strong>constructor</strong>(h: number, m: number) { }<br>}</pre><p>Интерфейсы описывают только ту сторону класса, которая будет доступна извне. Скрытые внутри класса детали реализации интерфейс не описывает и не должен этого делать. Польза в том, что вы можете скрыть от использования свойства и методы, использование которых не нужно в контексте данного интерфейса.</p><h4>Различие между статической составляющей класса и его экземпляром</h4><p>Когда вы работаете с классами и интерфейсами, нужно помнить, что у класса есть статическая сторона и сторона реализации (экземпляра) класса. Статическая сторона— это описание полей и методов класса, а сторона реализации — непосредственно экземпляр класса. Когда вы создаете интерфейс с сигнатурой конструктора и пробуете создать класс, который реализует данный интерфейс, то получите сообщение об ошибке:</p><pre><strong>interface</strong> ClockConstructor {<br>    <strong>new</strong> (hour: number, minute: number);<br>}</pre><pre><strong>class</strong> Clock <strong>implements</strong> ClockConstructor {<br>    currentTime: Date;<br>    <strong>constructor</strong>(h: number, m: number) { }<br>}</pre><p>Это происходит потому, что когда класс реализует интерфейс, проверяется только экземпляр класса. А конструктор находится в объявлении самого класса (в его статической составляющей) и не включен в эту проверку.</p><p>Вместо этого, нужно работать с объявлением класса. В следующем примере создаются два интерфейса, <strong><em>ClockConstructor </em></strong>для конструктора и <strong><em>ClockInterface </em></strong>для методов экземпляра. Затем для удобства определяется функция <strong><em>createClock </em></strong>для создания экземпляров передаваемых в нее классов.</p><pre><strong>interface</strong> ClockConstructor {<br>    <strong>new</strong> (hour: number, minute: number): ClockInterface;<br>}<br><strong>interface</strong> ClockInterface {<br>    tick();<br>}</pre><pre><strong>function</strong> <strong>createClock</strong>(ctor: ClockConstructor, hour: number, minute: number): <strong>ClockInterface</strong> {<br>    <strong>return</strong> <strong>new</strong> ctor(hour, minute);<br>}</pre><pre><strong>class</strong> DigitalClock <strong>implements</strong> ClockInterface {<br>    <strong>constructor</strong>(h: number, m: number) { }<br>    tick() {<br>        console.log(&quot;beep beep&quot;);<br>    }<br>}<br><strong>class</strong> AnalogClock <strong>implements</strong> ClockInterface {<br>    <strong>constructor</strong>(h: number, m: number) { }<br>    tick() {<br>        console.log(&quot;tick tock&quot;);<br>    }<br>}</pre><pre><strong>let</strong> digital = createClock(DigitalClock, 12, 17);<br><strong>let</strong> analog = createClock(AnalogClock, 7, 32);</pre><p>Первый параметр функции <strong><em>createClock </em></strong>имеет тип <strong><em>ClockConstuctor </em></strong>и при передаче значения (например, <strong><em>AnalogClock</em></strong>) проверяется, что класс имеет правильную сигнатуру конструктора.</p><h3>Расширение (или наследование) интерфейсов</h3><p>Как и классы, интерфейсы могут расширять друг друга. Это позволяет вам копировать методы одного интерфейса в другой, что дает вам больше гибкости при разработке.</p><pre><strong>interface</strong> Shape {<br>    color: string;<br>}</pre><pre><strong>interface</strong> Square extends Shape {<br>    sideLength: number;<br>}</pre><pre><strong>let</strong> square = &lt;<strong>Square</strong>&gt;{};<br>square.color = &quot;blue&quot;;<br>square.sideLength = 10;</pre><p>Интерфейс может наследовать несколько интерфейсов, создавая комбинацию из всех.</p><pre><strong>interface</strong> Shape {<br>    color: string;<br>}</pre><pre><strong>interface</strong> PenStroke {<br>    penWidth: number;<br>}</pre><pre><strong>interface</strong> Square extends Shape, PenStroke {<br>    sideLength: number;<br>}</pre><pre><strong>let</strong> square = &lt;<strong>Square</strong>&gt;{};<br>square.color = &quot;blue&quot;;<br>square.sideLength = 10;<br>square.penWidth = 5.0;</pre><h3>Гибридные типы</h3><p>Как упоминалось ранее, интерфейсы могут описывать множество типов данных, которые есть в JavaScript. И поскольку JavaScript имеет динамичную и гибкую природу, вы можете столкнуться с объектом, который работает как комбинация из описанных выше типов.</p><p>Одним из таких примеров является объект, который может одновременно быть и функцией и объектом с набором свойств:</p><pre><strong>interface</strong> Counter {<br>    (start: number): string;<br>    interval: number;<br>    reset(): void;<br>}</pre><pre><strong>function</strong> <strong>getCounter</strong>(): <strong>Counter</strong> {<br>    <strong>let</strong> counter = &lt;<strong>Counter</strong>&gt;function (start: number) { };<br>    counter.interval = 123;<br>    counter.reset = function () { };<br>    return counter;<br>}</pre><pre>let c = getCounter();<br>c(10);<br>c.reset();<br>c.interval = 5.0;</pre><p>При использовании сторонних библиотек JavaScript, вы можете использовать шаблоны, похожие на представленные выше, для описания поведения типа.</p><h3>Наследование классов интерфейсами</h3><p>Когда интерфейс наследует класс, он включает в себя все члены этого класса, но не их реализации. Это все равно, что интерфейс объявляет все члены класса без реализации. Интерфейс унаследует даже закрытые (private) и защищенные (protected) члены класса. Это означает, что когда вы создаете интерфейс, который наследуется от класса с private или protected членами, то тип этого интерфейса может быть реализован только этим классом или его потомком.</p><p>Это бывает полезно, когда у вас большая иерархия наследования, но вы хотите определить, что ваш код должен работать только с потомками, которые имеют конечный набор свойств.</p><pre><strong>class</strong> Control {<br>    <strong>private</strong> state: any;<br>}</pre><pre><strong>interface</strong> SelectableControl extends Control {<br>    select(): void;<br>}</pre><pre><strong>class</strong> Button extends Control {<br>    select() { }<br>}</pre><pre><strong>class</strong> TextBox extends Control {<br>    select() { }<br>}</pre><pre><strong>class</strong> Image {<br>    select() { }<br>}</pre><pre><strong>class</strong> Location {<br>    select() { }<br>}</pre><p>В приведенном примере, <strong><em>SelectableControl </em></strong>содержит все члены <strong><em>Control</em></strong>, включая также и свойство <strong><em>state</em></strong>. Т.к. свойство <strong><em>state </em></strong>является <strong><em>private</em></strong>, только потомки класса <strong><em>Control </em></strong>могут реализовывать интерфейс <strong><em>SelectableControl</em></strong>. Это потому, что только потомки класса <strong><em>Control </em></strong>будут иметь private свойство <strong><em>state.</em></strong></p><pre>let someVar: SelectableControl = new Button();</pre><pre>// Допустимо, т.к. TextBox является потомком класса Control<br>someVar = new TextBox(); </pre><pre>// Ошибка! Класс Image не является потомком класса Control<br>someVar = new Image();</pre><p><a href="https://www.typescriptlang.org/docs/handbook/interfaces.html">Documentation - Object Types</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5ac4ae1de797" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Объявление переменных в TypeScript]]></title>
            <link>https://medium.com/@sergey.bakaev/%D0%BE%D0%B1%D1%8A%D1%8F%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D1%8B%D1%85-%D0%B2-typescript-48df02e31ac9?source=rss-5401fa6ede55------2</link>
            <guid isPermaLink="false">https://medium.com/p/48df02e31ac9</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[ecmascript-6]]></category>
            <category><![CDATA[destructuring]]></category>
            <dc:creator><![CDATA[Sergey Bakaev]]></dc:creator>
            <pubDate>Wed, 19 Oct 2016 19:50:51 GMT</pubDate>
            <atom:updated>2016-10-19T19:50:51.523Z</atom:updated>
            <content:encoded><![CDATA[<p>В JavaScript существует два относительно новых способа объявления переменных — с помощью ключевых слов <strong><em>let </em></strong>и <strong><em>const</em></strong>. Объявление переменной с использованием <strong><em>let </em></strong>очень похоже на объявление с использованием <strong><em>var</em></strong>, но позволяет избегать некоторых распространенных подводных камней при работе с JavaScript. Объявление с помощью <strong><em>const </em></strong>делает невозможным все последующие присваивания новых значений переменной.</p><p>Язык TypeScript полностью поддерживает объявление переменных с помощью <strong><em>let </em></strong>и <strong><em>const</em></strong>, поскольку является надмножеством языка JavaScript. Далее будет рассмотрено, почему <strong><em>let </em></strong>и <strong><em>const </em></strong>являются более предпочтительным способом объявления переменных, нежели <strong><em>var</em></strong>.</p><h3>Объявление с помощью var</h3><p>Использование ключевого слова <strong><em>var </em></strong>для объявления переменной является традиционным способом в языке JavaScript.</p><pre><strong>var</strong> a = 10;</pre><p>Как можно видеть, здесь мы объявили переменную с именем <strong>a </strong>и присвоили ей значение, равное <strong>10</strong>.</p><p>Также объявлять переменную можно внутри функции:</p><pre><strong>function</strong> <strong>f</strong>() {<br>    <strong>var</strong> message = &quot;Hello, world!&quot;;</pre><pre>    <strong>return</strong> message;<br>}</pre><p>Ну и конечно можно получить доступ к этим переменным внутри других функций:</p><pre><strong>function</strong> <strong>f</strong>() {<br>    <strong>var</strong> a = 10;<br>    <strong>return</strong> <strong>function</strong> <strong>g</strong>() {<br>        <strong>var</strong> b = a + 1;<br>        <strong>return</strong> b;<br>    }<br>}</pre><pre><strong>var</strong> g = f();<br>g(); // returns&#39;11&#39;</pre><p>В приведенном выше примере, функция <strong><em>g </em></strong>захватывает переменную <strong><em>а</em></strong>, объявленную в функции <strong><em>f</em></strong>. Когда будет вызвана функция <strong><em>g</em></strong>, значение переменной <strong><em>a </em></strong>в <strong><em>g </em></strong>будет привязано к значению <strong><em>a </em></strong>из <strong><em>f</em></strong>. Таким образом даже при однократном вызове функции <strong><em>g </em></strong>в<strong><em> f</em></strong>, <strong><em>g </em></strong>получает доступ к переменной <strong><em>a </em></strong>и может изменить её значение.</p><pre><strong>function</strong> <strong>f</strong>() {<br>    <strong>var</strong> a = 1;</pre><pre>    a = 2;<br>    <strong>var</strong> b = g();<br>    a = 3;</pre><pre>    <strong>return</strong> b;</pre><pre>    <strong>function</strong> <strong>g</strong>() {<br>        <strong>return</strong> a;<br>    }<br>}</pre><pre>f(); // returns &#39;2&#39;</pre><h4>Правила области видимости</h4><p>Объявления переменных с использованием <strong><em>var </em></strong>имеют несколько необычные <em>правила области видимости</em> по сравнению с другими языками программирования. Рассмотрим пример:</p><pre><strong>function</strong> <strong>f</strong>(shouldInitialize: boolean) {<br>    <strong>if</strong> (shouldInitialize) {<br>        <strong>var</strong> x = 10;<br>    }<br><br>    <strong>return</strong> x;<br>}<br><br>f(true);  // returns &#39;10&#39;<br>f(false); // returns &#39;undefined&#39;</pre><p>В данном примере переменная <strong><em>x </em></strong>объявляется <em>внутри </em>блока <strong><em>if</em></strong>, однако мы можем получить к ней доступ вне его. Происходит это потому, что объявления с помощью var доступны в любом месте в пределах Lсодержащей их функции, модуля, пространства имен, или в глобальном масштабе независимо от содержащего блока. Иногда это называют <em>var-областью видимости (var-scoping)</em> или <em>областью видимости функции</em>. Параметры, передаваемые в функцию, также принадлежат области видимости функции.</p><p>Данные правила могут быть причиной нескольких типов ошибок. Одна из проблем — это отсутствие сообщений об ошибках при многократном объявлении одной и той же переменной:</p><pre><strong>function</strong> <strong>sumMatrix</strong>(matrix: number[][]) {<br>    <strong>var</strong> sum = 0;<br>    <strong>for</strong> (<strong>var</strong> i = 0; i &lt; matrix.length; i++) {<br>        <strong>var</strong> currentRow = matrix[i];<br>        <strong>for</strong> (<strong>var</strong> i = 0; i &lt; currentRow.length; i++) {<br>            sum += currentRow[i];<br>        }<br>    }</pre><pre>    <strong>return</strong> sum;<br>}</pre><p>В данном примере объявление переменной во внутреннем цикле for затрет значение переменной <strong><em>i </em></strong>во внешнем цикле, поскольку <strong><em>i </em></strong>находится в пределах одной и той же области видимости функции. Подобные случаи могут ускользнуть от внимания разработчиков и, в конечном итоге, привести к трудно отлавливаемым ошибкам.</p><h4>Особенности захвата переменных</h4><p>Рассмотрим следующий пример. Каким будет результат работы данного куска кода?</p><pre><strong>for</strong> (<strong>var</strong> i = 0; i &lt; 10; i++) {<br>    setTimeout(<strong>function</strong>() { console.log(i); }, 100 * i);<br>}</pre><blockquote>Если вы еще не знаете, то <strong>setTimeout </strong>выполняет функцию, переданную в качестве первого аргумента спустя некоторое количество миллисекунд, переданное во втором аргументе.</blockquote><p>Так каким же будет результат?</p><pre>10<br>10<br>10<br>10<br>10<br>10<br>10<br>10<br>10<br>10</pre><p>Для множества JavaScript разработчиков такое поведение будет вполне ожидаемым, однако если для вас это сюрприз, то вы в любом случае не одни. Казалось бы, стоило ожидать следующего результата:</p><pre>0<br>1<br>2<br>3<br>4<br>5<br>6<br>7<br>8<br>9</pre><p>Что же здесь не так? На самом деле каждая функция, которую мы передаем в <strong><em>setTimeout </em></strong>ссылается на одну и ту же переменную <strong><em>i </em></strong>из одной и той же области видимости.</p><p><strong><em>setTimeout </em></strong>выполнит функцию спустя некоторое количество миллисекунд, но это будет уже после того, как цикл завершится. И в этом случае значение переменной <strong><em>i </em></strong>будет равно <strong><em>10</em></strong>.</p><p>Выходом из этой ситуации является использование “<strong><em>функции немедленного вызова</em></strong>” (IIFE — an Immediately Invoked Function Expression) для захвата переменной i в каждой итерации цикла:</p><pre><strong>for</strong> (<strong>var</strong> i = 0; i &lt; 10; i++) {<br>    // capture the current state of &#39;i&#39;<br>    // by invoking a function with its current value<br>    (<strong>function</strong>(i) {<br>        setTimeout(<strong>function</strong>() { console.log(i); }, 100 * i);<br>    })(i);<br>}</pre><p>Такой странный шаблон достаточно распространен в JavaScript. Параметр <strong><em>i </em></strong>“<em>закрывает</em>” переменную <strong><em>i</em></strong>, объявленную в цикле, а поскольку имена переменной и параметра функции совпадают, мы больше не можем изменить переменную цикла.</p><h3>Объявления с помощью let</h3><p>Именно из-за проблем, присущим объявлению переменных с использованием <strong><em>var</em></strong>, было введено объявление с использованием <strong><em>let</em></strong>.</p><pre><strong>let</strong> hello = &quot;Hello!&quot;;</pre><p>Ключевым отличием здесь является не синтаксис, а семантика объявления, которое сейчас и будет рассмотрено.</p><h4>Область видимости на уровне блока</h4><p>Когда переменная объявляется с помощью ключевого слова <strong><em>let</em></strong>, считается, что она находится в так называемой <em>лексической области видимости</em> или в <em>области видимости блока</em>. В отличие от <strong><em>var</em></strong>, <strong><em>let </em></strong>переменные не видны вне блока, в котором они были объявлены.</p><pre><strong>function</strong> <strong>f</strong>(input: boolean) {<br>    <strong>let</strong> a = 100;</pre><pre>    <strong>if</strong> (input) {<br>        // Still okay to reference &#39;a&#39;<br>        <strong>let</strong> b = a + 1;<br>        <strong>return</strong> b;<br>    }</pre><pre>    // Error: &#39;b&#39; doesn&#39;t exist here<br>    <strong>return</strong> b;<br>}</pre><p>В данном примере переменная <strong><em>а </em></strong>принадлежит области видимости функции <strong><em>f</em></strong>, а область видимости переменной <strong><em>b </em></strong>ограничена блоком <strong><em>if</em></strong>. Поэтому попытка получить доступ к переменной <strong><em>b </em></strong>вне блока <strong><em>if </em></strong>приведет к ошибке.</p><p>Переменные, определенные в блоке <strong><em>catch</em></strong>, не доступны за пределами этого блока, что похоже на объявление переменных с помощью <strong><em>let</em></strong>.</p><pre><strong>try</strong> {<br>    <strong>throw</strong> &quot;oh no!&quot;;<br>}<br><strong>catch</strong> (e) {<br>    console.log(&quot;Oh well.&quot;);<br>}</pre><pre>// Error: &#39;e&#39; doesn&#39;t exist here<br>console.log(e);</pre><p>К переменным, определенным с помощью ключевого слова <strong><em>let</em></strong>, нельзя обращаться до места их непосредственного объявления. Хотя переменная и существует в определенной области видимости, все попытки обращения к ней до объявления находятся в так называемой “<em>временной мертвой зоне</em>”.</p><pre>a++; // нельзя обращаться к переменной до объявления<br><strong>let</strong> a;</pre><p>Стоит отметить, что сейчас можно захватить let-переменную до ее объявления. Единственная проблема в том, что нельзя вызывать функцию до объявления этой переменной. Если используется ES2015, то будет сгенерировано исключение; однако, на данный момент TypeScript не выдаст никакого сообщения об ошибке.</p><pre><strong>function</strong> <strong>foo</strong>() {<br>    // Допустимо<br>    <strong>return</strong> a;<br>}<br><br>// нельзя вызывать &#39;foo&#39; до того, как &#39;a&#39; будет объявлена<br>// будет брошено исключение во время выполнения<br>foo();<br><br><strong>let</strong> a;</pre><p>Более подробно о “временных мертвых зонах” можно узнать на <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let#Temporal_dead_zone_and_errors_with_let">Mozilla Developer Network</a>.</p><h4>Повторное объявление и сокрытие переменных</h4><p>При использовании ключевого слова <strong><em>var </em></strong>неважно сколько раз мы объявим переменную.</p><pre><strong>function</strong> <strong>f</strong>(x) {<br>    <strong>var</strong> x;<br>    <strong>var</strong> x;</pre><pre>    <strong>if</strong> (true) {<br>        <strong>var</strong> x;<br>    }<br>}</pre><p>В приведенном выше примере все объявления переменной <strong><em>x </em></strong>будут иметь отношение к одному и тому же <strong><em>x</em></strong>, и это вполне допустимо. Как правило, это является источником ошибок. К счастью, с помощью let так делать нельзя.</p><pre><strong>let</strong> x = 10;<br><strong>let</strong> x = 20; // Ошибка: &#39;x&#39; уже объявлен в этой области видимости</pre><p>Переменные при этом необязательно всегда должны объявляться с помощью ключевого слова <strong><em>let</em></strong>.</p><pre><strong>function</strong> <strong>f</strong>(x) {<br>    <strong>let</strong> x = 100; // Ошибка: переменная совпадает с параметром<br>}</pre><pre><strong>function</strong> <strong>g</strong>() {<br>    <strong>let</strong> x = 100;<br>    <strong>var</strong> x = 100; // Ошибка: нельзя еще раз объявить &#39;x&#39;<br>}</pre><p>Но это не означает, что let-переменную нельзя объявить только один раз в пределах области видимости функции. Переменная, имеющая область видимости на уровне блока, просто должна быть объявлена в другом блоке.</p><pre><strong>function</strong> <strong>f</strong>(condition, x) {<br>    <strong>if</strong> (condition) {<br>        <strong>let</strong> x = 100;<br>        <strong>return</strong> x;<br>    }</pre><pre>    <strong>return</strong> x;<br>}</pre><pre>f(false, 0); // returns &#39;0&#39;<br>f(true, 0);  // returns &#39;100&#39;</pre><p>Процесс объявления новой переменной во вложенной области видимости называется <em>сокрытием</em>. Это как палка о двух концах: с одной стороны это может привести к ошибкам в случае случайного сокрытия переменной; с другой — предотвратить их появление. Для примера перепишем написанную выше функцию <strong><em>sumMatrix </em></strong>с использованием <strong><em>let</em></strong>.</p><pre><strong>function</strong> <strong>sumMatrix</strong>(matrix: number[][]) {<br>    <strong>let</strong> sum = 0;<br>    <strong>for</strong> (<strong>let</strong> i = 0; i &lt; matrix.length; i++) {<br>        <strong>var</strong> currentRow = matrix[i];<br>        <strong>for</strong> (<strong>let</strong> i = 0; i &lt; currentRow.length; i++) {<br>            sum += currentRow[i];<br>        }<br>    }</pre><pre>    <strong>return</strong> sum;<br>}</pre><p>Данная версия функции будет работать корректно, так как переменная <strong><em>i </em></strong>внутреннего цикла скрывает <strong><em>i </em></strong>от внешнего цикла.</p><p>Как правило, следует избегать сокрытия для написания более чистого кода. Его нужно использовать только тогда, когда вы уверены, что оно может дать вам преимущество в каждом конкретном случае.</p><h4>Захват let-переменных</h4><p>Когда мы первый раз коснулись идеи захвата переменных, объявленных с помощью var, мы кратко описали как происходит этот процесс. Для лучшего понимания рассмотрим этот процесс подробнее. Каждый раз, когда область видимости начинает свое выполнение, она создает “окружение” для переменных, которые в ней используются. Это окружение и захваченные в ней переменные могут существовать даже после того, как выполнение этой области видимости завершится.</p><pre><strong>function</strong> <strong>theCityThatAlwaysSleeps</strong>() {<br>    <strong>let</strong> getCity;</pre><pre>    <strong>if</strong> (true) {<br>        <strong>let</strong> city = &quot;Seattle&quot;;<br>        getCity = <strong>function</strong>() {<br>            <strong>return</strong> city;<br>        }<br>    }</pre><pre>    <strong>return</strong> getCity();<br>}</pre><p>Так как мы захватили переменную <strong><em>city </em></strong>внутри окружения, созданной областью видимости, мы все еще можем получить к ней доступ несмотря на тот факт, что блок <strong><em>if </em></strong>уже выполнился.</p><p>Вспомним пример с функцией <strong><em>setTimeout</em></strong>, описанный ранее. Там нам потребовалось использовать функцию немедленного вызова (IIFE) для захвата значения переменной для каждой итерации цикла. То есть по сути мы создали новые переменные окружения для каждой захваченной переменной. Это головная боль для разработчиков, но к счастью, в TypeScript вам не придется этого делать.</p><p><strong><em>let</em></strong>-объявления переменных обладают кардинально отличающимся поведением, когда переменная объявляется как часть цикла. В этом случае создается область видимости для <em>каждой итерации цикла. </em>Поэтому пример с setTimeout можно переписать следующим образом, используя <strong><em>let</em></strong>:</p><pre><strong>for</strong> (<strong>let</strong> i = 0; i &lt; 10 ; i++) {<br>    setTimeout(<strong>function</strong>() { console.log(i); }, 100 * i);<br>}</pre><p>Как и ожидалось, результат будет следующим:</p><pre>0<br>1<br>2<br>3<br>4<br>5<br>6<br>7<br>8<br>9</pre><h4>Объявления переменных с использованием const</h4><p>Объявления с помощью ключевого слова <strong><em>const </em></strong>являются еще одним способом создания переменных.</p><pre><strong>const</strong> numLivesForCat = 9;</pre><p>Объявление с помощью const похоже на <strong><em>let</em></strong>, но, как следует из названия, значение такой переменной может быть присвоено только один раз. Другими словами, к <strong><em>const </em></strong>объявлениям применимы те же правила, что и к <strong><em>let</em></strong>, но плюс к этому вы не можете изменить значение переменной.</p><p>Не следует путать это с тем, что значения, на которые ссылаются такие переменные будут <em>неизменяемыми</em>.</p><pre><strong>const</strong> numLivesForCat = 9;<br><strong>const</strong> kitty = {<br>    name: &quot;Aurora&quot;,<br>    numLives: numLivesForCat,<br>}</pre><pre>// Error<br>kitty = {<br>    name: &quot;Danielle&quot;,<br>    numLives: numLivesForCat<br>};</pre><pre>// all &quot;okay&quot;<br>kitty.name = &quot;Rory&quot;;<br>kitty.name = &quot;Kitty&quot;;<br>kitty.name = &quot;Cat&quot;;<br>kitty.numLives--;</pre><p>Если не вы не предпримете конкретных действий, чтобы этого избежать, внутреннее состояние константной переменной останется <em>изменяемым</em>. К счастью, в TypeScript можно указать, что члены объекта являются только для чтения. <a href="https://www.typescriptlang.org/docs/handbook/interfaces.html">Здесь </a>можно подробнее ознакомиться как это реализовать.</p><h4>let vs. const</h4><p>Так когда же использовать <strong><em>let</em></strong>, а когда <strong><em>const</em></strong>? Здесь все зависит от контекста.</p><p>Применяя <a href="https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D1%85_%D0%BF%D1%80%D0%B8%D0%B2%D0%B8%D0%BB%D0%B5%D0%B3%D0%B8%D0%B9">принцип наименьших привилегий</a>, все объявления переменных, которые не планируется изменять, должны быть определены с помощью const. Смысл заключается в том, что если переменную не требуется изменять, другие разработчики не должны автоматически получить доступ к ее изменению. Для того, чтобы это сделать, необходимо будет рассмотреть вопрос о целесообразности данного действия. Использование <strong><em>const </em></strong>делает код более предсказуемым.</p><p>Applying the <a href="https://en.wikipedia.org/wiki/Principle_of_least_privilege">principle of least privilege</a>, all declarations other than those you plan to modify should use const. The rationale is that if a variable didn’t need to get written to, others working on the same codebase shouldn’t automatically be able to write to the object, and will need to consider whether they really need to reassign to the variable. Using constalso makes code more predictable when reasoning about flow of data.</p><p>С другой стороны, длина слова <strong><em>let </em></strong>такая же, как и у <strong><em>var</em></strong>, и многие пользователи предпочтут использовать <strong><em>let </em></strong>для краткости.</p><p>Выбор за вами.</p><h3>Деструктуризация</h3><p>Другая особенность ECMAScript 2015, которую поддерживает TypeScript — деструктуризация. Подробнее с этой особенностью можно ознакомиться в <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">статье</a>.</p><h4>Разбор массивов</h4><p>Простейший пример деструктуризации — разбор массива с помощью деструктурирующего присваивания:</p><pre><strong>let</strong> input = [1, 2];<br><strong>let</strong> [first, second] = input;<br>console.log(first); // outputs 1<br>console.log(second); // outputs 2</pre><p>В данном примере создаются две переменные: <strong><em>first </em></strong>и <strong>second</strong>. Это более удобно, чем использовать доступ к элементу массива по индексу</p><pre>first = input[0];<br>second = input[1];</pre><p>Деструктуризация работает с уже объявленными переменными:</p><pre>// меняем значения местами<br>[first, second] = [second, first];</pre><p>Также можно использовать данную форму записи в качестве параметра функции:</p><pre><strong>function</strong> <strong>f</strong>([first, second]: [number, number]) {<br>    console.log(first);<br>    console.log(second);<br>}<br>f(input);</pre><p>Вы можете создать переменную для оставшихся элементов массива, используя синтаксис вида <strong><em>…name</em></strong></p><pre><strong>let</strong> [first, ...rest] = [1, 2, 3, 4];<br>console.log(first); // outputs 1<br>console.log(rest); // outputs [ 2, 3, 4 ]</pre><p>Ну и конечно вы можете игнорировать элементы массива, которые вам не нужны:</p><pre><strong>let</strong> [first] = [1, 2, 3, 4];<br>console.log(first); // outputs 1</pre><p>Или например так:</p><pre><strong>let</strong> [, second, , fourth] = [1, 2, 3, 4];<br>console.log(second); // outputs 2<br>console.log(fourth); // outputs 4</pre><h4>Деструктуризация объектов</h4><p>Деструктуризацию можно использовать для объектов:</p><pre><strong>let</strong> o = {<br>    a: &quot;foo&quot;,<br>    b: 12,<br>    c: &quot;bar&quot;<br>}<br><strong>let</strong> {a, b} = o;</pre><p>В этом примере будут созданы новые переменные <strong><em>a </em></strong>и <strong><em>b</em></strong>, которые будут иметь значения равные <strong><em>o.a</em></strong> и <strong><em>o.b</em></strong> соответственно. Стоит отметить, что свойство <strong><em>c </em></strong>игнорируется за ненадобностью.</p><p>Также как и при разборе массивов, вы можете присваивать следующим образом:</p><pre>({a, b} = {a: &quot;baz&quot;, b: 101});</pre><p>Обратите внимание на скобки. Без них JavaScript воспримет <strong><em>{</em></strong> как начало блока.</p><h4>Переименование свойств</h4><p>Можно давать различные имена свойствам объекта:</p><pre><strong>let</strong> {a: newName1, b: newName2} = o;</pre><p>Как ни странно, но в этой записи <strong><em>newName1 </em></strong>и <strong><em>newName2 </em></strong>не означают тип. Эта запись аналогична:</p><pre><strong>let</strong> newName1 = o.a;<br><strong>let</strong> newName2 = o.b;</pre><p>Чтобы указать типы переменных, нужно использовать следующую форму записи:</p><pre><strong>let</strong> {a, b}: {a: string, b: number} = o;</pre><h4>Значения по умолчанию</h4><p>Значения по умолчанию позволяют задать значение свойству, если оно не определено явно:</p><pre><strong>function</strong> <strong>keepWholeObject</strong>(wholeObject: {a: string, b?: number}) {<br>    <strong>let</strong> {a, b = 1001} = wholeObject;<br>}</pre><p><strong><em>keepWholeObject </em></strong>теперь имеет переменную <strong><em>wholeObject</em></strong>, также как и свойства <strong><em>a </em></strong>и <strong><em>b</em></strong>, даже если <strong><em>b </em></strong>не определено.</p><h4>Объявления функций</h4><p>Деструктуризация также применяется при объявлении функций. Рассмотрим простой случай:</p><pre><strong>type</strong> C = {a: string, b?: number}<br><strong>function</strong> <strong>f</strong>({a, b}: C): <strong>void</strong> {<br>    // ...<br>}</pre><p>Указание значений по умолчанию для параметров функций с использованием деструктуризации может показаться фокусом. В первую очередь нужно запомнить, что тип должен быть указан до значений по умолчанию.</p><pre><strong>type</strong> C = {a: string, b?: number}<br><strong>function</strong> <strong>f</strong>({a, b}: C = {a: &quot;&quot;, b: 0}): <strong>void</strong> {<br>    // ...<br>}<br>f(); // ok, default to {a: &quot;&quot;, b: 0}</pre><p>Также нужно запомнить, что значения по умолчанию для необязательных свойств должны указываться на деструктурирующем свойстве, а не в инициализаторе.</p><pre><strong>function</strong> <strong>f</strong>({a, b = 0} = {a: &quot;&quot;}): <strong>void</strong> {<br>    // ...<br>}<br>f({a: &quot;yes&quot;}) // ok, default b = 0<br>f() // ok, default to {a: &quot;&quot;}, which then defaults b = 0<br>f({}) // error, &#39;a&#39; is required if you supply an argument</pre><p>Пользуйтесь деструктуризацией с осторожностью. Как показано выше, даже простейшая деструктуризация имеет определенные особенности. Что уж говорить о глубоко вложенной деструктуризации, которую может оказаться очень непросто понять даже без переименований, значений по умолчанию и определений типов. Старайтесь использовать только простые и понятные формы записи деструктуризации.</p><p><a href="https://www.typescriptlang.org/docs/handbook/variable-declarations.html">Destructuring #</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=48df02e31ac9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>