Learn about RxJS to write efficient asynchronous code. Explore subjects, operators, and observables. Gain insights into creating projects like a reactive local database and handling DOM events.

mocha.tar.gz

rxjsCodeWidget

rxjsSPA

mocha

RxJS (Reactive Extensions for JavaScript) is a very powerful library for web development which allows you to easily write asynchronous or call-back code.

In this course, you will explore the latest version of RxJS in detail, focusing on how to apply the reactive paradigm to solve your day-to-day tasks. You will learn all the major components of this library including: subjects, operators, and how to test observables.

In the last section of this course, you will get hands-on with this library to create your own project. Throughout this project, you’ll learn about building a centralized loading indicator, how to handle DOM events, how to build a reactive local database, and more.

By the end of this course, you will have a great new skill to add to your resume, and a cool new project for your portfolio.

Building Reactive Applications with RxJS

In the previous lesson, we learned how each subscriber invokes the subscribe function of the Observable, which means that it owns an independent execution of that Observable. This is known as a **unicast** value delivery.

On the other hand, we may need a different approach where the same execution context for an Observable will be shared between every subscriber. This is known as a **multicast** value delivery. 

`Subjects` are a special type of Observable in RxJS that enable **multicasting**.

# Enter `Subjects`

A Subject is a special construct in RxJS, which can act as an Observable and an Observer at the same time.
1. You can subscribe to a Subject, the same as you would do with an Observable.
2. You can push values to a Subject, by invoking the method `next`, the same as you would do within the `subscribe` function in an Observable. 

Every interested subscriber can listen to the values produced by the Subject by simply subscribing to it, without worrying whether the Observable context is new or shared for each Observer. 

Every data producer can publish values to the Subject over time, and those values would be multicasted to each subscribed Observer. 

How? 

The Subject maintains a list of all active subscribers, and the incoming values are multicasted to each subscriber in the same execution context. 

You may be wondering why do I need Subjects when I can easily work with Observables? 

Imagine you have multiple services in your application that produce data over time. It's best for those services to put the data in the `Subject`, and that data would be multicasted to every subscriber, leading to much cleaner work and less code. The illustration below shows this workflow.

Learn how RxJS offers Subjects to deal with multiple producers pushing values over time to multiple consumers through the same pipeline.

The Need for Reactive Programming

RxJS Subjects

RxJS Operators

Testing Observables

Real-World Projects in RxJS

Conclusion

Overview of Subjects in RxJS

Enter `Subjects`

Overview of Subjects in RxJS

Enter Subjects

Enter `Subjects`