CF

RxJs 6 In Practice (with FREE E-Book)

4h 28m 50s
English
Paid
Updated September 2026

RxJs 6 In Practice (with FREE E-Book) is a 41-lesson 4 hours 28 minutes self-paced course by Udemy. RxJs is one of the trickiest parts of the Angular ecosystem to get comfortable with, and jumping straight into existing reactive code rarely works well.

Course facts

Lessons
41
Duration
4 hours 28 minutes
Level
All levels
Language
English
Updated
2026-09-11
Instructor
Udemy
Price
Premium

RxJs is one of the trickiest parts of the Angular ecosystem to get comfortable with, and jumping straight into existing reactive code rarely works well. This course starts from first principles instead, building your understanding of Streams and Observables before moving into applied examples.

How the Course Is Structured

You build your own Observable from scratch, including an HTTP observable with error handling and cancellation, before working through a wide catalog of operators using official marble diagrams alongside practical code: Map and Filter first, then more advanced ones like shareReplay, concat, concatMap, merge, mergeMap, exhaustMap, switch, and switchMap.

Handling Errors and State

You cover several error-handling strategies (catch-and-recover, catch-and-rethrow, retry) and dig into Subjects such as BehaviorSubject and AsyncSubject, using them to build a centralized observable store from the ground up. Additional operators like withLatestFrom, forkJoin, take, first, delay, delayWhen, and startWith round out the toolkit, finishing with how to write your own custom pipeable operator for debugging RxJs code.

A companion e-book covering TypeScript fundamentals accompanies the video lessons.

Who teaches RxJs 6 In Practice (with FREE E-Book)? Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in RxJs 6 In Practice (with FREE E-Book)?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 41 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: RxJs In Practice Course Helicopter View
All Course Lessons (41)
#Lesson TitleDurationAccess
1
RxJs In Practice Course Helicopter View Demo
05:54
2
Environment Setup - Get the Lessons Code Up and Running
07:09
3
Understanding RxJs - What are Streams?
05:54
4
What is RxJs? What Problem Does it Solve?
03:32
5
What is an RxJs Observable? A Simple Explanation
07:34
6
3 Core RxJs Concepts - Errors, Completion and Subscriptions
06:01
7
Learn How Observables Work Under the Hood, Build Your Own HTTP Observable
12:08
8
What are RxJs Operators? Learn the Map Operator
07:25
9
Building Components with RxJs - Imperative Design
05:09
10
Building Components with RxJs - Reactive Design
07:29
11
Sharing HTTP Responses with the shareReplay Operator
06:09
12
Observable Concatenation - In-Depth Explanation
07:49
13
Form Draft Pre-Save Example and the RxJs Filter Operator
08:24
14
The RxJs concatMap Operator - In-Depth Explanation and Practical Example
07:48
15
Understanding the merge Observable combination Strategy
03:38
16
The RxJs mergeMap Operator - In-Depth Explanation
04:13
17
The RxJs exhaustMap Operator - In-Depth Explanation
07:55
18
Unsubscription In Detail - Implementing a Cancellable HTTP Observable
07:26
19
Setting Up the Course Component
04:32
20
Building a Search Typeahead - debounceTime and distinctUntilChanged Operators
07:28
21
Finishing the Search Typeahead - The switchMap Operator
11:27
22
RxJs Error Handling - The Catch and Replace Error Handling Strategy
07:40
23
The Catch and Rethrow RxJs Error Handling Strategy and the finalize Operator
09:19
24
The Retry RxJs Error Handling Strategy.screenflow
06:09
25
The startWith RxJs Operator - Simplifying the Course Component
02:51
26
RxJs Throttling vs Debouncing - Understand the Differences
07:16
27
Implementing a Custom RxJs Operator - the Debug Operator
06:30
28
The RxJs Debug Operator - Implementation Conclusion
07:32
29
The RxJs forkJoin Operator - In-Depth Explanation and Practical Example
04:14
30
Subjects and Stores - New Section Kickoff
02:22
31
What are RxJs Subjects? A Simple Explanation
07:21
32
BehaviorSubject In Detail - When to Use it and Why?
07:18
33
AsyncSubject and ReplaySubject - Learn the Differences
04:04
34
Store Service Design - What Subject to Use?
07:56
35
The Store Pattern - Loading Initial Data, Selector Methods, Consuming Data
06:47
36
BehaviorSubject Store - Example of a Data Modification Operation
11:21
37
Refactoring the Course Component for Using the Store
03:51
38
Forcing the Completion of Long Running Observables - First and Take Operators
06:36
39
The withLatestFrom RxJs Operator - Detailed Explanation
07:34
40
Other Courses
02:18
41
RxJs In Practice Course Conclusion and Key Takeaways
04:47
Unlock unlimited learning

Get instant access to all 40 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to RxJs 6 In Practice (with FREE E-Book)?

More courses by Udemy

Frequently asked questions

What prerequisites are needed for this course?
Prospective students should have a basic understanding of JavaScript and familiarity with the Angular framework. While not mandatory, some experience with TypeScript will be beneficial since the course includes the Typescript Jumpstart E-Book to help bridge any gaps in understanding.
What projects will I build during the course?
Throughout the course, you will build several components using RxJs. These include creating an HTTP observable for managing backend requests, building a search typeahead feature with debounceTime and distinctUntilChanged, and implementing a store service with BehaviorSubject for data modification operations. These projects are designed to provide hands-on experience with RxJs in real-world scenarios.
Who is the target audience for this course?
This course is tailored for developers working within the Angular ecosystem who encounter challenges with RxJs and Reactive Programming. It is suitable for both beginners who are just starting with RxJs and more experienced developers looking to solidify their understanding of reactive design concepts.
How does this course compare in depth and scope to other RxJs courses?
This course offers a practical guide to RxJs with a focus on the most commonly used operators and real-world examples. While it doesn't cover every possible operator, it provides a comprehensive understanding of how to implement reactive design concepts effectively, making it a balanced choice between depth and actionable knowledge.
What specific RxJs operators will I learn in this course?
You will learn about a variety of operators such as map, concatMap, mergeMap, exhaustMap, switchMap, shareReplay, debounceTime, distinctUntilChanged, catch, retry, startWith, and more. The course also dives into creating custom operators like the Debug Operator, providing a robust understanding of operator functionalities.
What topics are not covered in this course?
While the course provides a broad overview of RxJs and its applications in reactive programming, it does not cover every RxJs operator in existence. The focus is on the most commonly used operators and practical examples rather than an exhaustive list of operators.
How much time should I expect to commit to this course?
The course consists of 41 lessons, each designed to be concise and focused. While the total runtime is unspecified, you can expect to spend additional time on hands-on coding exercises and reviewing the provided e-book material. Allocating several hours a week should allow you to progress steadily through the course content.