Começando por uma definição da própria documentação, o RxJS é uma biblioteca para construção de programas assíncronos ou baseado em eventos, utilizando uma sequência de observables. Não entendeu nada? Vamos tentar separar então alguns pontos dessa frase: 

Começando por uma definição da própria documentação, o RxJS é uma biblioteca para construção de programas assíncronos ou baseado em eventos, utilizando uma sequência de observables. Não entendeu nada? Vamos tentar separar então alguns pontos dessa frase: 
<ul>
<li style="font-weight: 400;" aria-level="1">Programas assíncronos: o exemplo mais simples para esse tipo de programa é quando o seu método, função ou componente no front-end espera alguma resposta de uma API. Não há uma resposta imediata para a sua requisição, ou seja não há uma resposta síncrona mas sim assíncrona ao que você pediu o servidor da API. </li>
</ul>
<ul>
<li style="font-weight: 400;" aria-level="1">Programas baseados em eventos: se a sua aplicação tem o mínimo de interação com o usuário, provavelmente você tem alguma estrutura de eventos para saber quando o usuário clicou em determinada parte da tela ou quando ele digitou em algum campo, por exemplo. Cada uma dessas ações gera um evento, um alerta de que algo aconteceu. A partir do momento que você tem controle de quando essas ações são realizadas e trabalha no seu código em resposta a elas, você tem um programa baseado em eventos. </li>
<li style="font-weight: 400;" aria-level="1">Sequência de observables: Para entender o que é uma sequência de observables, precisamos entender primeiro o que é um observable. Por enquanto, entenda-se como um tipo muito importante para o RxJS, que processa eventos ou valores futuros. </li>
</ul>
A documentação continua: o RxJS provê operadores, inspirados nos operadores de Array comuns a várias linguagens como map, filter, reduce, every, etc, que permitem lidar com assincronicidade e eventos como se fossem coleções. 
Apesar de ser mais utilizado no framework Angular, a biblioteca está no npm e pode ser utilizada em qualquer framework, inclusive substituindo bibliotecas de gerenciamento de estado como o redux. 
Por trás do RxJS, nós temos um padrão de projeto bem conhecido. Precisamos pegar carona em alguma das suas ideias para compreender o que foi pensado de estratégia para essa biblioteca. 
<div id="toc_container" role="navigation" aria-label="Table of Contents" data-nosnippet class="toc_white no_bullets toc_numbered toc_title_center">Sumário<ul class="toc_list"><li><a href="#Padrao-Observer-em-RxJS">1. Padrão Observer em RxJS</a></li><li><a href="#Relacao-do-padrao-Observer">2. Relação do padrão Observer </a><ul><li><a href="#Exemplo-pratico-da-aplicacao-do-padrao-na-biblioteca">2.1. Exemplo prático da aplicação do padrão na biblioteca </a></li></ul></li><li><a href="#Ponto-de-apoio-Marble-Diagram">3. Ponto de apoio: Marble Diagram </a></li><li><a href="#Conclusao">4. Conclusão </a></li></ul></div>
<h2>Padrão Observer em RxJS</h2>
Um padrão de projeto que pode ser utilizado para lidar com programas baseado em eventos é o Observer. Não à toa, o RxJS baseia a sua estrutura neste padrão. Primeiramente, define-se um objeto denominado Subject, que mantém uma lista de dependentes chamado observers, que são notificados a cada mudança de estado de alguma variável a qual se queira associar um evento. 
Para que fique claro, vejamos um diagrama desse padrão: 
<img fetchpriority="high" decoding="async" class="alignnone" src="https://lydian-ton-edd.notion.site/image/https%3A%2F%2Fs3-us-west-2.amazonaws.com%2Fsecure.notion-static.com%2F73b95b5a-73a7-49f2-969b-554481660a0c%2FUntitled.png?table=block&amp;id=901fbd53-cefc-4751-a051-ed755b59be1d&amp;spaceId=74d6766d-17a9-4ec7-8ff4-7b83e33e1590&amp;width=2730&amp;userId=&amp;cache=v2" alt="Padrão Observer " width="2000" height="827" />
No diagrama acima, a classe Subject possui uma propriedade com a coleção dos seus observers (observeCollection), um método para registrar novos observers (registerObserver) um método para desassociar observers do seu controle (unregisterObserver) e por fim, o método mais importante, de notificar os observers de alguma atualização (notifyObservers). 
Uma interface Observer controla a assinatura do método de atualização em cada instância atrelada ao Subject. Por sua vez, cada observer concreto, possui um método de atualização a seu critério, contando que seja seguido a assinatura da interface. 
Basicamente, na maioria das vezes que se deseja enviar uma notificação de estado para algum lugar da sua aplicação, de maneira centralizada, podemos utilizar o padrão de projeto Observer. 
<h2>Relação do padrão Observer </h2>
Ok, mas qual é a relação desse padrão de projeto com o RxJS? Vejamos alguns conceitos essenciais dessa biblioteca, para que naturalmente nós enxerguemos a relação: 
<ul>
<li style="font-weight: 400;" aria-level="1">Observable: coleção invocável de valores ou eventos futuros. </li>
</ul>
<ul>
<li style="font-weight: 400;" aria-level="1">Observer: coleção de callbacks que sabem como ler os valores entregues pelos Observables. </li>
<li style="font-weight: 400;" aria-level="1">Subscription (inscrição): representa a execução de um Observable, é primariamente utilizado para cancelar a sua execução. </li>
</ul>
<a href="https://osagilistas.com/"><img decoding="async" class="alignnone wp-image-17485 size-large" src="https://www.cms.dtidigital.com.br/wp-content/uploads/2021/08/CTA-entrechaves-1024x255.png" alt="RxJS - Entre Chaves " width="1024" height="255" srcset="https://www.cms.dtidigital.com.br/wp-content/uploads/2021/08/CTA-entrechaves-1024x255.png 1024w, https://www.cms.dtidigital.com.br/wp-content/uploads/2021/08/CTA-entrechaves-300x75.png 300w, https://www.cms.dtidigital.com.br/wp-content/uploads/2021/08/CTA-entrechaves-768x191.png 768w, https://www.cms.dtidigital.com.br/wp-content/uploads/2021/08/CTA-entrechaves.png 1205w" sizes="(max-width: 1024px) 100vw, 1024px" /></a>
Conseguimos associar diretamente o conceito de Observer do RxJS com o conceito de Observer do padrão de projeto descrito anteriormente, ambos estão sujeitos a receber valores emitidos por uma entidade, no caso do padrão de projeto, o Subject e no caso do RxJS os Observables com a realização da sua inscrição. 
Agora vamos aplicar esses conceitos na prática, com alguns exemplos trazidos da própria documentação da biblioteca. 
<h3>Exemplo prático da aplicação do padrão na biblioteca </h3>
Exemplo 1: 
[js]
import { of } from &#8216;rxjs&#8217;;
of(10, 20, 30) 
.subscribe( 
next =&gt; console.log(&#8216;next:&#8217;, next), 
err =&gt; console.log(&#8216;error:&#8217;, err), 
() =&gt; console.log(&#8216;the end&#8217;), 
);
// Saídas 
// next: 10 
// next: 20 
// next: 30 
// Fim
[/js]
Para que possamos explicar <a href="https://www.youtube.com/watch?v=DBHpS2CqGZs">qualquer exemplo de RxJS</a>, nós precisamos de alguma fonte de valores ou eventos futuros, um Observable. Para esse exemplo, foi utilizado o operador of, que recebe uma lista de argumentos e retorna um Observable que emitirá cada valor de forma sequencial e completará. 
Levando em consideração a saída que esse código emitiu, nós percebemos que cada valor emitido pelo operador of (10, 20 e 30), foi passado para dentro da callback logo abaixo do método subscribe. Mais especificamente, cada valor foi passado somente pela callback com o argumento next. 
Considerando esse resultado, vamos quebrar esse código em algumas partes para que possamos entender o que está acontecendo: 
<code>import { of } from 'rxjs';</code> 
<code>of(10, 20, 30) </code>
Primeiramente, importamos o operador of do pacote rxjs. Em seguida chamamos a função passando três argumentos que serão emitidos em sequência, como explicado anteriormente. 
<code>.subscribe(</code>
O método subscribe irá gerar uma Subscription ou seja, é por meio desse método que permitimos a execução da emissão de valores do Observable definido anteriormente. Dentro do subscribe podemos passar 3 argumentos:
<code>next =&gt; console.log('next:', next),</code> 
<code>err =&gt; console.log('error:', err),</code> 
<code>() =&gt; console.log('the end'),</code>
<ul>
<li>O primeiro argumento é uma callback de next, ou seja, essa função irá tratar cada valor emitido pelo Observable, nesse caso, para o operador of, ela será executada para os valores, 10, 20 e 30 (emitidos anteriormente), respectivamente.</li>
<li>O segundo argumento é uma callback de err, ou seja, essa função será executada caso durante a emissão dos valores do Observable haja algum sinal de erro emitido pelo mesmo.</li>
<li>O terceiro e último argumento é uma callback de complete. Os Observables podem emitir um sinal de complete, indicando que todos os seus valores ou eventos futuros foram emitidos e a partir de agora nada mais será emitido. No caso do of, esse sinal é emitido junto com a emissão do último valor, no caso do nosso exemplo, o operador emite o valor 30 e o sinal de complete. A callback de complete realiza alguma ação assim que o Observable emite este tipo de sinal.</li>
</ul>
<h2>Ponto de apoio: Marble Diagram </h2>
Podemos representar o código do exemplo e a sua execução através de um diagrama chamado marble diagram, ou diagrama de bolinhas: 
<img decoding="async" class="alignnone size-full wp-image-17491" src="https://www.cms.dtidigital.com.br/wp-content/uploads/2021/08/RxJS-.png" alt="RxJS" width="640" height="180" srcset="https://www.cms.dtidigital.com.br/wp-content/uploads/2021/08/RxJS-.png 640w, https://www.cms.dtidigital.com.br/wp-content/uploads/2021/08/RxJS--300x84.png 300w" sizes="(max-width: 640px) 100vw, 640px" />
Esse diagrama é dividido nas seguintes partes: 
<ul>
<li style="font-weight: 400;" aria-level="1">O quadrado representa a execução de um operador, com os seus argumentos.</li>
<li style="font-weight: 400;" aria-level="1">A seta representa uma passagem de tempo. </li>
<li style="font-weight: 400;" aria-level="1">As bolinhas são os valores emitidos ao longo do tempo. </li>
<li style="font-weight: 400;" aria-level="1">O traço vertical representa o ponto onde o Observable emitiu o sinal de complete. </li>
</ul>
Então, assim como vimos, juntamente com o valor 30 emitido pelo operador, ele emite também o sinal de complete, como visto na última bolinha do diagrama. 
<h2>Conclusão </h2>
Dada o nosso exemplo, o mais interessante é pensar que se substituíssemos o operador of por algum Observable que, por exemplo, emitisse cada valor digitado pelo usuário num campo de formulário, poderíamos fazer uma tratativa na função next de limitação de caracteres desse campo, ou uma busca no lado do servidor do termo pesquisado, dentre outras aplicações. Esse é um exemplo do poder do RxJS e seu paradigma reativo. 
Neste artigo conseguimos associar um conceito da Engenharia de Software, o padrão Observer, que permitiu a criação do RxJS. Também abordamos algumas peças fundamentais para que você entenda exemplos mais complexos daqui para frente, como a divisão dos argumentos da função subscribe. Dessa maneira<a href="https://www.cms.dtidigital.com.br/blog/como-gerar-graficos-usando-python/"> você conseguirá ir agregando outras peças a esse entendimento</a> e utilizar melhor esta biblioteca poderosa nos seus projetos. 
Gostou do conteúdo? Em nosso podcast técnico, o<a href="https://osagilistas.com/"> Entre Chaves</a>, você confere insights como esse para sua carreira de desenvolvedor(a) ou entusiasta do assunto. Te esperamos lá!
<img loading="lazy" decoding="async" class="wp-image-15530 size-full" src="https://www.cms.dtidigital.com.br/wp-content/uploads/2021/05/Entre-chaves-banner2-1.png" alt="RxJS - Entre Chaves " width="960" height="150" />

RxJS: Primeiros passos e aprendizados de desenvolvimento

Desbloqueie o futuro do seu negócio

Mais conteúdos como esse

Travessa Dona Zilda, 125, sala 203, São Gonçalo – Pelotas, RS. CEP: 96075-166

14841 Dallas Parkway, 8th Floor Addison, TX 75254

R. Levindo Lopes, 357, 5º e 12º Andar – Savassi, Belo Horizonte MG, 30112-010