RxJs 6 In Practice (with FREE E-Book)

4h 28m 50s
English
Paid

Course description

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.

Read more about the course

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).

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!

Who this course is for:
  • Developers trying to make sense of the RxJs library
  • Developers looking to learn Reactive Programming
  • Developers trying to understand how to build Applications in a Reactive Design style

Watch Online

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

Watch Online RxJs 6 In Practice (with FREE E-Book)

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

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

Reactive Angular Course (with RxJs)

Reactive Angular Course (with RxJs)

Sources: udemy
This course is a catalog of commonly used design patterns (and some anti-patterns) that every Angular developer should know. The goal of the course is to teach you how to comfor...
5 hours 33 minutes 49 seconds
RxJS Beyond the Basics: Operators in Depth

RxJS Beyond the Basics: Operators in Depth

Sources: egghead
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 ...
1 hour 30 minutes 9 seconds