RxJs In Practice (with FREE E-Book)

Learn numerous RxJs Operators, learn all RxJs and Reactive Programming core concepts via Practical Examples

4.63 (5297 reviews)
Udemy
platform
English
language
Web Development
category
22,163
students
4.5 hours
content
Mar 2024
last update
$84.99
regular price

What you will learn

Code in Github repository with downloadable ZIP files per section

Learn the RxJs library via Practical Examples

Become familiar with an extended subset of RxJs Operators

Understand in detail the core notions of Reactive Programming

Learn how to design and build Applications in Reactive style

Description

This Course in a Nutshell  (note: this course includes the Typescript Jumpstart E-Book)

This course is a complete practical guide for the RxJs library (Reactive Extensions for Javascript).

If you are a developer just getting started with the Angular ecosystem, or even if you already have some experience with it, the part that you will find the hardest to wrap your head around is RxJs.

And this is because RxJs and Reactive Programming have a steep learning curve that makes it hard to just jump in into an existing program and learn these concepts by example. With RxJs that approach will simply not work. Instead, we need to start at the beginning and learn some baseline reactive design concepts first.

In this course, we will start by presenting a couple of baseline concepts, and then we will provide you with an extended catalog of RxJs operators that will in practice cover the vast majority of your daily needs.

Also, the goal here is not to cover every single operator, but instead to choose an extended subset that contains the most commonly used operators, and provide practical examples for each.

Another goal of the course is to show how RxJs is meant to be used for building programs using Reactive Design as opposed to an imperative programming style.

Course Overview

We will start by quickly introducing RxJs: we will cover the notions of Stream and Observable, and we will answer common questions such as: what is RxJs, when to use it and why, what problem does it solve?

We will then write our own Observable from first principles: we will implement our own HTTP observable that will allow us to handle backend HTTP requests while supporting error handling and cancellation.

After this quick introduction, we will dive straight into the practical examples covering a large variety of operators. We will cover the operators by explaining their behavior using the official RxJs marble diagrams, and then we will complement that with a practical example.

We will first start with the Map and Filter operators, and quickly move to more complex operators such as shareReplay, concat, concatMap, and other commonly used observable combination strategies such as: merge and mergeMap, exhaustMap, switch and switchMap. We will provide practical examples for these operators that include backend save operations and search typeaheads.

We will then cover several RxJs error handling strategies, like catch and recover, catch and rethrow or retry.

We will also cover the notion of subject and give examples of several commonly used subjects, such as BehaviorSubject or AsyncSubject. We will then use a subject to implement a very commonly used reactive pattern: we will implement a centralized observable store from first principles.

We will also cover many other commonly used operators, that include but are not restricted to: withLatestFrom, forkJoin, take, first, delay, delayWhen, startWith, etc.

At the end of the course, we will implement our own custom pipeable operator from first principles: we will implement a debugging operator that is going to be very helpful for debugging our RxJS programs.

What Will You Learn In this Course?

By taking this course you will learn how to use the RxJs library in practice for building applications in reactive style. You will understand well the core notions that are the basis of reactive programming, such as Streams and Observables.

You will also be familiar with an extended subset of operators that in practice will provide all that you will need for building applications in reactive style using RxJs.

Have a look at the course free lessons below, and please enjoy the course!

Content

Introduction to RxJs

RxJs In Practice Course Helicopter View
Recommended Software Versions
The Typescript Jumpstart Ebook
Environment Setup - Get the Lessons Code Up and Running
Understanding RxJs - What are Streams?
What is RxJs? What Problem Does it Solve?
What is an RxJs Observable? A Simple Explanation
3 Core RxJs Concepts - Errors, Completion and Subscriptions
Learn How Observables Work Under the Hood, Build Your Own HTTP Observable

Essential RxJs Operators + Reactive Design

What are RxJs Operators? Learn the Map Operator
Building Components with RxJs - Imperative Design
Building Components with RxJs - Reactive Design
Sharing HTTP Responses with the shareReplay Operator
RxJs Higher-Order Mapping Operators PDF
Observable Concatenation - In-Depth Explanation
Form Draft Pre-Save Example and the RxJs Filter Operator
The RxJs concatMap Operator - In-Depth Explanation and Practical Example
Understanding the merge Observable combination Strategy
The RxJs mergeMap Operator - In-Depth Explanation
The RxJs exhaustMap Operator - In-Depth Explanation
Unsubscription In Detail - Implementing a Cancellable HTTP Observable
Setting Up the Course Component
Building a Search Typeahead - debounceTime and distinctUntilChanged Operators
Finishing the Search Typeahead - The switchMap Operator

RxJs Error Handling

RxJs Error Handling - PDF Guide
RxJs Error Handling - The Catch and Replace Error Handling Strategy
The Catch and Rethrow RxJs Error Handling Strategy and the finalize Operator
The Retry RxJs Error Handling Strategy.screenflow
The startWith RxJs Operator - Simplifying the Course Component
RxJs Throttling vs Debouncing - Understand the Differences

Building a RxJs Custom Operator

Implementing a Custom RxJs Operator - the Debug Operator
The RxJs Debug Operator - Implementation Conclusion
The RxJs forkJoin Operator - In-Depth Explanation and Practical Example

RxJs Subjects and the Store Pattern

Subjects and Stores - New Section Kickoff
What are RxJs Subjects? A Simple Explanation
BehaviorSubject In Detail - When to Use it and Why?
AsyncSubject and ReplaySubject - Learn the Differences
Store Service Design - What Subject to Use?
The Store Pattern - Loading Initial Data, Selector Methods, Consuming Data
BehaviorSubject Store - Example of a Data Modification Operation
Refactoring the Course Component for Using the Store
Forcing the Completion of Long Running Observables - First and Take Operators
The withLatestFrom RxJs Operator - Detailed Explanation

Conclusion

Other Courses
Bonus Lecture
RxJs In Practice Course Conclusion and Key Takeaways

Screenshots

RxJs In Practice (with FREE E-Book) - Screenshot_01RxJs In Practice (with FREE E-Book) - Screenshot_02RxJs In Practice (with FREE E-Book) - Screenshot_03RxJs In Practice (with FREE E-Book) - Screenshot_04

Reviews

Jarrod
November 13, 2023
The course provided a well-rounded introduction to RxJS with easy-to-follow examples. I would recommend the course as a good starting point for anyone looking to learn RxJS.
Stephen
November 7, 2023
Good introduction to RxJs which covered: - Rationale for using - Basic concepts - Operators - Behaviours Would require someone with more experience with RxJs to assess how comprehensive and up to date. Pacing was good with live demonstrations throughout. Would benefit from having: - quizzes to check that the viewer is understanding the concepts - exercises to test that the viewer can apply the concepts
Daniel
October 17, 2023
Despite being dated, still a good course to gain foundational knowledge and understanding of RxJS. Was worth the time and effort.
Aliaksandr
October 14, 2023
Difficult to follow what version of git project should be opened. Moreover, in some cases, the project is broken, e.g. "2-store" branch is broken likely due to incremental migration to latest Angular versions. "Property 'save' does not exist on type 'CourseDialogComponent'" The temp fix is easy, however, if you know Angular which is not requirement for RxJS course. The videos in the courses were recorded when Angular 6 existed. Some RxJS operators are officially deprecated, such as retryWhen, static Observable.create() and so on. It seems the course is partially obsolete.
Darren
October 12, 2023
Some of the codes are outdated. Just updating the outdated code will help special the beginners which is not familiar with the basic concept of RxJs.
Petyo
October 1, 2023
It was not good match for me as the course was suggesting that is for all experience levels, but it is more beginner to intermediate so that is misleading and I wasted my time expecting to see something more advanced. The material is well presented though.
Vladyslav
September 22, 2023
pretty good course but a lot of questions does not answer and material in some lecture need to be rewrite
Amit
September 18, 2023
1) Forget coding along, the instructor flies through the most important concepts and then slowly drags out the most obvious concepts and I just grew more irritated as the course went on. 2) The course seems to be edited so that the instructor seems to never stop talking and in doing that, key concepts are jumbled. To really learn and maintain any of the knowledge, you have to play and pause a lot and will likely end up watching the whole course again to catch what you missed. 3) As opposed to having visual indicators in the video, which most other courses have nowadays, the instructor always circles his mouse to indicate where to look before quickly moving on, which is as annoying as the loud musical intro in EVERY section.
Francis
September 2, 2023
This course is sold as updated but it is actually very old, they use version 6 of rxjs and some of the methods they explain are already deprecated, it is false advertising
Bhaskar
August 21, 2023
I have taken other couses provided by Angular University. The instructor have very good knowledge and course structure is also good.
Abinaya
July 18, 2023
It helped me to understand how to use rxjs in a better way and how to communicate with backend and modify response. Thanks a lot.
Reiner
April 25, 2023
Good course. The actual (7.8) RxJS library has some other functions and some are depewcated. But with the only docu it's agood practice to find it out.
Vladislav
April 13, 2023
The course is very good for beginner with no knowledge about the RxJs library. It is very useful and very well explained with detailed examples. A couple of remarks: some of the operators are or will be deprecated, but they're still taught in this course and perhaps it needs to be updated. Moreover, it would have been nice to see some more complex Observable chains where we would chain more than one or two operators and also some real life complex use cases of Observable chains. Overall, a very recommended RxJs course for beginners.
Miguel
April 11, 2023
Great course, good explanation with good examples to understand the behavior of the observables using RxJS in a functional way.
Noel
April 3, 2023
Great Explanation and it's good that you are using hands on teaching approach which helps me understand the concepts very well.

Charts

Price

RxJs In Practice (with FREE E-Book) - Price chart

Rating

RxJs In Practice (with FREE E-Book) - Ratings chart

Enrollment distribution

RxJs In Practice (with FREE E-Book) - Distribution chart

Related Topics

1726420
udemy ID
6/1/2018
course created date
5/7/2019
course indexed date
Bot
course submited by