RxJS Subjects & Operators: What They Do and When to Use Them

I want you to pay attention if you are a fresher in RxJS and have no idea what to do. You might know the rudiments about basic operators, such as map or tap, but in as much as you’d like to dig deeper. Then, ''RxJS Subjects & Operators: What They Do and When to Use Them’’ is the course for you. First, we will introduce RxJS, and at each step, I will show you how to go deeper and deeper into the topic, all while building an Angular application from scratch in this course.

Towards the end of the course, you will be able to understand specific types of Subjects, e.g., behavior subjects, Replay subjects, creation and filtering operators such as interval, of, take, and filter, among others, and the advanced operators such as joining, transformation operators, and error handling in streams. Some custom operators will also be named for some of the logic regarding logging and sorting. Certainly, when learning about each of these operators, you will discover when and how to apply them.

We will also discuss its concepts, such as Imperative vs Reactive programming or how to understand the official documents of RxJS with marble diagrams. This class, "RxJS Subjects & Operators: What They Do and When to Use Them,” will be particularly useful for all learners through the completion of the class. This makes it easy for you to set the speed of this course to a level you are comfortable with. By the end, you should be able to use RxJS optimally for your apps.

RxJS Subjects & Operators: What They Do and When to Use Them Table of Contents:

1. Source Code for the Course Application (00:03)
2. Course Application (01:48)
3. Course Details (04:33)
4. Observables Primer (33:30)
5. Imperative Programming (23:43)
6. RxJS Subjects: Part 1 (15:30)
7. RxJS Subjects: Part 2 (06:51)
8. Reactive Programming: Overview (17:23)
9. Reactive Programming: Our First Coding Exercise (21:38)
10. Interval (13:03)
11. Take and Discussion on Pipe Method vs Async Pipe (12:24)
12. Delay (05:25)
13. Of (04:22)
14. From (03:31)
15. Completing Creation Operators (02:01)
16. Map (21:19)
17. Tap (13:45)
18. How to Create Custom Pipeable Operators (06:12)
19. Create a Custom Pipeable Log Operator (16:26)
20. Create a Custom Pipeable Sort Operator (17:20)
21. Filter (08:38)
22. ConcatAll (11:42)
23. ToArray (11:00)
24. ForkJoin (10:17)
25. CombineLatest (26:59)
26. DebounceTime (27:51)
27. DistinctUntilChanged (10:29)
28. WithLatestFrom (47:23)
29. Merge (27:25)
30. ShareReplay (17:05)
31. Zip (24:23)
32. Defer (09:41)
33. GroupBy (27:45)
34. Demo of Higher-Order Mapping Operators Differences (16:26)
35. ConcatMap (09:22)
36. MergeMap (09:26)
37. SwitchMap (03:50)
38. ExhaustMap (01:59)
39. Share (18:29)
40. Scan (14:57)
41. CatchError (08:02)
42. Finalize (01:25)
43. How to Create Custom Creation Operators (04:00)
44. Create a Custom Loading Operator (19:49)
45. Custom Course Decision Tree (00:42)
46. Course Wrap-Up (02:02)

Who is this course for?

1. Any developer aspiring to code his or her application using RxJS and align it to Reactive Programming principles.

Click on the links below to Download RxJS Subjects & Operators: What They Do and When to Use Them!