RxJS is a library for composing asynchronous and event-based programs by using observable sequences. 


rxjs

Operators are the core building blocks for reacting to data in your JavaScript applications.

In this course you will learn what operators are, and then take a tour of the most useful operators that RxJS has to offer.

We have covered the basics of what is Observable.create, and other creation functions. Now lets finally dive into operators, which are the focus of this course. We will see how operators are simple pure functions attached to the Observable type.

🚨 Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. `Observable.create` is deprecated, use `new Observable` instead. You can no longer `.{operator}`, you need to `.pipe({operator})` instead.

Understand RxJS Operators

There are many operators available, and in order to understand them we need to have a simple way of communicating how they transform a source Observable into a result Observable over time. To show this we use Marble Diagrams to easily explain what is happening. Throughout this course we are going to see the so-called marble diagrams.

🚨 Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. `Observable.create` is deprecated, use `new Observable` instead. You can no longer `.{operator}`, you need to `.pipe({operator})` instead.

Use Marble Diagrams to Understand RxJS Operators

transforming the values emitted by observables.
We made our first operator called multiplyBy, which looks a bit useful, but in practice we don't need it because it's too specific: it only does simple multiplication on numbers. In this lesson we will see how the map() operator is useful for any calculation on delivered values.

🚨 Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead.

Use RxJS mapTo and map to Transform Values Emitted by Observables

inspect the behavior of other operators
We just saw map which is a transformation operator. There are a couple of categories of operators, such as filtering, combination, flattening, etc. One of these categories is the utility operators. The most important utility operator is `do`, useful for debugging.

🚨 Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. `do` is deprecated, use `tap` instead. You can no longer `.{operator}`, you need to `.pipe({operator})` instead.

Inspect the Behavior of Operators with RxJS do

through a predicate function that tells what is the criteria to pass or reject an event.
This lesson introduces filter: an operator that allows us to let only certain events pass, while ignoring others.

🚨 Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead.

Filter Events  Based on a Predicate with RxJS filter


There are more operators in the filtering category besides filter(). This lesson will teach how take(), first(), and skip() are simply operators to ignore or pass a certain amount of events from the source Observable.

🚨 Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead.

Filter Events with RxJS Operators take, first, and skip

Operators take(), skip(), and first() all refer to values emitted in the beginning of an Observable execution. In this lesson we will see similar operators which refer instead to the end of an Observable execution, such as takeLast().

🚨 Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead.

Filter Events with RxJS Operators takeLast and last

Some Observables may complete, and we may want to append another Observable to the one which just completed. This lesson teaches you how to use the concat() operator for either appending or prepending, and how the shortcut operator startWith() is an easy way of prepending values to an Observable.

🚨 Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead.

Prepend/Append Data with RxJS Operators concat and startWith

In the category of combination operators, concat executes Observables sequentially, while merge executes them in parallel. This lesson will teach you how the merge operator is an OR-style combination operator that blends two or more Observables together.

🚨 Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead.

Merge Values in Parallel with RxJS Operator merge

While merge is an OR-style combination operator, combineLatest is an AND-style combination operator. This lesson explains what AND-style combination means, and how you can join values from two or more Observables in a formula.

🚨 Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. To use `combineLatest`, you can no longer do `{Observable}.combineLatest({Observable})`, instead, do `combineLatest({Observable}, {Observable})`.

Join Values from Multiple Observables with RxJS combineLatest

Operator combineLatest is not the only AND-style combinator. In this lesson we will explore withLatestFrom, another AND-style combination operator, and how it works essentially as map() operator, with some combination properties.

🚨  Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. To link together multiple Observables and Operators, the method is a bit different. You call `zip` first, then list your Observables, your functions, then pipe your Operators. 

Control the Output of Values with RxJS Operator withLatestFrom

CombineLatest and withLatestFrom are both AND-style combination operators. In this lesson, we will learn about zip, our last AND-style combinator. It uses the n-th value of each member Observable to produce the n-th output value.

🚨  Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. 

Combine Values with RxJS Operator zip

All of the combination operators take two or more observables as input. These operators may also be alternatively called "vertical combination operators", because of how they work in a marble diagram. Next, we will learn about scan(), which is an important "horizontal combination operator".

🚨  Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. To link together multiple Observables and Operators, the method is a bit different. You call `zip` first, then list your Observables, your functions, then pipe your Operators. 

Combine Values of One Observable with RxJS scan

This lesson will teach you about another horizontal combination operator: buffer and its variants. Buffer groups consecutive values together, emitting the output as an array. The buffer variants and their arguments allow to specify when to close the buffers.

🚨  Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. To link together multiple Observables and Operators, the method is a bit different. You call `zip` first, then list your Observables, your functions, then pipe your Operators. 

Group Consecutive Values Together with RxJS Operator buffer

This lessons teaches about delay and delayWhen: simple operators that time shift each emission from the source Observable by a specified amount of time.

🚨  Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. To link together multiple Observables and Operators, the method is a bit different. You call `zip` first, then list your Observables, your functions, then pipe your Operators. 

Delay the Emission of Values from an RxJS Observable

you drop some emissions, while at the same time delaying the other emissions in the case emissions
Debounce and debounceTime operators are similar to delayWhen and delay, with the difference that they may drop some emissions. This lesson teaches you how debounce works and where is it useful, for instance when building a type-ahead UI.

🚨  Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. To link together multiple Observables and Operators, the method is a bit different. You call `zip` first, then list your Observables, your functions, then pipe your Operators. 

Drop and Delay Observable Emissions with RxJS debounce

Debounce is known to be a rate-limiting operator, but it's not the only one. This lessons introduces you to throttleTime and throttle, which only drop events (without delaying them) to accomplish rate limiting.

🚨  Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. 

Limit the Rate of Emissions from Observables with throttle in RxJS

Operator distinct() and its variants are an important type of Filtering operator. This lessons shows how they work and in what cases are they useful.

🚨  Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. 

Filter Redundant Observable Emissions with RxJS distinct

Most of the common RxJS operators are about transformation, combination or filtering, but this lesson is about a new category, error handling operators, and its most important operator: catch().

🚨  Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. `catch` is deprecated, use `catchError` instead.

Handle Errors with RxJS catch

Besides catch, the other commonly used error handling operator is retry(). This lessons teaches how retry() and retryWhen() detect errors and how they re-subscribe to the source, besides highlighting its real-world applications.

🚨  Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. To link together multiple Observables and Operators, the method is a bit different. You call `zip` first, then list your Observables, your functions, then pipe your Operators. 

Resubscribe to an Observable on Error with RxJS retry

Operator repeat() is somewhat similar to retry(), but is not for handling operators. In this lesson we learn how repeat works.

🚨  Since we are importing `interval` from RxJS, we don't need to preface our Observables with `Rx.Observable`. You can no longer `.{operator}`, you need to `.pipe({operator})` instead. To link together multiple Observables and Operators, the method is a bit different. You call `zip` first, then list your Observables, your functions, then pipe your Operators. 

Repeat the Execution of an Observable with RxJS repeat

Let's recap the categories of operators covered by the series. This lesson also shows what was not taught, and what comes next as learning material.

RxJS Beyond the Basics: Operators in Depth

André Staltz

Course Content