Skip to main content
CF

RxJS Beyond the Basics: Operators in Depth

1h 30m 9s
English
Paid

RxJS operators help you work with events, data streams, and async tasks. In this course, you learn what operators are and how to use them in real code. You also see clear examples that show when to pick each operator.

What Operators Do

Operators change, filter, or combine streams. You use them to shape data as it moves. This keeps your code clear and easy to trace.

Why They Matter

Operators help you avoid nested callbacks. They also keep async steps in one flow.

Main Types of Operators

Creation Operators

These start new streams. You use them to create values, events, or timers.

  • of creates a stream from set values.
  • from turns a promise, array, or iterable into a stream.
  • interval emits values on a fixed schedule.

Transformation Operators

These change each value in a stream.

  • map changes each value.
  • mergeMap handles async work and flattens results.
  • switchMap switches to a new stream and drops old ones.

Filtering Operators

These pick which values pass through.

  • filter keeps values that match a rule.
  • take stops after a set number of values.
  • debounceTime waits before it sends a value.

Combination Operators

These join two or more streams.

  • merge joins streams in any order.
  • concat runs streams one after another.
  • combineLatest pairs the newest values from each stream.

How to Practice

Start with small examples. Change one operator at a time and watch the output. This helps you see how each step shapes the data.

Use Visual Tools

You can use tools like marble diagrams. They show how values move over time. This makes stream behavior easier to follow.

What You Will Build

You work through real tasks you see in apps. These tasks include search boxes, live updates, and async calls. Each task shows which operator fits the job.

About the Author: egghead.io

egghead.io thumbnail

egghead.io is a US-based subscription video platform focused on short, focused screencasts on JavaScript ecosystem topics. Founded in 2012 by John Lindquist (a Google Developer Expert) and run by Joel Hooks, egghead pioneered the short-screencast format that most modern developer-education platforms now use — courses are typically broken into 2-5 minute lessons that each cover one specific concept or API.

The instructor roster includes many of the most cited names in the JavaScript ecosystem — Kent C. Dodds (whose Testing JavaScript launched on egghead before EpicWeb.dev), Andrew Del Prete, Hannah Davis, Lukas Ruebbelke, Tomasz Łakomy, Andy Van Slaars, and many others. Course material covers React, Next.js, TypeScript, Node.js, GraphQL, Vue, the testing tracks, RxJS / observables, and a long list of smaller libraries and tools.

The CourseFlix listing under this source carries over 20 egghead courses spanning that range. Material is paid; egghead itself runs on a monthly / annual subscription on the original platform. The bite-sized format suits developers learning incrementally during work hours rather than committing to multi-hour video sessions.

Watch Online 22 lessons

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Understand RxJS Operators
All Course Lessons (22)
#Lesson TitleDurationAccess
1
Understand RxJS Operators Demo
05:39
2
Use Marble Diagrams to Understand RxJS Operators
04:30
3
Use RxJS mapTo and map to Transform Values Emitted by Observables
03:35
4
Inspect the Behavior of Operators with RxJS do
04:26
5
Filter Events Based on a Predicate with RxJS filter
02:07
6
Filter Events with RxJS Operators take, first, and skip
02:52
7
Filter Events with RxJS Operators takeLast and last
03:11
8
Prepend/Append Data with RxJS Operators concat and startWith
06:23
9
Merge Values in Parallel with RxJS Operator merge
03:58
10
Join Values from Multiple Observables with RxJS combineLatest
04:22
11
Control the Output of Values with RxJS Operator withLatestFrom
04:03
12
Combine Values with RxJS Operator zip
05:11
13
Combine Values of One Observable with RxJS scan
05:22
14
Group Consecutive Values Together with RxJS Operator buffer
05:18
15
Delay the Emission of Values from an RxJS Observable
04:23
16
Drop and Delay Observable Emissions with RxJS debounce
05:22
17
Limit the Rate of Emissions from Observables with throttle in RxJS
02:49
18
Filter Redundant Observable Emissions with RxJS distinct
04:35
19
Handle Errors with RxJS catch
05:25
20
Resubscribe to an Observable on Error with RxJS retry
04:02
21
Repeat the Execution of an Observable with RxJS repeat
01:29
22
More operators and conclusion
01:07
Unlock unlimited learning

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

Learn more about subscription

Related courses

Frequently asked questions

What prerequisites are needed for this course?
Before enrolling, students should have a basic understanding of JavaScript, particularly ES6 features like Promises and iterables. Familiarity with asynchronous programming concepts will also be beneficial since the course focuses on working with data streams and async tasks using RxJS.
What types of projects or exercises will I work on in this course?
The course emphasizes hands-on practice with RxJS operators. Students will work on small examples to understand the impact of each operator. Exercises include transforming values with map and mapTo, filtering events using filter and take, and combining streams using merge and combineLatest.
Who is the target audience for this course?
This course is aimed at JavaScript developers who want to deepen their understanding of RxJS and learn how to effectively use operators to manage data streams and asynchronous tasks. It's particularly suited for those looking to write clearer, more maintainable code by avoiding nested callbacks.
How does the depth of this course compare to other RxJS courses?
This course provides an in-depth exploration of RxJS operators, offering 22 lessons that cover a wide range of operator types, including creation, transformation, filtering, and combination operators. By focusing on operators, the course provides a deeper dive into shaping and managing data streams than more general RxJS courses.
Which specific tools or platforms are highlighted in the course?
The course mentions using visual tools to aid understanding of RxJS operators, though it does not specify particular tools by name. The use of marble diagrams is specifically covered to help students visualize how operators transform and manage data streams.
What topics are not covered in this course?
While the course extensively covers RxJS operators and their practical applications, it does not address broader topics such as setting up an RxJS project from scratch or integrating RxJS with frameworks like Angular or React. The focus remains strictly on operators and how they modify and manage streams.
What is the expected time commitment to complete this course?
The course does not specify an exact runtime, but with 22 lessons, students should expect to spend several hours to thoroughly work through the material, including practice exercises. The time commitment will vary based on each student's prior experience and pace of learning.