Skip to main content
CF

Redux Saga

2h 54m 54s
English
Paid

Redux Saga helps you manage async tasks in your Redux app. It uses ES6 generators, which let you pause and resume code. This course shows you how to use Redux Saga to handle async work in a clear and safe way. You learn how it fits into Redux, how to test your sagas, and how to work with effects and channels.

What You Build

You build a small shopping cart app step by step. You let users add and remove items. You show tax and shipping totals. You also sync the cart with a server. Each feature helps you learn how async flows work in Redux Saga.

Core Ideas

You start with the basics of Redux Saga and why people use it. You see how it compares to other Redux tools. You learn how sagas sit between Redux actions and async calls.

Working With Effects

You explore key effects like take, call, put, and race. You see short examples that show when and why to use each one. These examples help you understand how to control async tasks.

Handling Complex Flows

You learn how to wait for actions, trigger tasks, and handle errors. You also learn how to cancel sagas and manage long-running work.

Channels and Testing

You study channels, which help you handle streams of events. You also learn how to test sagas without touching a real server. These tools help you keep your app stable as it grows.

What You Take Away

When you finish the course, you know how to build a full app with Redux Saga. You can handle async tasks, write clean sagas, and test your work with confidence.

About the Author: Pluralsight

Pluralsight thumbnail

Pluralsight is one of the largest enterprise-focused online technology training platforms in the world, founded in 2004 by Aaron Skonnard and acquired by Vista Equity Partners in 2021. The platform has historically been the dominant choice for corporate IT training, with a catalog of over 7,000 courses covering software development, IT operations, security, data, and cloud across virtually every major vendor and open-source platform.

The instructor roster includes Microsoft Regional Directors, AWS / Azure / GCP MVPs, and named experts in essentially every active technology track. Course material is structured for the corporate-training market: each course covers a specific skill at a defined depth, and Pluralsight's role-based learning paths are widely used by enterprises for upskilling engineering teams.

The CourseFlix listing under this source carries 12 Pluralsight courses — a small slice of the broader platform's catalog. Material is paid; Pluralsight itself runs on a monthly / annual subscription on the original platform, with Pluralsight Skills (individual) and Pluralsight Flow (engineering analytics) as the main product lines.

Watch Online 59 lessons

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Course Overview
All Course Lessons (59)
#Lesson TitleDurationAccess
1
Course Overview Demo
02:18
2
Introduction
02:01
3
Why Redux?
02:35
4
Who This Course is For
03:35
5
What This Course Will/won't Be Covering
02:44
6
Course Roadmap
00:56
7
Course Prerequisites
02:26
8
Overview of the Demo Application
04:29
9
What Is Redux Saga?
01:14
10
What Is a Saga?
02:34
11
Why Use Redux Saga?
01:28
12
Redux Thunk vs. Redux Saga
02:55
13
Setting up the Application (Demo)
05:38
14
Installing and Configuring Redux Saga (Demo)
02:00
15
Creating Your First Saga (Demo)
05:08
16
Conclusion
00:56
17
Introduction
00:40
18
What Is Yield?
02:44
19
Advantages and Disadvantages to Yield
03:09
20
Generator Functions
01:57
21
Creating a Generator (Demo)
06:41
22
Yield and Promises
01:09
23
Wrapping Generators
01:40
24
Wrapping Generators with Redux Saga and Co (Demo)
04:33
25
Summary
01:06
26
Module Introduction
00:41
27
Introduction to Effects
01:25
28
Take
03:22
29
Put
02:40
30
Call
02:04
31
Implementing Take, Call, and Put in the Application
05:04
32
Fork
02:35
33
Implementing Fork in the Application
06:37
34
TakeEvery
02:22
35
Cancel and Cancelled
04:08
36
TakeLatest
07:36
37
Select
00:42
38
Spawn
02:49
39
All
03:52
40
Module Summary
00:56
41
Introduction to Channels
00:42
42
What Are Channels?
00:57
43
Action Channels
03:45
44
Generic Channels
03:15
45
Event Channels
04:55
46
Shipping Saga
05:25
47
Tax Rate Saga
02:27
48
Checkout Availability Saga
02:54
49
Checkout Saga
09:21
50
Summary
00:50
51
Module Overview
00:27
52
Testing Redux Saga Applications
01:53
53
Methods for Testing Redux Saga Applications
04:40
54
Implementing Tests for the Application/the User Status Saga Test
06:03
55
Implementing Tests for the Item Quantity Saga
06:11
56
Conclusion
01:13
57
Course Summary
03:07
58
Continuing Development of the Application
01:54
59
Thank You
01:26
Unlock unlimited learning

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

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for this course?
The course requires a basic understanding of Redux, JavaScript, and ES6 generators. Familiarity with async tasks in JavaScript can also be beneficial. The 'Course Prerequisites' lesson provides additional details on what knowledge is expected before starting the course.
What project will I build during the course?
You will build a small shopping cart application. The app allows users to add and remove items, display tax and shipping totals, and sync with a server. Each feature of the application is used to demonstrate how asynchronous flows are managed with Redux Saga.
Who is the target audience for this course?
This course is designed for developers who are already familiar with Redux and want to manage async tasks more effectively within their Redux applications. It is also suitable for those interested in learning about ES6 generators and how they integrate with Redux Saga.
What tools and techniques does the course cover?
The course covers Redux Saga tools and techniques such as effects like take, call, put, and race. You also learn about channels for handling streams of events and testing sagas without a real server. These concepts are essential for building robust async flows in Redux applications.
What topics are not covered in the course?
The course does not cover basic Redux concepts in depth, as it assumes prior knowledge. Instead, it focuses on advanced topics related to Redux Saga such as handling complex flows, working with effects, and testing. The 'What This Course Will/won't Be Covering' lesson outlines the scope in detail.
How does Redux Saga compare to other Redux tools like Redux Thunk?
The course includes a comparison between Redux Saga and Redux Thunk. It discusses the advantages of using Redux Saga for managing complex async flows and how it differs from Redux Thunk in terms of handling side effects. Detailed comparisons are provided in the lesson 'Redux Thunk vs. Redux Saga'.
What is the time commitment required for this course?
The course consists of 59 lessons, with a total runtime that is unspecified. It provides a comprehensive exploration of Redux Saga, and the time commitment will vary depending on your familiarity with the prerequisite topics and the pace at which you complete the exercises and projects.