RxJS

# RxJS - Pipe
A função `pipe` é a linha de junção a partir da sua fonte de dados observáveis
através seus operadores. Como um material bruto em uma fábrica passa por uma
série de paradas antes de se tornar em um produto final, dados de fonte conseguem
passar por uma pipeline de operadores onde você consegue manipular, filtrar, e
transformar dados que se ajustam ao seu caso de uso. Não é raro usar 5 ou mais
operadores dentro de uma observable chain, contido dentro de uma função `pipe`.





# RxJS - Operators

Operadores oferecem uma forma de manipular valores de uma fonte, retornando um
observable dos valores transformados. Muitos dos operadores RxJS parecerão familiar
se você está acostumado com os métodos `Array`.
Por exemplo, se você quiser transformarvalores emitidos de uma observable source,
você pode usar `map`.
Se você quiser filtrar por valores específicos, você pode usar `filter`
Em prática, se houver um problema que você precisa resolver, é mais que provável
que tenha um operador para ele. E enquanto o número absoluto de operadores possa
ser desgastante assim que você começa a sua jornada em RxJS, você pode reduzí-lo
a algo pequeno e útil para começar a ser efetivo.


## Operadores conseguem agrupados em categorias comuns
A primeira parada quando procurando pelo operador correto é encontrar uma categoria
relacionada. Necessida filtrar dados de uma fonte? Olhe os operadores de 'filtragem'.
Tentando encontrar um bug, ou depurar o fluxo de dados através da sua stream
de dados? Há operadores 'utilitários' que possam resolver isso. As categorias
de operadores incluem:

### Operadores de Criação
Esses operadores permitem a criação de um observable a partir de quase tudo.
Do genérico a casos de uso específico você está livre de transformar tudo em um stream.
Por exemplo, supondo que criamos uma barra de progresso assim que o usuário role
a página em um artigo. Conseguiríamos transformar o evento de rolagem em uma
stream utilizando o operador `fromEvent`.
Os operadores de criação mais comuns são `of`, `from` e `fromEvent`.

### Operadores de Combinação
Os operadores de combinação permitem a junção de informação a partir de múltiplos
observables. Ordem, tempo, e estrutura de valores emitidps são as variações primárias
dentre esses operadores.
Por exemplo, conseguimos combinar atualizações de diversas fontes de dados para performar
um cálculo.
Os operadores de combinação mais usados são `combineLatest`, `concat`, `merge`,
`startWith`, `withLatestFrom`.

### Operadores de Resolução de Erros
Os operadores para lidar com erros oferecem formas efetivas para lidar com os
erros graciosamente e performar novas tentativas, caso ocorram.
Por exemplo, conseguimos usar `catchError` para	proteger contra requisições
de rede mal-sucedidas.

### Operadores de Filtragem
Os operadores de filtragem oferecem técnicas para aceitar - ou rejeitar - valores
de uma fonte observável e lidar com 'contrapressão', ou a construção de valores
dentro de uma stream.
Por exemplo, conseguimos utilizar o operador `take` para capturar somente os 5
primeiros valores emitidos de uma fonte.
Os operadores de filtragem mais utilizados são `debounceTime`, `distinctUntilChanged`,
`filter`,`take`, e `takeUntil`.

### Operadores de Multicasting
Em RxJS, observables são 'cold' ou 'unicast' (uma fonte por subscriber) por padrão.
Esses operadores conseguem tornar um observable 'hot', ou 'multicast', permitindo
efeitos colaterais serem compartilhados dentre múltiplos subscribers.
Por exemplo, podemos querer que 'late subscribers' compartilhem e recebam o
último valor emitido de uma fonte ativa.
O operador de multicasting mais usado é o `shareReplay`.

### Operadores de Transformação
Transformar valores assim que eles passam em uma cadeia de operadores é uma
tarefa comum. Esses operadores oferecem técnicas de transformação para praticamente
qualquer caso de uso que você irá encontrar.
Por exemplo, podemos querer acumular um objeto de estado a partir de uma fonte
ao decorrer do tempo, similarmente ao Redux.
Os operadores de trasformação mais utilizados são `concatMap`, `map`, `mergeMap`,
`scan` e `switchMap`.


## Operadores tem comportamentos comuns
Enquanto operadores conseguem ser agrupados em categorias comuns, operadores dentro
de uma categoria habitualmente compartilham um comportamento comum. Reconhecendo
esse comportamento comum você consegue começar criar uma árvore de
"escolha seu próprio operador" na sua cabeça.
Por exemplo, uma grande quantidade de operadores conseguem ser agrupados em...

### Operadores que 'achatam'
Ou em outras palavras, operadores que gerenciam a subscription de um observable
interior, emitindo esses valores a uma única fonte observável. Um caso de uso comum
para operadores de achatamento é lidar com requisições HTTP em um a API promise-based
ou observable-based, porém isso está somente arranhando a superfície.

Podemos então dividir operadores de achatamento em comportamentos comuns como...

### Operadores 'switch'
Como um interruptor de luz, operadores baseados em `switch` desligarão (unsubscribe)
o observable atual e ligarão um novo observable para emissões a partir daquela
fonte. Operadores `switch` são úteis em situações que você não quer (ou precisa)
mais do que um observable ativo por vez.
Operadores baseados em 'switch' incluem `switchAll, `switchMap` e `switchMapTo`.

### Operadores 'concat'
Comparável a uma fila em uma máquina ATM, a próxima transação não consegue começar
até que a anterior termite. Em termos de observable, somete uma subscription pode
acontecer por vez, em ordem, disparado pela conclusão da anterior.
Operadores 'concat' incluem `concat`, `concatAll`, `concatMap`, `concatMapTo`.

### Operadores `merge`
Como uma pista de fusão na interestadual, operadores baseados em `merge` dão suporte
a múltiplos observables ativos fluindo em uma pista de maneira 'primeiro a chegar, primeiro a ser servido'
Operadores `merge` são úteis em situações onde você quer disparar uma ação quando
um evento de uma ou mais fontes ocorram:

## Outras similaridades entre operadores
Há também operadores que compartilham um objetivo similar mas oferecem flexibilidade
em seus gatilhos. Por exemplo, para desinscrever de um observable após uma condição
específica ser satisfeita, conseguimos utilizar:
1. `take` quando sabemos que somente iremos quer 'n' valores
2. `takeLast` quado queremos somente os últimos 'n' valores.
3. `takeWhile` quando temos uma expressão predicada para suprir.
4. `takeUntil` quando somente quisermos que a fonte permaneça ativa até outra
fonte emitir.

Enquanto o número de operadores em RxJS consiga ser desgastante no começo, esses
comportamentos e padrões comuns conseguem fazer ponte rapidamente enquanto se aprende
RxJS.



##
Assim que você se torna familiar com programação 'push-based' através de Observables,
você começa modelar todo comportamento assíncrono em suas aplcações através
de streams observáveis. Isso abre soluções simples e flexibilidade para comportamento
notavelmente complexo.
Por exemplo, supondo que queiramos fazer uma requisição que salva atividade de usuário
quando ele responde uma pergunta no quiz. Nossa implementação inicial pode usar
o operator `mergeMap`, que dispara uma requisição de salvar a cada evento.
Após, é determinado que precisamos assegurar ordem desses saves. Equipado com o
conhecimento do comportamento dos operadores, ao invés de implementar um sistema
complexo de fila, conseguimos substituir o operador `mergeMap` pelo `concatMap`
e fazer o push das nossas mudanças.