Programação Reativa em JavaScript (Node.js): biblioteca RxJS

Programação Reativa em JavaScript (Node.js) com RxJS

Programação reativa é um paradigma orientado a fluxos de dados assíncronos e propagação de mudanças. No ecossistema JavaScript (Node.js), uma das bibliotecas mais poderosas para implementar esse paradigma é o RxJS (Reactive Extensions for JavaScript). Ela fornece ferramentas para trabalhar com Observable (sequências observáveis), permitindo que desenvolvedores processem eficientemente eventos, requisições HTTP, temporizadores e outras fontes de dados assíncronas.

Conceitos Principais do RxJS

Na base do RxJS estão três componentes-chave:

• Observable (Objeto Observável) — representa um fluxo de dados que pode gerar valores ao longo do tempo.
• Observer (Observador) — objeto que se inscreve no Observable e reage à chegada de novos dados (next), erros (error) ou conclusão do fluxo (complete).
• Subscription (Inscrição) — resultado da chamada do método subscribe(). Permite gerenciar o ciclo de vida da inscrição (por exemplo, cancelá-la).

Também desempenham um papel importante os operadores — funções puras que permitem transformar, filtrar, combinar e mesclar fluxos de dados.

Instalação e Configuração

Para usar RxJS em um projeto Node.js, basta instalar o pacote via npm:

npm install rxjs

Após a instalação, a biblioteca está pronta para uso. Importe os componentes necessários:

const { Observable, of, from, interval } = require('rxjs');const { map, filter, take } = require('rxjs/operators');

Criação de Observable

Existem várias formas de criar fluxos de dados. Vejamos as básicas:

1. Criação a partir de um array

const { from } = require('rxjs');

const numbers$ = from([1, 2, 3, 4, 5]);numbers$.subscribe({    next: value => console.log(`Recebido: ${value}`),    complete: () => console.log('Fluxo concluído')});

Resultado da execução:

Recebido: 1Recebido: 2Recebido: 3Recebido: 4Recebido: 5Fluxo concluído

2. Geração periódica de valores

const { interval } = require('rxjs');const { take } = require('rxjs/operators');

const timer$ = interval(1000).pipe(    take(4) // limitamos a 4 valores);

timer$.subscribe({    next: value => console.log(`Tick ${value}`),    complete: () => console.log('Temporizador concluído')});

Saída (com intervalo de 1 segundo):

Tick 0Tick 1Tick 2Tick 3Temporizador concluído

Trabalhando com Operadores

Os operadores são o coração do RxJS. Eles permitem transformar dados em tempo real. Vejamos dois operadores populares:

• map — transforma cada valor do fluxo.
• filter — permite apenas os valores que satisfazem uma condição.

const { of } = require('rxjs');const { map, filter } = require('rxjs/operators');

const source$ = of(1, 2, 3, 4, 5, 6);

source$.pipe(    filter(value => value % 2 === 0), // mantém apenas pares    map(value => value * 10)          // multiplica cada um por 10).subscribe({    next: value => console.log(`Resultado: ${value}`),    complete: () => console.log('Pronto')});

Resultado:

Resultado: 20Resultado: 40Resultado: 60Pronto

Tratamento de Erros em Fluxos Reativos

RxJS fornece mecanismos integrados para tratamento de erros. Por exemplo, o operador catchError permite capturar uma exceção e continuar a execução:

const { throwError, of } = require('rxjs');const { catchError } = require('rxjs/operators');

const error$ = throwError(() =>