<?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 Denis Makarov on Medium]]></title>
        <description><![CDATA[Stories by Denis Makarov on Medium]]></description>
        <link>https://medium.com/@limitofzero?source=rss-5360326dfbba------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*4jSa7Wbvjvsblo8uBUjR-A.jpeg</url>
            <title>Stories by Denis Makarov on Medium</title>
            <link>https://medium.com/@limitofzero?source=rss-5360326dfbba------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 21:59:45 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@limitofzero/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[The basics of reactive programming using RxJS]]></title>
            <link>https://limitofzero.medium.com/the-basics-of-reactive-programming-using-rxjs-23c0d36a197b?source=rss-5360326dfbba------2</link>
            <guid isPermaLink="false">https://medium.com/p/23c0d36a197b</guid>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[rxjs]]></category>
            <category><![CDATA[js]]></category>
            <category><![CDATA[reactive-programming]]></category>
            <dc:creator><![CDATA[Denis Makarov]]></dc:creator>
            <pubDate>Tue, 27 Oct 2020 08:26:11 GMT</pubDate>
            <atom:updated>2020-10-27T08:26:11.869Z</atom:updated>
            <content:encoded><![CDATA[<h4>Part 1. Reactivity and streams</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A7_XAz9wey585WlEYpWzxQ.png" /></figure><p>This series of articles is devoted to reactivity and its application in JS using such a wonderful library as RxJS.</p><p><strong>Who this article is for:</strong> basically, here I will explain the basics, therefore the article is primarily intended for beginners in this technology. At the same time, I hope that experienced developers will be able to learn something new for themselves. You will require knowledge of JS (es5 / es6) to get into this article.</p><p><strong>Motivation:</strong> I first faced with RxJS when I started working with Angular. It was the moment when I had difficulty understanding the reactivity mechanism. Difficulties were added by the fact that at the time of the beginning of my work most of the articles were devoted to the old version of the library. I had to read a lot of documentation, various manuals in order to at least understand something. And only after some time I began to realize how “everything is arranged”. To make life easier for others, I decided to put everything in order.</p><h4>What is reactivity?</h4><p>It is difficult to find an answer to a seemingly common term. In short: reactivity is the ability to respond to any changes. But what changes are we talking about? First of all, data changes. Consider an example:</p><pre>let a = 2; <br>let b = 3;<br>let sum = a + b;</pre><pre>console.log(sum); <em>// 5</em></pre><pre>a = 3;</pre><pre>// the value has not changed, because the data needs to be recalculated</pre><pre>console.log(sum); <em>// 5</em></pre><p>This example demonstrates the familiar imperative programming paradigm. Unlike the imperative approach, the reactive approach is based on push change propagation strategies. Push strategy implies that in case of data changes, the same changes will be “pushed”, and the data dependent on them will be automatically updated. Here is how our example would behave if a push strategy was applied:</p><pre>let a = 2;<br>let b = 3;<br>let sum = a + b;</pre><pre>console.log (sum); // 5</pre><pre>a = 3;</pre><pre>// the value of the variable sum is automatically recalculated<br>console.log (sum); // 6</pre><p>This example shows a reactive approach. It is worth noting that this example has nothing to do with reality, I pointed it only to show the difference in approaches. Reactive code in real applications will look very different, and before moving on to practice, we should talk about another important component of reactivity.</p><p><strong>Data stream</strong></p><p>If you look at the term “reactive programming” on Wikipedia, the site will give us the following definition: “reactive programming is a declarative programming paradigm concerned with data streams and the propagation of change.” From this definition, we can conclude that reactivity stands on tow pillars. I mentioned the distribution of changes above, so we will not dwell on this further. But we should talk more about data streams. Let’s look at the following example:</p><pre>// get the link to the element<br>const input = document.querySelector (&#39;input&#39;);</pre><pre>const eventsArray = [];</pre><pre>// push each event into eventsArray<br>input.addEventListener (&#39;keyup&#39;,<br>   event =&gt; eventsArray.push (event)<br>);</pre><p>We listen to the <em>keyup</em> event and put the event object in our array. Over time, our array can contain thousands of objects. Recognize that our list is sorted by time. Such an array is a simplified data stream model. We call it simplified because the array can only store data. We can iterate the array and somehow process its elements. This was an added new item. To do this, we need to iterate again.</p><p>But what if our array knew how to inform us that new data arrived in it? Such an array could with certainty be called a stream. So, we come to the definition of stream. A stream is an array of data sorted by time that can indicate that the data has changed.</p><h4>Observable</h4><p>Now that we know what stream is, let’s work with it. In RxJS, streams are represented by the <em>Observable</em> class. To create your own stream, just call the constructor of this class and pass the subscription function as an argument to it:</p><pre>const observable = new Observable(observer =&gt; {<br>  observer.next(1);<br>  observer.next(2);<br>  observer.complete();<br>})</pre><p>By calling the constructor of the Observable class, we create a new stream. As an argument, we passed the subscription function to the constructor. The subscription function is a regular function that takes an observer as a parameter. The observer itself is an object that has three methods:</p><ul><li>next — emit a new value into the stream</li><li>error — throws an error into the stream, after which the stream ends</li><li>complete — terminates the stream</li></ul><p>Thus, we created a stream that emits two values and terminates.</p><h4>Subscription</h4><p>If we run the previous code, nothing will happen. We will only create a new stream and save the link to it in the observable variable, but the stream itself will never emit a single value. This is because streams are “lazy” objects and do nothing by themselves. In order for our stream to start emitting values and we can process these values, we need to start “listening” to the stream. You can do this by calling the subscribe method on the observable object.</p><pre>const observer = {<br>  next: value =&gt; console.log(value), <em>// 1, 2<br>  </em>error: error =&gt; console.error(error), <em>//<br>  </em>complete: () =&gt; console.log(&quot;completed&quot;) <em>// completed<br></em>};</pre><pre>observable.subscribe(observer);</pre><p>We defined our observer and described three methods for him: <em>next</em>, <em>error</em>, <em>complete</em>. Methods simply log data that is passed as parameters. Then we call the subscribe method and pass our observer to it. At the time of the subscribe call, the subscription function is called, the one that we passed to the constructor at the stage of declaring our stream. Next, the code of the subscription function will be executed, which passes two values to our observer, and then terminates the stream.</p><p>Surely, many have a question, what will happen if we subscribe to the stream again? Everything will be the same: the stream will again pass two values to the observer and end. Each time the subscribe method is called, the subscription function will be called, and all its code will be executed again. From this we can conclude: no matter how many times we subscribe to the stream, our observers will receive the same data.</p><h4>Unsubscribe</h4><p>Now let’s try to implement a more complex example. We will write a timer that will count seconds from the moment of subscription, and transmit them to observers.</p><pre>const timer = new Observable (observer =&gt; {<br>   // define the counter<br>   let counter = 0;</pre><pre>   setInterval (() =&gt; {</pre><pre>     // pass counter value to the observer and increase it by one<br>     observer.next (counter ++);</pre><pre>   }, 1000);</pre><pre>});</pre><pre>// just log each value<br>timer.subscribe({ next: console.log });</pre><p>The code is quite simple. Inside the subscription function, we declare a counter variable. Then, using <em>closure</em>, we access the variable from the <em>arrow function</em> in <em>setInterval</em>. And every second we pass the variable to the observer, after which we increment it. Then we subscribe to the stream, specify only one method — next. Do not worry that we have not announced other methods. None of the observer methods are required. We can even pass an empty object, but in this case the stream will be wasted.</p><p>After launch, we will see the desirable logs that will appear every second. If you want, you can experiment and subscribe to the stream several times. You will see that each of the streams will be executed independently of the others.</p><p>If you think about it, our stream will be executed throughout the life of the entire application, because we don’t have any logic to cancel <em>setInterval</em>, and in the subscription function there is no call to the complete method. But what if we need the stream to end?</p><p>In fact, everything is very simple. If you look at the documentation, you can see that the subscribe method returns a subscription object. This object has an <em>unsubscribe</em> method. We call it, and our observer will stop receiving values from the stream.</p><pre>const subscription = timer.subscribe ({next: console.log});<br>// stream will end in 5 seconds<br>setTimeout (() =&gt; subscription.unsubscribe (), 5000);</pre><p>After starting, we will see that the counter stops at 4. But, although we have unsubscribed from the stream, our <em>setInterval</em> function continues to work. It increments our counter every second and passes it to the “dummy” observer. To prevent this from happening, you must write the logic for canceling the interval. To do this, you need to return a new function from the subscription function in which the cancellation logic will be implemented.</p><pre>const timer = new Observable(observer =&gt; {<br>  let counter = 0;<br>  const intervalId = setInterval(() =&gt; {<br>    observer.next(counter++);<br>  }, 1000);  return () =&gt; {<br>   clearInterval(intervalId);<br>  }<br>});</pre><p>Now we can give a sigh of relief. After calling the unsubscribe method, our unsubscribe function will be called, which will clear the interval.</p><h4>Conclusion</h4><p>This article shows the differences between the imperative and reactive approaches, as well as examples of creating your own streams. In the next part I will talk about what other methods for creating streams exist and how to apply them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=23c0d36a197b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Интерактивная выгрузка файлов на сервер с помощью RxJS]]></title>
            <link>https://medium.com/ngx/upload-files-with-rxjs-eaf2027266f1?source=rss-5360326dfbba------2</link>
            <guid isPermaLink="false">https://medium.com/p/eaf2027266f1</guid>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[rxjs]]></category>
            <category><![CDATA[reactive-programming]]></category>
            <dc:creator><![CDATA[Denis Makarov]]></dc:creator>
            <pubDate>Mon, 10 Feb 2020 07:26:26 GMT</pubDate>
            <atom:updated>2022-11-02T17:06:22.109Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*45IB48_b-wwSq4-_.jpg" /></figure><p>Прошло много времени с тех пор, как я написал свою последнюю статью по основам RxJS. В комментариях меня попросили показать более сложные примеры, которые могут пригодиться на практике. Поэтому я решил немного разбавить теорию и сегодня мы поговорим про выгрузку файлов.</p><p>Что мы будем делать?</p><ul><li>Напишем небольшую страничку, на которой пользователь сможет выбрать файл для загрузки его на сервер</li><li>Добавим progress bar, чтобы отображался прогресс загрузки файла</li><li>Добавим возможность отменить загрузку нажатием на кнопку отмены</li></ul><blockquote>Для понимания данной статьи вам потребуются базовые знания RxJS. Что такое <a href="https://medium.com/ngx/introducing-to-reactive-programming-984c1a390e2d">Observable</a>, <a href="https://medium.com/ngx/introducing-to-reactive-programming-with-rxjs-3583345faec1">операторы</a>, а так-же <a href="https://medium.com/ngx/introducing-to-reactive-programming-d1337fbead32">HOO операторы</a>.</blockquote><p>Не будем тянуть кота за хвост и сразу перейдем к делу!</p><h4>Подготовка</h4><p>Для начала нам потребуется сервер, который может принимать запросы на загрузку файлов. Для этого может подойти любой сервер, я для статьи буду использовать node.js в связке с express и <a href="https://github.com/expressjs/multer">multer</a>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/156c8b758838f09adba78485c406e410/href">https://medium.com/media/156c8b758838f09adba78485c406e410/href</a></iframe><p>Теперь создадим html страничку, на которой мы разместим все необходимые элементы:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ce81e9923ef1c77ede97907b55b2ece3/href">https://medium.com/media/ce81e9923ef1c77ede97907b55b2ece3/href</a></iframe><p>Сейчас на страничке у нас есть 4 элемента, с которыми пользователь будет взаимодействовать:</p><ul><li>Input с типом file, чтобы пользователь смог выбрать файл для выгрузки</li><li>Кнопка upload, при нажатии на которую мы начнем выгрузку</li><li>Кнопка cancel, которая будет отменять загрузку</li><li>Progress bar со стартовой шириной 0. В процессе выгрузки мы будем менять его ширину</li></ul><p>В самом конце тега body я добавил ссылку на скрипт index.js, который нам тоже нужно будет создать:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e0607d7af9d8a3ebab8950178b92adae/href">https://medium.com/media/e0607d7af9d8a3ebab8950178b92adae/href</a></iframe><p>Выглядеть все это должно примерно так:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/866/1*5902XpQYoT0b49HOeoOIBw.png" /></figure><h4>Всё — поток</h4><p>Чтобы сказать браузеру, какой файл нужно выбрать, пользователь должен кликнуть по кнопке “Choose file”. После этого откроется диалоговое окно вашей операционной системы, где отобразится дерево папок. После выбора файла браузер загрузит всю необходимую информацию о нем.</p><p>Как нам понять, что пользователь выбрал файл? Для этого существует событие ‘change’. После срабатывания события мы можем обратиться к массиву files в input’е, куда и будут записаны данные файла.</p><p>Как же нам слушать событие ‘change’? Можно воспользоваться методом addEventListener и работать с ним. Но мы работаем с RxJS, где любое событие может быть представлено как поток:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/17912cd011e9f09d561e66233c95ab5e/href">https://medium.com/media/17912cd011e9f09d561e66233c95ab5e/href</a></iframe><p>Добавим функцию upload, которая будет выгружать файл на сервер. Пока оставим ее тело пустым:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c63c2e5ac3c435f81fe1615c5cc2a8e3/href">https://medium.com/media/c63c2e5ac3c435f81fe1615c5cc2a8e3/href</a></iframe><p>Функция upload должна вызываться после нажатия на кнопку uploadBtn:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c07ef7bc874de7c8cbe617a31389983a/href">https://medium.com/media/c07ef7bc874de7c8cbe617a31389983a/href</a></iframe><h4>Объединяем потоки</h4><p>Сейчас наш код ничем не отличается от того, который бы мы написали, используя addEventListener. Да, он работает, но если мы оставим его таким, то потеряем те преимущества, которые открывает перед нами RxJS.</p><p>Что мы можем сделать? Распишем последовательность шагов для выгрузки файла:</p><ul><li>Выбор файла</li><li>Нажатие кнопки uploadBtn</li><li>Извлечение файла из input.files</li><li>Выгрузка файла</li></ul><p>Теперь данную последовательность перенесем на код. Но как объединить потоки input’а и uploadBtn? В этом нам поможет оператор switchMap, который позволяет спроецировать один поток на другой:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0b4bb74a5014b1ae59c5c2621981aa21/href">https://medium.com/media/0b4bb74a5014b1ae59c5c2621981aa21/href</a></iframe><p>Данный код очень похож на последовательность тех инструкций, что мы описали выше. Пользователь выбирает файл, срабатывает switchMap и мы подписываемся на uploadBtn. Но дальше ничего не произойдет.</p><p>switchMap пропускает во внешний поток только те значения, которые генерирует <em>fromEvent(uploadBtn, ‘click’)</em>.Чтобы выгрузка файлов началась, нужно выполнить вторую инструкцию, а именно — нажать на uploadBtn. Затем отработает метод map, который извлечет файл из массива, и уже в subscribe произойдет вызов метода upload.</p><p>Самое интересное здесь то, что последовательность инструкций не нарушаема. Чтобы сработала функция upload, нужно, чтобы перед этим сработало событие ‘change’.</p><p>Но все же одна проблема осталась. Пользователь может выбрать файл, а затем отменить свой выбор. И тогда при попытке выгрузки файла, мы передадим в функцию upload — undefined. Чтобы избежать подобной ситуации, нам следует добавить проверку:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b9ae4e9b8745af970a20cec25a79a0a8/href">https://medium.com/media/b9ae4e9b8745af970a20cec25a79a0a8/href</a></iframe><h4>Работаем с xhr</h4><p>Пора реализовать самое сложное — процесс выгрузки. Я буду показывать его на примере работы с xhr, так как fetch, на момент написания статьи, не умеет отслеживать <a href="https://fetch.spec.whatwg.org/#fetch-api">прогресс выгрузки</a>.</p><blockquote>Вы можете реализовать выгрузку с помощью любой другой библиотеки, например axios или jQuery.ajax.</blockquote><p>Так как на серверной стороне я использую multer, то передавать файл мне придется внутри формы(multer принимает данные только в таком формате). Для этого я написал функцию createFormData:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/aa22ea85ed95cf68d15ff57b26e7ba79/href">https://medium.com/media/aa22ea85ed95cf68d15ff57b26e7ba79/href</a></iframe><p>Выгружать форму мы будем через XMLHttpRequest. Нам потребуется создать экземпляр данного объекта и определить у него методы unload и onerror. Первый будет срабатывать, когда выгрузка завершена, второй — когда произошла ошибка.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e014ddebe814d4f5bb61c1af88edc41f/href">https://medium.com/media/e014ddebe814d4f5bb61c1af88edc41f/href</a></iframe><p>Теперь у нас есть рабочий пример. Но он содержит пару недостатков:</p><ul><li>Нет возможности отменить загрузку</li><li>Если нажать на кнопку uploadBtn n раз, то у нас откроется n параллельных соединений на выгрузку одного файла</li></ul><p>Все потому, что функция upload работает вне потока. Она живет сама по себе. Нам нужно это исправить. Сделаем так, чтобы функция возвращала нам Observable. Тогда мы сможем контролировать выгрузку файлов:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0aa793875bcdda0534d3e29660b48e6c/href">https://medium.com/media/0aa793875bcdda0534d3e29660b48e6c/href</a></iframe><p>Обратите внимание на возвращаемую внутри Observable стрелочную функцию. Данный метод будет вызван в момент отписки и отменит выгрузку.</p><p>Поместим вызов upload в switchMap:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2201e96cc160cf20b957965a457f2a0b/href">https://medium.com/media/2201e96cc160cf20b957965a457f2a0b/href</a></iframe><p>Теперь, если пользователь нажмет на кнопку выгрузки еще раз, то предыдущий запрос будет отменен, но создастся новый.</p><h4>Отменяем запрос по клику</h4><p>У нас еще осталась кнопка calcelBtn. Мы должны реализовать отмену запроса. Здесь нам поможет оператор takeUntil.</p><p>takeUntil переводится как “бери пока”. Данный оператор забирает значения из внешнего потока и отдает их дальше по цепочке. До тех пор, пока внутренний поток существует и ничего не генерирует. Как только внутренний поток сгенерирует значение — takeUntil вызовет метод unsubscribe и отпишется от внешнего потока.</p><p>Прежде чем добавить оператор, нужно определить, от какого потока мы хотим отписаться. Нас интересует upload, так как необходимо завершить только выгрузку файла, т.е. отписаться от внутреннего потока:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/82f779fe25aab1b3e8d9941b80051c63/href">https://medium.com/media/82f779fe25aab1b3e8d9941b80051c63/href</a></iframe><h4>Progress bar</h4><p>Осталось добавить progress bar. Для отслеживания прогресса нам понадобится определить метод xhr.upload.onprogress. Данный метод вызывается при возникновении события ProgressEvent. Объект события содержит в себе несколько полезных для нас свойств:</p><ul><li>lengthComputable — если true, значит, что нам известен полный размер файла(в нашем случае всегда true)</li><li>total — общее количество байт</li><li>loaded — количество отосланных байт</li></ul><p>Внесем изменения в функцию upload:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bb178f0be4efb0733d1592c83aebf14a/href">https://medium.com/media/bb178f0be4efb0733d1592c83aebf14a/href</a></iframe><p>Теперь upload выплевывает в поток состояние выгрузки. Осталось только написать функцию, которая будет менять свойства style у элемента progressBar:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/76c832a8d850164cf0bf149d146d984d/href">https://medium.com/media/76c832a8d850164cf0bf149d146d984d/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/846/1*3JSCMGX3SZFrPlemaoJf8A.png" /><figcaption>Выгрузка файла с progress bar’ом</figcaption></figure><blockquote>Небольшой совет: чтобы ваши файлы локально выгружались не так быстро, включите настройку “Fast 3G” или “Slow 3G” во вкладке “Performance” в Chrome devtools.</blockquote><h4>Доводим до ума</h4><p>Мы получили полноценное рабочее приложение. Осталось добавить пару штрихов. Сейчас при нажатии на кнопку uploadBtn мы отменяем предыдущую выгрузку и начинаем новую. Но у нас уже есть кнопка отмены.</p><p>Хочется, чтобы кнопка uploadBtn не реагировала на последующие нажатия, пока мы не выгрузили файл(или пока мы не отменили выгрузку). Что можно предпринять?</p><p>Можно вешать атрибут disable, пока процесс выгрузки не завершится. Но есть другой вариант — оператор exhaustMap. Данный оператор будет игнорировать новые значения из внешнего потока, пока внутренний поток не будет завершен. Заменим switchMap на exhaustMap:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c74cfe7351ba827f4eb5d03265fcc8d7/href">https://medium.com/media/c74cfe7351ba827f4eb5d03265fcc8d7/href</a></iframe><p>И вот теперь можно считать наше приложение законченным. Немного рефакторинга и получаем финальный вариант:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a3b8a09714be75dea8d7be5030aa286e/href">https://medium.com/media/a3b8a09714be75dea8d7be5030aa286e/href</a></iframe><p>Мой вариант я выложил <a href="https://github.com/limitofzero/upload-fiels-with-rxjs">здесь</a>.</p><h4>Angular и HttpClient</h4><p>Если вы работаете с Angular, то вам не нужно использовать xhr напрямую. В Angular есть HttpClient сервис. Данный сервис может отслеживать прогресс загрузки/выгрузки, для этого достаточно передать следующие параметры в post метод:</p><ul><li>reportProgress: true — получать информацию о выгрузке/загрузке</li><li>observe: “events” — указываем, что хотим получать HttpEvents из потока</li></ul><p>Вот как будет выглядеть метод upload в Angular:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/abf0d57a5f28e37c8b28fce779ebeed1/href">https://medium.com/media/abf0d57a5f28e37c8b28fce779ebeed1/href</a></iframe><p>Оператор filter отфильтровывает только события о выгрузке. Остальные события нас не интересуют. Дальше мы приводим событие к HttpProgressEvent, чтобы получить доступ к свойствам loaded и total. Считаем процент.</p><p>HttpClient всего лишь обертка над xhr, которая избавляет нас от бойлерплейта и делает работу с HTTP проще. <br>Пример приложения на Angular можно найти <a href="https://github.com/limitofzero/angular-upload-file-with-progress">здесь</a>.</p><h4>Заключение</h4><p>RxJS очень мощный инструмент в руках разработчика. В его арсенале есть огромнейший набор операторов на все случаи жизни. К сожалению, из-за этого порог входа в данную технологию довольно высок. И часто, люди по незнанию начинают писать свои “велосипеды”, из-за чего код становится трудно поддерживаемым.</p><p>Поэтому, хочется пожелать всем читателям, не стоять на месте и не бояться экспериментировать. Изучайте RxJS. Вдруг вы наткнетесь на оператор, который может превратить 10 строчек кода в одну. Или поможет сделать код чуточку понятней.</p><p>Удачи!</p><p>Если вы хотите быть в курсе выпуска новых статей, то рекомендую подписаться на мой <a href="https://twitter.com/limitofzero"><strong>twitter</strong></a><strong>.</strong></p><p>Также хочу вам порекомендовать <a href="https://t.me/angular_fox"><strong>Telegram канал</strong></a><strong> Angular Fox </strong>и вступить в <a href="https://t.me/angular_ru"><strong>Angular группу</strong></a><strong>, </strong>где можно задать любой вопрос по RxJS и Angular.</p><p>Еще я веду канал про web3 технологии, если они вам интересны — то <a href="https://t.me/web_3_developer"><strong>подписывайтесь</strong></a>.</p><ul><li><a href="https://t.me/web_3_developer">Web3Developer</a></li><li><a href="https://t.me/angular_fox">🦊 Angular Fox 🚀 - русскогорящие новости сообщества</a></li><li><a href="https://t.me/angular_ru">Angular - русскоговорящее сообщество</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eaf2027266f1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ngx/upload-files-with-rxjs-eaf2027266f1">Интерактивная выгрузка файлов на сервер с помощью RxJS</a> was originally published in <a href="https://medium.com/ngx">Angular Soviet</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Основы реактивного программирования с использованием RxJS]]></title>
            <link>https://medium.com/ngx/introducing-to-reactive-programming-d1337fbead32?source=rss-5360326dfbba------2</link>
            <guid isPermaLink="false">https://medium.com/p/d1337fbead32</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[reactive-programming]]></category>
            <category><![CDATA[reactive]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[rxjs]]></category>
            <dc:creator><![CDATA[Denis Makarov]]></dc:creator>
            <pubDate>Sun, 28 Apr 2019 15:22:55 GMT</pubDate>
            <atom:updated>2022-11-02T17:08:29.619Z</atom:updated>
            <content:encoded><![CDATA[<h4>Часть 3. Higher Order Observables</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4tc2j-ZrkjVQegqw.jpg" /></figure><p>В данной статье мы рассмотрим, как можно в одном потоке обрабатывать другой, для чего это нужно, и как нам в этом помогут операторы Higher Order Observables (дальше HOO).</p><p>Серия статей “Основы реактивного программирования с использованием RxJS”:</p><ul><li><a href="https://medium.com/ngx/introducing-to-reactive-programming-984c1a390e2d">Часть 1. Реактивность и потоки</a></li><li><a href="https://medium.com/ngx/introducing-to-reactive-programming-with-rxjs-3583345faec1">Часть 2. Операторы и пайпы</a></li></ul><blockquote>Для того, чтобы понять теоретическую часть статьи, вам не обязательно читать предыдущие статьи, необходимо лишь знать, что такое observable, операторы и пайпы. В практической части мы будем дорабатывать пример из <a href="https://medium.com/ngx/introducing-to-reactive-programming-with-rxjs-3583345faec1">второй статьи</a>, который вы можете найти по ссылке <a href="https://stackblitz.com/edit/github-api-with-rxjs?file=index.ts">здесь</a>.</blockquote><p>При работе с потоками часто возникает ситуация, когда необходимо в качестве значения одному потоку передать результаты работы другого. Например, мы хотим выполнить ajax запрос и его ответ обработать в текущем потоке, или запустить несколько параллельных запросов, реализовать pooling. Думаю, многие привыкли решать подобные задачи, используя такой механизм как promise. Но можно ли решать их используя RxJS? Конечно, и все куда проще чем вы думаете!</p><h4>Проблема</h4><p>Давайте представим следующую задачу: нам необходимо каждую секунду узнавать, доступен ли сервер. Как мы можем ее решить?</p><p>Для начала создадим поток с помощью метода timer:</p><pre>timer(0, 1000).subscribe({<br>  next: console.log<br>});</pre><p>Метод <a href="https://rxjs.dev/api/index/function/timer">timer</a> очень похож по принципу работы на <a href="https://rxjs.dev/api/index/function/interval">interval</a>. Но в отличие от него позволяет задать таймаут запуска потока, который передается первым параметром. Вторым параметром указывается интервал, через который будет генерироваться новое значение. Если второй параметр не указывать, то таймер сгенерирует только одно значение и завершит поток.</p><p>Так как сервера у нас с вами нет, то предлагаю просто написать функцию, эмулирующую запрос, на сервер:</p><pre>const makeRequest = () =&gt; {<br>  return timer(1000).pipe(<br>    mapTo(&#39;success&#39;)<br>  )<br>}</pre><p>Что делает этот метод? Он возвращает поток, созданный с помощью метода timer, который испускает значение по прошествию одной секунды и завершается. Так как метод timer генерирует только число, то с помощью оператора mapTo мы заменяем его на строку “success”.</p><p>Вот как выглядит поток, который создается методом makeRequest:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*94oREOpBFTCvOfRqv7fXyg.png" /></figure><p>Теперь у нас стоит выбор: вызывать метод makeRequest внутри потока или возложить эту обязанность на наблюдателя?</p><p>Первый подход более предпочтительный, так как в этом случае мы сможем использовать весь потенциал RxJS с его операторами и избавим нашего наблюдателя от лишних обязанностей. Воспользуемся методом timer, чтобы выполнять запросы по интервалу:</p><pre>timer(0, 1000).pipe(<br>  map(() =&gt; makeRequest())<br>).subscribe({<br>  next: console.log<br>});</pre><p>Когда мы запустим подобный код, то увидим, что в console.log нам приходит не сообщение с текстом “success”, а объект типа Observable:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*2tTtvqBvzbZZeULg1iAXAg.png" /><figcaption><a href="https://stackblitz.com/edit/rxjs-stories-3-example-1">https://stackblitz.com/edit/rxjs-stories-3-example-1</a></figcaption></figure><p>Ответ вполне ожидаем, ведь в map мы возвращаем поток. Чтобы поток заработал, нужно на него подписаться. Что же, давайте посмотрим, как <strong>не надо делать</strong>:</p><pre>timer(0, 1000).pipe(<br>  map(() =&gt; makeRequest())<br>).subscribe({<br>  next: observable =&gt; observable.subscribe({<br>    next: console.log<br>  });<br>});</pre><p>Проблема примера выше в том, что мы получаем подписку в подписке. А что если мы захотим сделать более одного запроса в цепочке? Или как быть, если в определенный момент нам нужно будет отписаться от потока внутри? В таком случае наш код все больше будет напоминать “лапшу”. Для решения данной проблемы в RxJS есть специальные операторы, которые носят название HOO.</p><h4>HOO</h4><p>HOO — это особый тип операторов, которые в качестве значений принимают потоки. Одним из таких операторов является метод mergeAll.</p><p>Когда на вход mergeAll поступает поток, он подписывается на него. Поток, на который оператор подписался, носит название внутренний. Поток, из которого оператор получает в качестве значений другие потоки, называют внешним.</p><p>Когда внутренний поток генерирует значение, то mergeAll проталкивает это значение во внешний поток. Таким образом, мы избавляемся от необходимости выполнять подписку вручную. Если мы отпишемся от внешнего потока, то mergeAll автоматически отпишется от внутреннего.</p><p>Давайте посмотрим, как можно переписать наш пример с помощью mergeAll:</p><pre>timer(0, 1000).pipe(<br>  map(() =&gt; makeRequest())<br>  mergeAll()<br>).subscribe({<br>  next: console.log<br>});</pre><p>В примере выше внешний поток создан оператором timer. А потоки, которые создаются в операторе map — внутренние. Каждый созданный поток попадает в оператор mergeAll.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0r-H5LgrikwOD4wjfQf_IA.png" /></figure><p>Комбинация map + mergeAll используются очень часто, поэтому в RxJS существует метод mergeMap:</p><pre>timer(0, 1000).pipe(<br>  mergeMap(() =&gt; makeRequest())<br>).subscribe({<br>  next: console.log<br>});</pre><p>Когда внешний поток генерирует значение, оператор mergeMap вызывает переданную в него функцию обратного вызова (callback), которая генерирует новый поток. Затем mergeMap подписывается на сгенерированный поток.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3bHcmYrpVFvPuewvPVO1bQ.png" /></figure><p>Особенность mergeAll/mergeMap оператора в том, что, если к нему спускается еще один поток, то он так же подписывается на него. Таким образом, во внешний поток у нас могут попадать значения сразу из нескольких внутренних. Посмотрим следующий пример:</p><pre>timer(0, 1000)</pre><p>Вот так внешний поток будет выглядеть без оператора mergeMap:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n9pvxlxKCRBFtda7uDPdsQ.png" /></figure><p>А вот так с mergeMap:</p><pre>timer(0, 1000).pipe(<br>  mergeMap(() =&gt; interval(1000)) <br>)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j9SPGXz6EnCpIHucydSBdQ.png" /></figure><p>Каждую секунду у нас создается новый внутренний поток и mergeMap на него подписывается. Таким образом, у нас одновременно работают множество внутренних потоков, значения из которых попадают во внешний:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zI54b9g1M1MVP-ExzvX8SQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BkcttO1v37F3WamDUWkZQQ.png" /></figure><p><strong>Примечание: </strong>будьте аккуратны с применением mergeMap, каждый новый внутренний поток будет работать до тех пор, пока вы не отпишитесь от внешнего. В примере выше количество внутренних потоков растет каждую секунду, в конце концов потоков может стать настолько много, что компьютер не справится с нагрузкой.</p><h4>concatAll/concatMap</h4><p>Метод mergeMap отлично подходит, когда вам не важен порядок исполнения внутренних потоков, но как быть, если у вас появилась в этом необходимость? Допустим, мы хотим, чтобы следующий запрос на сервер выполнился только после получения ответа от предыдущего?</p><p>Для подобных целей подойдет HOO оператор concatAll/concatMap. Данный оператор, подписавшись на внутренний поток, ждет, пока тот не завершится, и только потом подписывается на следующий.</p><p>Если во время выполнения одного потока к нему спускается новый, то он помещается в очередь до тех пор, пока предыдущий не завершится.</p><pre>// поток, генерирующий 1 по прошествии одной секунды<br>const firstInnerObservable = timer(1000).pipe(<br>  mapTo(1)<br>);</pre><pre>// поток, генерирующий 2 по прошествии половины секунды<br>const secondInnerObservable = timer(500).pipe(<br>  mapTo(2)<br>);</pre><pre>of(<br>  firstInnerObservable,<br>  secondInnerObservable<br>).pipe(<br>  concatAll()<br>).subscribe({<br>  next: console.log<br>});</pre><p>В примере выше мы создаем два потока с помощью метода timer. Для наглядности я использовал оператор mapTo для вывода разных значений. Первый поток сгенерирует 1, второй — 2. Внешний поток создается с помощью метода of, который на вход принимает два вышеобъявленных observable.</p><p>Оператор concatAll сначала получает firstInnerObservable, подписывается на него и ждет, когда он завершится, и только после завершения первого подпишется на secondInnerObservable. Вот как будет выглядеть внешний поток:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ow9aEpjHC9Hf1hw_-mOz0A.png" /></figure><p>Если же мы заменим concatAll на mergeAll, то поток будет выглядеть так:</p><pre>of(<br>  firstInnerObservable,<br>  secondInnerObservable<br>).pipe(<br>  mergeAll()<br>).subscribe({<br>  next: console.log<br>});</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8_-23shIq_u4iv2EwP41yg.png" /></figure><h4>switchAll/switchMap</h4><p>Данный оператор отличается от предыдущих тем, что когда он получает новый поток, то сразу отписывается от предыдущего и подписывается на новый.</p><p>Возьмем пример выше и заменим concatAll на switchAll, и посмотрим как будет вести себя внешний поток:</p><pre>of(<br>  firstInnerObservable,<br>  secondInnerObservable<br>).pipe(<br>  switchAll()<br>).subscribe({<br>  next: console.log<br>});</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*InXbFYYOu7WAIejJkiuiqA.png" /></figure><p>Во внешний поток попало только значение из второго внутреннего потока. Все потому что switchMap отписался от первого, когда получил второй поток.</p><p>Когда это бывает нужно? Например, при реализации поиска данных. Если ответ с сервера еще не пришел, а мы уже отправили новый запрос, то нам нет смысла ждать предыдущий.</p><h4>exhaust/exhaustMap</h4><p>exhaust — полная противоположность оператору switchAll, при этом его поведение похоже на concatAll. Данный метод, подписавшись на поток, ждет, когда он завершится. Если к нему спускается новый поток, то он просто отбрасывается.</p><pre>of(<br>  firstInnerObservable,<br>  secondInnerObservable<br>).pipe(<br>  exhaust()<br>).subscribe({<br>  next: console.log<br>});</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9QOWfCtGXAG_6J6L-gHaMw.png" /></figure><p>В примере выше мы не получили двойку, потому что в этот момент оператор ожидал завершения первого потока, и просто отбросил второй.</p><p>Думаю, у многих возник вопрос, когда подобное поведение может понадобиться? Хороший пример — форма авторизации. Нет смысла отправлять несколько запросов на сервер, пока не выполнился текущий.</p><h4>Дорабатываем приложение</h4><p>Вспоминаем <a href="https://stackblitz.com/edit/github-api-with-rxjs?file=index.ts">пример</a> из <a href="https://medium.com/ngx/introducing-to-reactive-programming-with-rxjs-3583345faec1">второй статьи</a>. В нем мы реализовали поиск по GitHub и использовали оператор mergeMap для отправки запросов к серверу. Теперь мы знаем особенности данного оператора, действительно ли он подходит в нашем случае?</p><pre>fromEvent(input, &#39;keyup&#39;).pipe(<br>  debounceTime(700),<br>  map(event =&gt; event.target.value),<br>  filter(val =&gt; val.length &gt; 2),<br>  distinctUntilChanged(),<br>  mergeMap(value =&gt; {<br>    return from(getUsersRepsFromAPI(value)).pipe(<br>      catchError(err =&gt; of([]))<br>    )<br>  })<br>).subscribe({<br>  next: reps =&gt; recordRepsToList(reps)<br>})</pre><p>Давайте предположим, что сервер GitHub будет сильно перегружен, тогда обработка нашего ответа будет занимать много времени. Что в этом случае может пойти не так?</p><p>Допустим, пользователь ввел какие-то данные, не дождался ответа и ввел новые. В этом случае мы отправим уже второй запрос на сервер. При этом никто не гарантирует, что ответ на первый запрос придет раньше.</p><p>Так как оператору mergeMap все равно в какой последовательности обрабатывать внутренние потоки, то в случае, когда первый запрос выполнится позже второго, мы затрем актуальные данные. Поэтому предлагаю заменить метод mergeMap на switchMap:</p><pre>fromEvent(input, &#39;keyup&#39;).pipe(<br>  debounceTime(700),<br>  map(event =&gt; event.target.value),<br>  filter(val =&gt; val.length &gt; 2),<br>  distinctUntilChanged(),<br>  switchMap(value =&gt; {<br>    return from(getUsersRepsFromAPI(value)).pipe(<br>      catchError(err =&gt; of([]))<br>    )<br>  })<br>).subscribe({<br>  next: reps =&gt; recordRepsToList(reps)<br>})</pre><p>Теперь, если пользователь введет новые данные, то switchMap отпишется от предыдущего потока и подпишется на новый.</p><p>Стоит отметить, что наш http запрос будет продолжать висеть до тех пор, пока сервер не даст на него ответ. Но, так как мы отписались от внутреннего потока, ответ не попадет во внешний поток.</p><p><strong>Примечание:</strong> если вы работаете с Angular и применяете HttpClient для работы с http, то можете не беспокоится об отмене самого запроса. HttpClient умеет это делать за вас при отписке.</p><h4>Отменяем http</h4><p>В fetch api есть возможность отмены http запроса с применением <a href="https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort">AbortController</a>. Данный функционал при комбинировании с оператором switchMap позволит экономить трафик пользователя.</p><p>Давайте перепишем немного наш пример. И создадим метод, который будет оборачивать вызов fetch в observable:</p><pre>const createCancellableRequest = (url) =&gt; {<br>  // создаем контроллер для возможности отмены<br>  const controller = new AbortController();<br>  const signal = controller.signal;</pre><pre>  return new Observable(observer =&gt; {</pre><pre>    fetch(url, { signal })<br>      .then(response =&gt; {<br>        if (response.ok) {<br>          return response.json();<br>        }</pre><pre>        throw new Error(&#39;Ошибка&#39;);<br>    })<br>    // передаем успешный ответ наблюдателю<br>    .then(result =&gt; observer.next(result))<br>    <em>// завершаем поток<br>    </em>.then(() =&gt; observer.complete())<br>    // в случае ошибки, оповещаем об этом наблюдателя<br>    .catch(error =&gt; observer.error(error));</pre><pre>    // функция, вызывающаяся при отписке<br>    return () =&gt; {<br>      // отменяем запрос<br>      controller.abort();<br>    };</pre><pre>  });<br>};</pre><p>Также поменяем метод getUsersRepsFromApi:</p><pre>const getUsersRepsFromAPI = (username) =&gt; {<br>  const url = `https://api.github.com/users/${ username }/repos`;<br>  return createCancellableRequest(url);<br>}</pre><p>Теперь метод возвращает не promise, а observable. Поэтому уберем обертку from в switchMap:</p><pre>switchMap(value =&gt; {<br>  return getUsersRepsFromAPI(value).pipe(<br>    catchError(err =&gt; of([])<br>  )<br>)</pre><p><strong>Примечание: </strong>в RxJS версии 6.5 добавили оператор <a href="https://rxjs.dev/api/fetch/fromFetch">fromFetch</a>, который под капотом сам вызывает метод abort, поэтому вам больше не нужно писать свой “велосипед”.</p><p>Вот и все! Весь код примера можно найти <a href="https://stackblitz.com/edit/github-api-with-rxjs-2">здесь</a>.</p><h4>Заключение</h4><p>Сегодня мы рассмотрели, что такое HOO и несколько очень полезных операторов из данной категории. Конечно, это были далеко не все из них. Для более детальной и подробной информации рекомендую посетить <a href="https://rxjs.dev/api">документацию</a> по RxJS.</p><p>В следующей статье я планирую рассмотреть, в чем разница между Hot и Cold observables.</p><p>Напоследок: не используйте подписку в подписке, ведь есть HOO!</p><p>А если вы хотите всегда быть в курсе последних событий в мире Angular, рекомендую подписаться на <a href="https://t.me/angular_fox"><strong>Telegram канал</strong></a> и вступить в <a href="https://t.me/angular_ru"><strong>Angular группу</strong></a>.</p><p>Еще я веду канал про web3 технологии, если они вам интересны — то <a href="https://t.me/web_3_developer">подписывайтесь</a>.</p><ul><li><a href="https://t.me/web_3_developer">Web3Developer</a></li><li><a href="https://t.me/angular_fox">🦊 Angular Fox 🚀 - русскогорящие новости сообщества</a></li><li><a href="https://t.me/angular_ru">Angular - русскоговорящее сообщество</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d1337fbead32" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ngx/introducing-to-reactive-programming-d1337fbead32">Основы реактивного программирования с использованием RxJS</a> was originally published in <a href="https://medium.com/ngx">Angular Soviet</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Основы реактивного программирования с использованием RxJS]]></title>
            <link>https://medium.com/ngx/introducing-to-reactive-programming-with-rxjs-3583345faec1?source=rss-5360326dfbba------2</link>
            <guid isPermaLink="false">https://medium.com/p/3583345faec1</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[rxjs]]></category>
            <category><![CDATA[reactive-programming]]></category>
            <category><![CDATA[reactive]]></category>
            <category><![CDATA[angular]]></category>
            <dc:creator><![CDATA[Denis Makarov]]></dc:creator>
            <pubDate>Mon, 18 Mar 2019 11:32:44 GMT</pubDate>
            <atom:updated>2022-11-02T17:07:22.488Z</atom:updated>
            <content:encoded><![CDATA[<h4>Часть 2. <strong>Операторы и пайпы</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JlEQb_vMfz5uI79VuvEAxg.jpeg" /></figure><p>В <a href="https://medium.com/ngx/introducing-to-reactive-programming-984c1a390e2d">предыдущей статье</a> мы рассмотрели, что такое потоки и с чем их едят. В новой части мы познакомимся с тем, какие методы RxJS предоставляет для создания потоков, что такое операторы, пайпы(pipes) и как с ними работать.</p><p>Серия статей “Основы реактивного программирования с использованием RxJS”:</p><ul><li><a href="https://medium.com/ngx/introducing-to-reactive-programming-984c1a390e2d">Часть 1. Реактивность и потоки</a></li><li><a href="https://medium.com/ngx/introducing-to-reactive-programming-d1337fbead32">Часть 3. Higher Order Observables</a></li></ul><p>RxJS обладает богатейшим <a href="https://rxjs.dev/api">API</a>. В документации описано более ста методов. Чтобы немного познакомиться с ними, мы напишем простое приложение и на практике посмотрим, как выглядит реактивный код. Вы увидите, что одни и те же задачи, которые раньше казались рутинными и требовали написания большого количества кода, имеют элегантное решение, если смотреть на них сквозь призму реактивности. Но прежде чем мы перейдем к практике, рассмотрим, как потоки можно представить графически, и познакомимся с удобными методами для их создания и обработки.</p><h4><strong>Графическое представление потоков</strong></h4><p>Чтобы наглядно продемонстрировать, как ведет себя тот или иной поток, я буду использовать принятую в реактивном подходе нотацию. Вспомним наш пример из предыдущей статьи:</p><pre>const observable = new Observable((observer) =&gt; {<br>  observer.next(1);<br>  observer.next(2);<br>  observer.complete();<br>});</pre><p>Вот как будет выглядеть его графическое представление:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/716/0*jA6bZJI1hk53E0fl" /></figure><p>Поток обычно изображается в виде прямой линии. Если поток испускает какое-либо значение, то оно отображается на линии в виде кружка. Прямая черта в отображении — это сигнал завершения потока. Для отображения ошибки используется символ — “×”.</p><pre>const observable = new Observable((observer) =&gt; {<br>  observer.error();<br>});</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/1*u_H1mOFoofZ88SPQaJgx9w.png" /></figure><h4>Потоки в одну строчку</h4><p>В моей практике я редко сталкивался с необходимостью создавать свои экземпляры Observable напрямую. Большинство методов для создания потоков уже есть в RxJS. Чтобы создать поток, испускающий значения 1 и 2, достаточно лишь использовать метод of:</p><pre>const observable = of(1, 2);</pre><p>Метод of принимает на вход любое количество аргументов и возвращает готовый экземпляр Observable. После подписки он испустит полученные значения и завершится:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/716/0*5nNZh1_M6F64ZdTq" /></figure><p>Если вы хотите представить массив в виде потока, то можно воспользоваться методом from. Метод from в качестве аргумента ожидает любой итерируемый объект(массив, строка и т.д.) или promise, и проецирует этот объект на поток. Вот как будет выглядеть поток, полученный из строки:</p><pre>const observable = from(&#39;abc&#39;);</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/717/0*OSR7U9R_mp56pdoJ" /></figure><p>А вот так можно обернуть promise в поток:</p><pre>const promise = new Promise((resolve, reject) =&gt; {<br>  resolve(1);<br>});</pre><pre>const observable = from(promise);</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/714/0*MR6XiR9Rqxa3TMrs" /></figure><p><strong>Примечание: </strong>часто потоки сравнивают с promise. На самом деле, они имеют всего одну общую черту — <a href="https://medium.com/ngx/introducing-to-reactive-programming-984c1a390e2d#cb26">push стратегию</a> распространения изменений. В остальном это абсолютно разные сущности. Promise не может выдать несколько значений. Он может только выполнить resolve или reject, т.е. иметь только два состояния. Поток же может передавать несколько значений, и может быть<strong> </strong>повторно использован.</p><p>А помните пример с интервалом из <a href="https://medium.com/ngx/introducing-to-reactive-programming-984c1a390e2d#5851">первой статьи</a>? Данный поток представляет собой таймер, который отсчитывает время в секундах с момента подписки.</p><pre>const timer = new Observable(observer =&gt; {<br>  let counter = 0;<br>  const intervalId = setInterval(() =&gt; {<br>    observer.next(counter++);<br>  }, 1000);</pre><pre>  return () =&gt; {<br>   clearInterval(intervalId);<br>  }<br>});</pre><p>Вот как в одну строчку можно реализовать то же самое:</p><pre>const timer = interval(1000);</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/0*qJxKVZuaHCNIjoxO" /></figure><p>И напоследок метод, который позволяет создать поток событий DOM элементов:</p><pre>const observable = fromEvent(domElementRef, &#39;keyup&#39;);</pre><p>В качестве значений этот поток будет получать и испускать объекты события “keyup”.</p><h4>Пайпы &amp; операторы</h4><p>Pipe — это метод класса Observable, добавленный в RxJS в версии 5.5. Благодаря ему мы можем строить цепочки операторов для последовательной обработки значений, полученных в потоке. Pipe представляет собой однонаправленный канал, который связывает между собой операторы. Сами операторы являются обычными функциями, описанными в RxJS, которые обрабатывают значения из потока.</p><p>Например, они могут преобразовать значение и передать его дальше в поток, или могут выполнять роль фильтров и не пропускать какие-либо значения, если они не соответствуют заданному условию.</p><p>Посмотрим на операторы в деле. Умножим каждое значение из потока на 2 с помощью оператора map:</p><pre>of(1,2,3).pipe(<br>  map(value =&gt; value * 2)<br>).subscribe({<br>  next: console.log<br>});</pre><p>Вот как выглядит поток до применения оператора map:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/0*EAAvOgS7AWdRwwXc" /></figure><p>После оператора map:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/725/0*8Am-93gtGziV6YGq" /></figure><p>Давайте воспользуемся оператором filter. Этот оператор работает точно так же, как функция filter в классе Array. Первым аргументом метод принимает функцию, в которой описано какое-либо условие. Если значение из потока удовлетворяет условию, то оно пропускается дальше:</p><pre>of(1, 2, 3).pipe(<br>  // пропускаем только нечетные значения<br>  filter(value =&gt; value % 2 !== 0),<br>  map(value = value * 2)<br>).subscribe({<br>  next: console.log<br>});</pre><p>И вот как будет выглядеть вся схема нашего потока:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/703/0*1r-iKpDQoDIWWqb9" /></figure><p>После filter:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/709/0*064MKeIHQy9dYQjZ" /></figure><p>После map:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/702/0*qLLXSwP5DW4qYduu" /></figure><p><strong>Примечание</strong>: pipe !== subscribe. Метод pipe декларирует поведение потока, но не выполняет подписку. Пока вы не вызовете метод subscribe, ваш поток не начнет работать.</p><h4>Пишем приложение</h4><p>Теперь, когда мы выяснили, что такое пайпы и операторы, можно приступать к практике. Наше приложение будет выполнять одну простую задачу: выводить список открытых репозиториев github по введенному никнейму владельца.</p><p>Требований будет немного:</p><ul><li>не выполнять запрос к API, если введенная в input строка содержит менее 3-х символов;</li><li>Чтобы не выполнять запрос на каждый введенный пользователем символ, следует установить задержку(debounce) в 700 миллисекунд перед обращением к API;</li></ul><p>Для поиска репозиториев мы воспользуемся <a href="https://developer.github.com/v3/">github API</a>. Сами же примеры я рекомендую выполнять на <a href="https://stackblitz.com/">stackblitz</a>. Там же я выложил готовую реализацию. Ссылки представлены в конце статьи.</p><p>Начнем с html разметки. Опишем input и ul элементы:</p><pre>&lt;input type=&quot;text&quot;&gt;<br>&lt;ul&gt;&lt;/ul&gt;</pre><p>Затем в js или ts файле получим ссылки на текущие элементы используя browser API:</p><pre>const input = document.querySelector(&#39;input&#39;);<br>const ul = document.querySelector(&#39;ul&#39;);</pre><p>Ещё нам понадобится метод, который будет выполнять запрос к github API. Ниже приведен код функции getUsersRepsFromAPI, которая принимает на вход никнейм пользователя и выполняет ajax запрос, используя fetch. Затем возвращает promise, попутно преобразуя успешный ответ в json:</p><pre>const getUsersRepsFromAPI = (username) =&gt; {<br>  const url = `https://api.github.com/users/${ username }/repos`;<br>  <br>  return fetch(url)<br>    .then(response =&gt; {<br>      if(response.ok) {<br>        return response.json();<br>      }</pre><pre>      throw new Error(&#39;Ошибка&#39;);<br>    });<br>}</pre><p>Следом напишем метод, который будет выводить список названий репозиториев:</p><pre>const recordRepsToList = (reps) =&gt; {<br>  for (let i = 0; i &lt; reps.length; i++) {<br>  <br>    // если элемент не существует, то создаем его<br>    if (!ul.children[i]) {<br>      const newEl = document.createElement(&#39;li&#39;);<br>      ul.appendChild(newEl);<br>    }</pre><pre>    // записываем название репозитория в элемент<br>    const li = ul.children[i];<br>    li.innerHTML = reps[i].name;<br>  }</pre><pre>  // удаляем оставшиеся элементы<br>  while (ul.children.length &gt; reps.length) {<br>    ul.removeChild(ul.lastChild);<br>  }<br>}</pre><p>Приготовления завершены. Настало время посмотреть на RxJS в действии. Нам необходимо слушать событие keyup нашего input’а. Первым делом мы должны понять, что в реактивном подходе мы работаем с потоками. К счастью, в RxJS уже предусмотрен подобный вариант. Вспомните метод fromEvent, который я упоминал выше. Используем его:</p><pre>const keyUp = fromEvent(input, &#39;keyup&#39;);</pre><pre>keyUp.subscribe({<br>  next: console.log<br>});</pre><p>Теперь наше событие представлено как поток. Если мы посмотрим, что выводится в консоль, то увидим объект типа KeyboardEvent<strong>. </strong>Но нам нужно введенное пользователем значение. Вот тут-то нам и пригодится метод pipe и оператор map:</p><pre>fromEvent(input, &#39;keyup&#39;).pipe(<br>  map(event =&gt; event.target.value)<br>).subscribe({<br>  next: console.log<br>});</pre><p>Перейдем к реализации требований. Начнем с того, что будем выполнять запрос, когда введенное значение содержит более двух символов. Для этого воспользуемся оператором filter:</p><pre>fromEvent(input, &#39;keyup&#39;).pipe(<br>  map(event =&gt; event.target.value),<br>  filter(value =&gt; value.length &gt; 2)<br>)</pre><p>С первым требованием разобрались. Приступим ко второму. Нам необходимо реализовать debounce. В RxJS есть оператор debounceTime. Данный оператор в качестве первого аргумента принимает число миллисекунд, в течение которых значение будет удерживаться, прежде чем пройдет дальше. При этом каждое новое значение будет сбрасывать таймер. Таким образом, на выходе мы получим последнее значение, после ввода которого прошло 700 миллисекунд.</p><pre>fromEvent(input, &#39;keyup&#39;).pipe(<br>  debounceTime(700),<br>  map(event =&gt; event.target.value),<br>  filter(value =&gt; value.length &gt; 2)<br>)</pre><p>Вот как может выглядеть наш поток без debounceTime:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/694/0*ZwrGK7i7Mf_--MTe" /></figure><p>А вот так будет выглядеть тот же поток, пропущенный через этот оператор:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/672/0*C5Na14yROCBiXNLP" /></figure><p>С debounceTime мы будем реже обращаться к API, за счет чего получим экономию трафика и разгрузим сервер.</p><p>В целях дополнительной оптимизации предлагаю использовать еще один оператор — distinctUntilChanged. Данный метод избавит нас от дубликатов. Лучше всего показать его работу на примере:</p><pre>from(&#39;aaabccc&#39;).pipe(<br>  distinctUntilChanged()<br>)</pre><p>Без distinctUntilChanged:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/701/0*l9mvf3I_aemUiIf4" /></figure><p>С distinctUntilChanged:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/706/0*-Eu8sUrMxI2g_Fk5" /></figure><p>Добавим данный оператор сразу после оператора debounceTime. Таким образом, мы не будем обращаться к API, если новое значение по какой-то причине совпадает с предыдущим. Подобная ситуация может возникнуть, когда пользователь ввел новые символы, а затем снова стер их. Так как у нас реализована задержка, в поток попадет только последнее значение, ответ на которое у нас уже есть.</p><h4>Идем на сервер</h4><p>Уже сейчас мы можем описать логику запроса и обработки ответа. Пока мы умеем только работать с promise. Поэтому опишем еще один оператор map, который будет вызывать метод getUsersRepsFromAPI. В наблюдателе опишем логику обработки нашего promise:</p><pre>/* Код учебный! В рабочих проектах с RxJS лучше избегать использования promise, вместо него стоит использовать потоки */</pre><pre>fromEvent(input, &#39;keyup&#39;).pipe(<br>  debounceTime(700),<br>  map(event =&gt; event.target.value),<br>  filter(val =&gt; val.length &gt; 2),<br>  distinctUntilChanged(),<br>  map(value =&gt; getUsersRepsFromAPI(value))<br>).subscribe({<br>  next: promise =&gt; promise.then(reps =&gt; recordRepsToList(reps))<br>});</pre><p>На текущий момент мы реализовали все, что хотели. Но у нашего примера есть один большой недостаток: нет обработки ошибок. Наш наблюдатель получает только promise и понятия не имеет, что что-то могло пойти не так.</p><p>Конечно, мы можем навесить catch на promise в методе next, но из-за этого наш код начнет все больше напоминать “callback hell”. Если вдруг нам понадобится выполнить еще один запрос, то сложность кода возрастет.</p><p><strong>Примечание</strong>: использование promise в коде с RxJS считается антипаттерном. Promise имеет множество недостатков по сравнению с observable. Его нельзя отменить, и нельзя использовать повторно. Если перед вами стоит выбор, то выбирайте observable. То же самое касается метода toPromise класса Observable. Данный метод был реализован в целях совместимости с библиотеками, которые не могут работать с потоками.</p><p>Мы можем использовать метод from, чтобы спроецировать promise на поток, но этот способ чреват дополнительными вызовами метода subscribe, и также приведет к разрастанию и усложнению кода.</p><p>Решить эту проблему можно с помощью оператора mergeMap:</p><pre>fromEvent(input, &#39;keyup&#39;).pipe(<br>  debounceTime(700),<br>  map(event =&gt; event.target.value),<br>  filter(val =&gt; val.length &gt; 2),<br>  distinctUntilChanged(),<br>  mergeMap(value =&gt; from(getUsersRepsFromAPI(value)))<br>).subscribe({<br>  next: reps =&gt; recordRepsToList(reps),<br>  error: console.log<br>})</pre><p>Теперь нам не нужно писать логику обработки promise. Метод from сделал из promise поток, а оператор mergeMap обработал его. Если promise выполнится успешно, то вызовется метод next, и наш наблюдатель получит готовый объект. Если же произойдет ошибка, то будет вызван метод error, и наш наблюдатель выведет ошибку в console.</p><p>Оператор mergeMap немного отличается от тех операторов, с которыми мы работали ранее, он принадлежит к так называемым <a href="https://netbasal.com/understanding-mergemap-and-switchmap-in-rxjs-13cf9c57c885">Higher Order Observables</a>, о которых я расскажу в следующей статье. Но, забегая вперед, скажу, что метод mergeMap сам подписывается на поток.</p><p><a href="https://netbasal.com/understanding-mergemap-and-switchmap-in-rxjs-13cf9c57c885">Understanding mergeMap and switchMap in RxJS</a></p><h4>Обработка ошибок</h4><p>Если наш поток получит ошибку, то он завершится. И если попытаться после ошибки взаимодействовать с приложением, то никакой реакции мы не получим, так как наш поток завершится.</p><p>Тут нам поможет оператор catchError. catchError вызывается только тогда, когда в потоке появляется ошибка. Он позволяет перехватить ее, обработать и вернуть в поток обычное значение, которое не приведет к его завершению.</p><pre>fromEvent(input, &#39;keyup&#39;).pipe(<br>  debounceTime(700),<br>  map(event =&gt; event.target.value),<br>  filter(val =&gt; val.length &gt; 2),<br>  distinctUntilChanged(),<br>  mergeMap(value =&gt; from(getUsersRepsFromAPI(value))),<br>  catchError(err =&gt; of([])<br>).subscribe({<br>  next: reps =&gt; recordRepsToList(reps),<br>  error: console.log<br>})</pre><p>Мы перехватываем ошибку в catchError и вместо нее возвращаем поток с пустым массивом. Теперь при возникновении ошибки мы очистим список репозиториев. Но затем поток снова завершится.</p><p>Все дело в том, что catchError подменяет наш оригинальный поток на новый. И дальше наш наблюдатель слушает только его. Когда поток of испустит пустой массив, будет вызван метод complete.</p><p>Чтобы не подменять наш оригинальный поток, вызовем оператор catchError на потоке from внутри оператора mergeMap.</p><pre>fromEvent(input, &#39;keyup&#39;).pipe(<br>  debounceTime(700),<br>  map(event =&gt; event.target.value),<br>  filter(val =&gt; val.length &gt; 2),<br>  distinctUntilChanged(),<br>  mergeMap(value =&gt; {<br>    return from(getUsersRepsFromAPI(value)).pipe(<br>      catchError(err =&gt; of([])<br>    )<br>  })<br>).subscribe({<br>  next: reps =&gt; recordRepsToList(reps),<br>  error: console.log<br>})</pre><p>Таким образом, наш оригинальный поток ничего не заметит. Вместо ошибки он получит пустой массив.</p><h4>Заключение</h4><p>Мы наконец-то перешли к практике и увидели, для чего нужны пайпы и операторы. Рассмотрели, как можно сократить код, пользуясь богатым API, которое предоставляет нам RxJS. Конечно, наше приложение не закончено, в следующей части мы разберем, как можно в одном потоке обрабатывать другой и как отменять наш http запрос, чтобы еще больше экономить трафик и ресурсы нашего приложения. А чтобы вы могли увидеть разницу, я выложил пример без использования RxJS, посмотреть его можно <a href="https://stackblitz.com/edit/without-rxjs-example?file=index.js">здесь</a>. По <a href="https://stackblitz.com/edit/github-api-with-rxjs?file=index.ts">этой ссылке</a> вы найдете полный код текущего приложения. Для генерации схем я пользовался <a href="https://rxviz.com/v/XJzKNLX8">RxJS визуализатором</a>.</p><p>Надеюсь, что данная статья помогла вам лучше понять, как устроен RxJS. Желаю вам успехов в изучении!</p><p>А если вы хотите всегда быть в курсе последних событий в мире Angular, рекомендую подписаться на <a href="https://t.me/angular_fox"><strong>Telegram канал</strong></a> и вступить в <a href="https://t.me/angular_ru"><strong>Angular группу</strong></a>.</p><p>Еще я веду канал про web3 технологии, если они вам интересны — то <a href="https://t.me/web_3_developer">подписывайтесь</a>.</p><ul><li><a href="https://t.me/web_3_developer">Web3Developer</a></li><li><a href="https://t.me/angular_fox">🦊 Angular Fox 🚀 - русскогорящие новости сообщества</a></li><li><a href="https://t.me/angular_ru">Angular - русскоговорящее сообщество</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3583345faec1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ngx/introducing-to-reactive-programming-with-rxjs-3583345faec1">Основы реактивного программирования с использованием RxJS</a> was originally published in <a href="https://medium.com/ngx">Angular Soviet</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Основы реактивного программирования с использованием RxJS]]></title>
            <link>https://medium.com/ngx/introducing-to-reactive-programming-984c1a390e2d?source=rss-5360326dfbba------2</link>
            <guid isPermaLink="false">https://medium.com/p/984c1a390e2d</guid>
            <category><![CDATA[rxjs]]></category>
            <category><![CDATA[reactive-programming]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Denis Makarov]]></dc:creator>
            <pubDate>Fri, 08 Feb 2019 10:20:47 GMT</pubDate>
            <atom:updated>2019-05-21T17:20:27.849Z</atom:updated>
            <content:encoded><![CDATA[<h4>Часть 1. Реактивность и потоки</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BX5v1xiPJ6Yshmo3cHgUZg.jpeg" /></figure><p>Данная серия статей посвящена реактивности и ее применению в JS с использованием такой замечательной библиотеки как RxJS.</p><p>Серия статей “Основы реактивного программирования с использованием RxJS”:</p><ul><li><a href="https://medium.com/ngx/introducing-to-reactive-programming-with-rxjs-3583345faec1">Часть 2. Операторы и пайпы</a></li><li><a href="https://medium.com/ngx/introducing-to-reactive-programming-d1337fbead32">Часть 3. Higher Order Observables</a></li></ul><p><strong>Для кого эта статья</strong>: в основном, здесь я буду объяснять основы, поэтому в первую очередь статья рассчитана на новичков в данной технологии. Вместе с тем надеюсь, что и опытные разработчики смогут почерпнуть для себя что-то новое. Для понимания потребуются знания JS (es5/es6).</p><p><strong>Мотивация</strong>: впервые я столкнулся с RxJS, когда начал работать с Angular. Именно тогда у меня возникли сложности с пониманием механизма реактивности. Сложности прибавлял еще тот факт, что на момент начала моей работы большинство статей было посвящено старой версии библиотеки. Пришлось читать много документации, различных мануалов, чтобы хоть что-то понять. И только спустя некоторое время я начал осознавать, как “все устроено”. Чтобы упростить жизнь другим, я решил разложить все по полочкам.</p><h4>Что такое реактивность?</h4><p>Сложно найти ответ на, казалось бы, такой распространенный термин. Если кратко: реактивность — это способность реагировать на какие-либо изменения. Но о каких изменениях идет речь? В первую очередь, об изменениях данных. Рассмотрим пример:</p><pre>let a = 2; <br>let b = 3; </pre><pre>let sum = a + b;</pre><pre>console.log(sum); <em>// 5</em> </pre><pre>a = 3;</pre><pre>// значение не поменялось, потому что данные нужно пересчитать<br>console.log(sum); <em>// 5</em></pre><p>Данный пример демонстрирует привычную нам императивную парадигму программирования. В отличие от императивного подхода, реактивный подход строится на push стратегии распространения изменений. Push стратегия подразумевает, что в случае изменения данных эти самые изменения будут “проталкиваться”, и зависимые от них данные будут автоматически обновляться. Вот как бы вел себя наш пример, если бы применялась push стратегия:</p><pre>let a = 2;<br>let b = 3;</pre><pre>let sum = a + b;</pre><pre>console.log(sum); <em>// 5</em></pre><pre>a = 3;</pre><pre>// <em>значение переменной sum автоматически пересчитается<br></em>console.log(sum); // 6</pre><p>Данный пример показывает реактивный подход. Стоит отметить, что этот пример не имеет ничего общего с реальностью, я его привел лишь с целью показать разницу в подходах. Реактивный код в реальных приложениях будет выглядеть совсем иначе, и прежде чем перейти к практике, нам стоит поговорить еще об одной важной составляющей реактивности.</p><h4>Поток данных</h4><p>Если поискать в Википедии термин “реактивное программирование”, то сайт нам выдаст следующее определение: “Реактивное программирование — парадигма программирования, ориентированная на потоки данных и распространение изменений”. Из этого определения можно сделать вывод, что реактивность базируется на двух основных “китах”. Про распространение изменений я упоминал выше, поэтому дальше мы на этом останавливаться не будем. А вот про потоки данных следует поговорить подробнее. Посмотрим на следующий пример:</p><pre><em>// получаем ссылку на элемент</em><br>const input = document.querySelector(&#39;input&#39;);</pre><pre>const eventsArray = [];</pre><pre><em>// пушим каждое событие в массив eventsArray</em><br>input.addEventListener(&#39;keyup&#39;,<br>  event =&gt; eventsArray.push(event)<br>);</pre><p>Мы слушаем событие keyup и кладем объект события в наш массив. Со временем наш массив может содержать тысячи объектов KeyboardEvent. При этом стоит отметить, что наш массив отсортирован по времени — индекс более поздних событий больше, чем индекс более ранних. Такой массив представляет собой упрощенную модель потока данных. Почему упрощенную? Потому что массив умеет только хранить данные. Еще мы можем проитерировать массив и как-то обработать его элементы. Но массив не может сообщить нам о том, что в него был добавлен новый элемент. Для того, чтобы узнать, были ли добавлены новые данные в массив, нам придется снова проитерировать его.</p><p>Но что, если бы наш массив умел сообщать нам о том, что в него поступили новые данные? Такой массив можно было бы с полной уверенностью назвать потоком. Итак, мы подошли к определению потока. Поток — это массив данных, отсортированных по времени, который может сообщать о том, что данные изменились.</p><h4>Observable</h4><p>Теперь, когда мы знаем, что такое потоки, давайте поработаем с ними. В RxJS потоки представлены классом Observable. Чтобы создать свой поток, достаточно вызвать конструктор данного класса и передать ему в качестве аргумента функцию подписки:</p><pre>const observable = new Observable(observer =&gt; {<br>  observer.next(1);<br>  observer.next(2);<br>  observer.complete();<br>})</pre><p>Через вызов конструктора класса Observable мы создаем новый поток. В качестве аргумента в конструктор мы передали функцию подписки. Функция подписки — это обычная функция, которая в качестве параметра принимает наблюдателя(observer). Сам наблюдатель представляет собой объект, у которого есть три метода:</p><ul><li>next — выбрасывает новое значение в поток</li><li>error — выбрасывает в поток ошибку, после чего поток завершается</li><li>complete — завершает поток</li></ul><p>Таким образом, мы создали поток, который испускает два значения и завершается.</p><h4>Subscription</h4><p>Если мы запустим предыдущий код, то ничего не произойдет. Мы лишь создадим новый поток и сохраним ссылку на него в переменную observable, но сам поток так никогда и не испустит ни одного значения. Это происходит потому, что потоки являются “ленивыми” объектами и ничего сами по себе не делают. Для того, чтобы наш поток начал испускать значения и мы могли бы эти значения обрабатывать, нам необходимо начать “слушать” поток. Сделать это можно, вызвав метод subscribe у объекта observable.</p><pre>const observer = {<br>  next: value =&gt; console.log(value), <em>// 1, 2<br>  </em>error: error =&gt; console.error(error), <em>//<br>  </em>complete: () =&gt; console.log(&quot;completed&quot;) <em>// completed<br></em>};</pre><pre>observable.subscribe(observer);</pre><p>Мы определили нашего наблюдателя и описали у него три метода: next, error, complete. Методы просто логируют данные, которые передаются в качестве параметров. Затем мы вызываем метод subscribe и передаем в него нашего наблюдателя. В момент вызова subscribe происходит вызов функции подписки, той самой, которую мы передали в конструктор на этапе объявления нашего потока. Дальше будет выполняться код функции-подписки, которая передает нашему наблюдателю два значения, а затем завершает поток.</p><p>Наверняка, у многих возник вопрос, что будет, если мы подпишемся на поток еще раз? Будет все то же самое: поток снова передаст два значения наблюдателю и завершится. При каждом вызове метода subscribe будет происходить обращение к функции-подписке, и весь ее код будет выполняться заново. Отсюда можно сделать вывод: сколько бы раз мы не подписывались на поток, наши наблюдатели получат одни и те же данные.</p><h4>Unsubscribe</h4><p>Теперь попробуем реализовать более сложный пример. Напишем таймер, который будет отсчитывать секунды с момента подписки, и передавать их наблюдателям.</p><pre>const timer = new Observable(observer =&gt; {<br>  <em>// объявляем счетчик<br></em>  let counter = 0; <em><br>  </em>setInterval(() =&gt; {<br>    <em>// передаем значение счетчика<br></em>    <em>// наблюдателю и увеличиваем его на единицу<br>    </em>observer.next(counter++);<em> <br>  </em>}, 1000);<br>});</pre><pre><em>// просто логируем каждое значение<br></em>timer.subscribe({ next: console.log });</pre><p>Код получился достаточно простой. Внутри функции-подписки мы объявляем переменную счетчик(counter). Затем, используя замыкание, получаем доступ к переменной из стрелочной функции в setInterval. И каждую секунду передаем переменную наблюдателю, после чего инкрементируем ее. Дальше подписываемся на поток, указываем только один метод — next. Не стоит переживать, что другие методы мы не объявили. Ни один из методов наблюдателя не является обязательным. Мы даже можем передать пустой объект, но в этом случае поток будет работать впустую.</p><p>После запуска мы увидим заветные логи, которые будут появляться каждую секунду. Если хотите, можете поэкспериментировать и подписаться на поток несколько раз. Вы увидите, что каждый из потоков будет выполняться независимо от остальных.</p><p>Если подумать, то наш поток будет выполняться в течение жизни всего приложения, ведь никакой логики отмены setInterval у нас нет, а в функции-подписке нет вызова метода complete. Но что, если нам нужно, чтобы поток завершился?</p><p>На самом деле все очень просто. Если посмотреть в документацию, то можно увидеть, что метод subscribe возвращает объект подписки. У данного объекта есть метод unsubscribe. Вызовем его, и наш наблюдатель перестанет получать значения из потока.</p><pre>const subscription = timer.subscribe({ next: console.log });<br><em>// поток завершится через 5 секунд<br></em>setTimeout(() =&gt; subscription.unsubscribe(), 5000);</pre><p>После запуска мы увидим, что счетчик остановится на цифре 4. Но, хоть мы и отписались от потока, наша функция setInterval продолжает работать. Она каждую секунду инкрементирует наш счетчик и передает его наблюдателю-пустышке. Чтобы такого не происходило, надо написать логику отмены интервала. Для этого нужно вернуть из функции-подписки новую функцию, в которой будет реализована логика отмены.</p><pre>const timer = new Observable(observer =&gt; {<br>  let counter = 0;<br>  const intervalId = setInterval(() =&gt; {<br>    observer.next(counter++);<br>  }, 1000);</pre><pre>  return () =&gt; {<br>   clearInterval(intervalId);<br>  }<br>});</pre><p>Теперь мы можем вздохнуть с облегчением. После вызова метода unsubscribe произойдет вызов нашей функции отписки, которая очистит интервал.</p><h4>Заключение</h4><p>В этой статье показаны отличия императивного подхода от реактивного, а также приведены примеры создания собственных потоков. В следующей части я расскажу о том, какие еще методы для создания потоков существуют и как их применять.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=984c1a390e2d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ngx/introducing-to-reactive-programming-984c1a390e2d">Основы реактивного программирования с использованием RxJS</a> was originally published in <a href="https://medium.com/ngx">Angular Soviet</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>