React – The Complete Guide 2023 (incl. React Router & Redux)

We welcome to “React – The Complete Guide2023,” a thorough and enjoyable video course aimed at teaching you React, React Router, and Redux. This course is your go-to resource for understanding the ins and outs of these potent JavaScript libraries, including more than 30 hours of top-notch video content.

In this course, you’ll embark on an intriguing trip into the world of React, a potent JavaScript toolkit used to design cutting-edge, interactive user experiences. Whether you are a novice or an experienced developer, this course was designed to accommodate students of all ability levels.

You will be led through simple tutorials and real-world examples with a focus on practical learning to ensure that you develop a strong foundation in React – The Complete Guide. In order to improve your understanding, our experienced teachers will clearly and concisely explain complex ideas using examples from real-world situations.

React Router is a routing tool for React that enables you to build dynamic, multi-page apps. Throughout the course, you’ll learn how to use it efficiently. You’ll also learn about Redux, a predictable state container that makes application state management easier.

What you’ll learn: React – The Complete Guide

  • Build powerful, fast, user-friendly, and reactive web apps
  • Leverage the power of JavaScript with React to provide amazing user experiences
  • Join a community of over 700,000 students in this course, and over 2,500,000 students taught across all courses
  • Develop multiple demo projects and explore realistic examples
  • Follow along with the course material either locally or in a cloud development environment
  • Learn the ins and outs of React Hooks and React Components
  • Efficiently manage complex state using React’s Context API and React Redux
  • Build standalone React apps and applications connected to a backend via HTTP
  • Gain insights into routing and route-related data fetching with React Router
  • Implement user authentication in React apps
  • Build full-stack React apps with NextJS
  • Get started with React Unit Testing

Course content of React – The Complete Guide

1. Getting Started

  • Welcome To The React – The Complete Guide Course!
  • What is React.js?
  • ReactJS vs “Vanilla JavaScript”: Why-Use-React?
  • Editing Our First React App
  • About This Course & Course Outline
  • The Two Ways(Paths) Of Taking This Course
  • Getting The Most Out Of This Course
  • Join our Online Learning Community
  • Creating React Projects: Browser-based vs Local Development
  • Creating React Projects Locally
  • using CodeSandbox For React Development (No Local Setup
  • Required!)
  • Module Resources

2. JavaScript Refresher

  • Module Introduction v
  • Starting Project
  • Adding JavaScript To A Page & How React Projects Differ
  • React Projects Use a Build Process
  • “import” & “export”
  • Revisiting Variables & Values
  • Revisiting Operators
  • Revisiting Functions & Parameters
  • Exercise: Working with Functions
  • Arrow Functions
  • More on the Arrow Function Syntax
  • Revisiting Objects & Classes
  • Arrays & Array Methods like map()
  • Exercise: Array Methods
  • Destructuring
  • Destructuring in Function Parameter Lists
  • The Spread Operator
  • Revisiting Control Structures
  • Manipulating the DOM – Not With React!
  • Using Functions as Values
  • Defining Functions Inside Of Functions
  • Reference vs Primitive Values
  • Next-Gen JavaScript – Summary v
  • JS Array Functions v
  • Module Resources

3. React Basics & Working With Components

  • Module Introduction
  • What Are Components? And Why Is React All About Them?
  • React Code Is Written In A “Declarative Way”!
  • Creating a new React Project
  • The Starting Project
  • Analyzing a Standard React Project
  • Introducing JSX
  • How React Works
  • Exercise: Working with JSX Code
  • Building a First Custom Component
  • Exercise: Building a First Component
  • Writing More Complex JSX Code
  • Adding Basic CSS Styling
  • Outputting Dynamic Data & Working with Expressions in JSX
  • Passing Data via “props”
  • Exercise: Passing Data via “props”
  • Alternative Ways of Passing & Receiving / Handling “props”
  • Adding “normal” JavaScript Logic to Components
  • Splitting Components Into Multiple Components
  • Time to Practice: React & Component Basics v
  • The Concept of “Composition” (“children props”)
  • Exercise: Component Composition
  • A First Summary
  • A Closer Look At JSX
  • Organizing Component Files
  • An Alternative Function Syntax
  • Learning Check: React Basics, Components, Props & JSX
  • Module Resources

4. Time to Practice: Component Basics

  • Module Introduction
  • The Starting Project & Your Tasks
  • Exercise Hints
  • Outputting Key Concepts Data
  • Identifying Possible Components
  • Creating & Using a Custom Component
  • Outsourcing Concept Items Into a Reusable Component
  • Module Resources

5. React State & Working with Events

  • Module Introduction
  • Listening to Events & Working with Event Handlers
  • Exercise: Listening to Events
  • How Component Functions Are Executed
  • Working with “State”
  • Exercise: Working with “State”
  • A Closer Look at the “useState” Hook
  • State can be updated in many ways!
  • Adding Form Inputs
  • Listening to User Input
  • Working with Multiple States
  • Using One State Instead (And What’s Better)
  • Updating State That Depends On The Previous State
  • Exercise: Using State with Form Inputs
  • Exercise: Updating State Based On Older State
  • Alternative: Creating A Shared Handler Function
  • Handling Form Submission
  • Adding Two-Way Binding
  • Child-to-Parent Component Communication (Bottom-up)
  • Lifting The State Up
  • Time to Practice: Working with Events & State v
  • Derived / Computed State
  • Controlled vs Uncontrolled Components & Stateless vs Stateful
  • Components
  • Learning Check: Working with Events & State
  • Module Resources

6. Rendering Lists & Conditional Content

  • Module Introduction React – The Complete Guide
  • Rendering Lists of Data
  • Exercise: Rendering Lists of Data
  • Using Stateful Lists
  • Understanding “Keys”
  • Time to Practice: Working with Lists v
  • Outputting Conditional Content
  • Exercise: Outputting Conditional Content
  • Adding Conditional Return Statements
  • Time to Practice: Conditional Content v
  • Demo App: Adding a Chart
  • Adding Dynamic Styles
  • Wrap Up & Next Steps
  • Fixing a Small Bug
  • Learning Check: Outputting Lists & Conditional Content
  • Module Resources

7. Styling React Components

  • Module Introduction
  • Setting Dynamic Inline Styles
  • Exercise: Dynamic Styles
  • Setting CSS Classes Dynamically
  • Exercise: Dynamic CSS Classes
  • Introducing Styled Components
  • Styled Components & Dynamic Props
  • Styled Components & Media Queries
  • Using CSS Modules
  • Dynamic Styles with CSS Modules
  • Module Resources

8. Debugging React Apps

  • Module Introduction
  • Understanding React Error Messages
  • Exercise: Fix Errors
  • Analyzing Code Flow & Warnings
  • Working with Breakpoints
  • Using the React DevTools
  • Module Resources

9. Time to Practice: A Complete Practice Project

  • Module Introduction
  • The First Practice Project & Your Tasks
  • Exercise Hints
  • Splitting the App Into Components
  • Handling Events
  • Managing State
  • Lifting the State Up
  • Outputting Results Conditionally
  • Adding CSS Modules
  • Fixing a Small Bug
  • Introducing the Second Project
  • Exercise Hints
  • Adding a “User” Component
  • Adding a re-usable “Card” Component
  • Adding a re-usable “Button” Component
  • Managing the User Input State
  • Adding Validation & Resetting Logic
  • Adding a Users List Component
  • Managing a List Of Users via State
  • Adding The “ErrorModal” Component
  • Managing the Error State
  • Module Resources
  1. Diving Deeper: Working with Fragments, Portals & “Refs”

Module Introduction
JSX Limitations & Workarounds
Creating a Wrapper Component
React Fragments
Introducing React Portals
Working with Portals
Working with “ref”s
Controlled vs Uncontrolled Components
Module Resources

11. Advanced: Handling Side Effects, Using Reducers & Using
the Context API

  • Module Introduction
  • What are “Side Effects” & Introducing useEffect
  • Using the useEffect() Hook
  • useEffect & Dependencies
  • What to add & Not to add as Dependencies
  • Using the useEffect Cleanup Function
  • useEffect Summary
  • Introducing useReducer & Reducers In General
  • Using the useReducer() Hook
  • useReducer & useEffect
  • Adding Nested Properties As Dependencies To useEffect
  • useReducer vs useState for State Management
  • Introducing React Context (Context API)
  • Using the React Context API
  • Tapping Into Context with the useContext Hook
  • Making Context Dynamic
  • Building & Using a Custom Context Provider Component
  • React Context Limitations
  • Learning the “Rules of Hooks”
  • Refactoring an Input Component
  • Diving into “Forward Refs”
  • Module Resources

12. Practice Project: Building a Food Order App

  • Module Introduction
  • Starting Setup
  • Adding a “Header” Component
  • Adding the “Cart” Button Component
  • Adding a “Meals” Component
  • Adding Individual Meal Items & Displaying Them
  • Adding a Form
  • Fixing Form Input IDs
  • Working on the “Shopping Cart” Component
  • Adding a Modal via a React Portal
  • Managing Cart & Modal State
  • Adding a Cart Context
  • Using the Context
  • Adding a Cart Reducer
  • Working with Refs & Forward Refs
  • Outputting Cart Items
  • Working on a More Complex Reducer Logic
  • Making Items Removable
  • Using the useEffect Hook
  • D Module Resources

13. A Look Behind The Scenes Of React & Optimization

  • Module Introduction
  • How React Really Works
  • Component Updates In Action
  • A Closer Look At Child Component Re-Evaluation
  • Preventing Unnecessary Re-Evaluations with React.memo()
  • Preventing Function Re-Creation with useCallback()
  • useCallback() and its Dependencies
  • A First Summary
  • A Closer Look At State & Components
  • Understanding State Scheduling & Batching
  • Optimizing with useMemo()
  • Module Resources

14. An Alternative Way Of Building Components: Class-based

  • Module Introduction
  • What & Why
  • Adding a First Class-based Component
  • Working with State & Events
  • The Component Lifecycle (Class-based Components Only!)
  • Lifecycle Methods In Action
  • Class-based Components & Context
  • Class-based vs Functional Components: A Summary
  • Introducing Error Boundaries
  • Module Resources

15. Sending Http Requests (e.g. Connecting to a Database)

  • Module Introduction
  • How To (Not) Connect To A Database
  • Using the Star Wars API
  • Our Starting App & Backend
  • Sending a GET Request
  • Using async / await
  • Handling Loading & Data States
  • Handling Http Errors
  • Using useEffect() For Requests
  • Preparing The Project For The Next Steps
  • Sending a POST Request
  • Wrap Up
  • Module Resources

16. Building Custom React Hooks

  • Module Introduction
  • What are “Custom Hooks”?
  • Creating a Custom React Hook Function
  • Using Custom Hooks
  • Configuring Custom Hooks
  • Onwards To A More Realistic Example
  • Building a Custom Http Hook
  • Using the Custom Http Hook
  • Adjusting the Custom Hook Logic
  • Using The Custom Hook In More Components
  • Module Resources

17. Working with Forms & User Input

  • Module Introduction
  • Our Starting Setup
  • What’s So Complex About Forms?
  • Dealing With Form Submission & Getting User Input Values
  • Adding Basic Validation
  • Providing Validation Feedback
  • Handling the “was touched” State
  • React To Lost Focus
  • Refactoring & Deriving States
  • Managing The Overall Form Validity
  • Time to Practice: Forms v
  • Adding A Custom Input Hook
  • Re-lJsing The Custom Hook
  • A Challenge For You!
  • Applying Our Hook & Knowledge To A New Form
  • Summary
  • Bonus: Using useReducer()
  • D Module Resources

18. Practice Project: Adding Http & Forms To The Food Order App

  • Module Introduction
  • Moving “Meals” Data To The Backend
  • Fetching Meals via Http
  • Handling the Loading State
  • Handling Errors
  • Adding A Checkout Form
  • Reading Form Values
  • Adding Form Validation
  • Submitting & Sending Catt Data
  • Adding Better User Feedback
  • Summary
  • Module Resources

19. Diving into Redux (An Alternative To The Context API)

  • Module Introduction
  • Another Look At State In React Apps
  • Redux vs React Context
  • How Redux Works
  • MUST READ: Redux createStore() is (not) deprecated
  • Exploring The Core Redux Concepts
  • More Redux Basics
  • Preparing a new Project
  • Creating a Redux Store for React
  • Providing the Store
  • Using Redux Data in React Components
  • Dispatching Actions From Inside Components
  • Redux with Class-based Components
  • Attaching Payloads to Actions
  • Working with Multiple State Properties
  • How To Work With Redux State Correctly
  • Redux Challenges & Introducing Redux Toolkit
  • Adding State Slices
  • Connecting Redux Toolkit State
  • Migrating Everything To Redux Toolkit
  • Working with Multiple Slices
  • Reading & Dispatching From A New Slice
  • Splitting Our Code
  • Summary
  • Module Resources

20. Advanced Redux

  • Module Introduction
  • Redux & Side Effects (and Asynchronous Code)
  • Refresher / Practice: Part 1/2
  • Refresher / Practice: Pan 2/2
  • Redux & Async Code
  • Frontend Code vs Backend Code
  • Where To Put Our Logic
  • Using useEffect with Redux
  • A Problem with useEffect()
  • Handling Http States & Feedback with Redux
  • Using an Action Creator Thunk
  • Getting Started with Fetching Data
  • Finalizing the Fetching Logic
  • Exploring the Redux DevTools
  • Summary
  • Module Resources

21. Building a Multi-Page SPA with React Router

  • Module Introduction
  • Routing: Multiple Pages in Single-Page Applications
  • Project Setup & Installing React Router
  • Defining Routes
  • Adding a Second Route
  • Exploring an Alternative Way of Defining Routes
  • Navigating between Pages with Links
  • Layouts & Nested Routes
  • Showing Error Pages with errorElement
  • Working with Navigation Links (NavLink)
  • Navigating Programmatically
  • Defining & Using Dynamic Routes
  • Adding Links for Dynamic Routes
  • Understanding Relative & Absolute Paths
  • Working with Index Routes
  • Onwards to a new Project Setup
  • Time to Practice: Problem
  • Time to Practice: Solution
  • Data Fetching with a loader()
  • Using Data From A Loader In The Route Component
  • More loader() Data Usage
  • Where Should loader() Code Be Stored?
  • When Are loader() Functions Executed?
  • Reflecting The Current Navigation State in the IJI
  • Returning Responses in loader()s
  • Which Kind Of Code Goes Into loader()s?
  • Error Handling with Custom Errors
  • Extracting Error Data & Throwing Responses
  • The json() Utility Function
  • Dynamic Routes & loader()s
  • The useRouteLoaderData() Hook & Accessing Data From Other
  • Routes
  • Planning Data Submission
  • Working with action() Functions
  • Submitting Data Programmatically
  • Updating the Ul State Based on the Submission Status
  • Validating User Input & Outputting Validation Errors
  • Reusing Actions via Request Methods
  • Behind-the-Scenes Work with useFetcher()
  • Deferring Data Fetching with defer()
  • Controlling Which Data Should Be Deferred
  • Module Summary
  • Upgrading from React Router v5
  • Module Resources
  • Old Lectures

22. Adding Authentication To React Apps

  • Module Introduction
  • How Authentication Works
  • Project Setup & Route Setup
  • Working with Query Parameters
  • Implementing the Auth Action
  • Validating User Input & Outputting Validation Errors
  • Adding User Login
  • Attaching Auth Tokens to Outgoing Requests
  • Adding User Logout
  • Updating the IJI Based on Auth Status
  • Important: loader()s must return null or any other value
  • Adding Route Protection
  • Adding Automatic Logout
  • Managing the Token Expiration
  • Module Resources

23. Deploying React Apps

  • Module Introduction
  • Deployment Steps
  • Understanding Lazy Loading
  • Adding Lazy Loading
  • Building the Code For Production
  • Deployment Example
  • Server-side Routing & Required Configuration
  • Module Resources

24. A (Pretty Deep Dive) Introduction to Next.js

  • Module Introduction
  • What is NextJS?
  • Key Feature 1: Built-in Server-side Rendering (Improved SEO!)
  • Key Feature 2: Simplified Routing with File-based Routing
  • Key Feature 3: Build Fullstack Apps
  • Creating a New Next.js Project &App
  • Analyzing the Created Project
  • Adding First Pages
  • Adding Nested Paths & Pages (Nested Routes)
  • Creating Dynamic Pages (with Parameters)
  • Extracting Dynamic Parameter Values
  • Linking Between Pages
  • Onwards to a bigger Project!
  • Preparing the Project Pages
  • Outputting a List of Meetups
  • Adding the New Meetup Form
  • The “_app.js” File & Layout Wrapper
  • Using Programmatic (Imperative) Navigation
  • Adding Custom Components & CSS Modules
  • How Pre-rendering Works & Which Problem We Face
  • Data Fetching for Static Pages
  • More on Static Site Generation (SSG)
  • Exploring Server-side Rendering (SSR) with
  • “getServerSideProps”
  • Working with Params for SSG Data Fetching
  • Preparing Paths with “getStaticPaths” & Working With Fallback
  • Pages
  • Introducing API Routes
  • Working with MongoDB
  • Sending Http Requests To Our API Routes
  • Getting Data From The Database
  • Getting Meetup Details Data & Preparing Pages
  • Adding “head” Metadata
  • Deploying Next.js Projects
  • Using Fallback Pages & Re-deploying
  • Summary
  • D Module Resources

25. Animating React Apps

  • Module Introduction
  • Preparing the Demo Project
  • Using CSS Transitions v
  • Using CSS Animations v
  • CSS Transition &Animations Limitations
  • Using ReactTransitionGroup v
  • Using the Transition Component v
  • Wrapping the Transition Component
  • Animation Timings v
  • Transition Events v
  • The CSSTransition Component v
  • Customizing CSS Classnames v
  • Animating Lists v
  • Alternative Animation Packages
  • Wrap Up v
  • Module Resources

26. Replacing Redux with React Hooks

  • Module Introduction
  • React 18 & This Section
  • Starting Project & Why You Would Replace Redux
  • Alternative: Using the Context API
  • Toggling Favorites with the Context API
  • Context API Summary (and why NOT to use it instead of Redux
  • Getting Started with a Custom Hook as a Store
  • Finishing the Store Hook
  • Creating a Concrete Store
  • Using the Custom Store
  • Custom Hook Store Summary
  • Optimizing the Custom Hook Store
  • Bonus: Managing Multiple State Slices with the Custom Store
  • Hook
  • Wrap Up
  • Module Resources

27. Testing React Apps (Unit Tests)

  • Module Introduction
  • What & Why?
  • IJnderstanding Different Kinds Of Tests
  • What To Test & How To Test
  • Understanding the Technical Setup & Involved Tools
  • Running a First Test
  • Writing Our First Test
  • Grouping Tests Together With Test Suites
  • Testing User Interaction & State
  • Testing Connected Components
  • Testing Asynchronous Code
  • Working With Mocks
  • Summary & Further Resources
  • Module Resources

28. React + TypeScript

  • Module Introduction
  • What & Why?
  • Installing & Using TypeScript
  • Exploring the Base Types
  • Working with Array & Object Types
  • Understanding Type Inference
  • Using Union Types
  • Understanding Type Aliases
  • Functions & Function Types
  • Diving Into Generics
  • A Closer Look At Generics
  • Creating a React + TypeScript Project
  • Working with Components & TypeScript
  • Working with Props & TypeScript
  • Adding a Data Model
  • Time to Practice: Exercise Time!
  • Form Submissions In TypeScript Projects
  • Working with refs & useRef
  • Working with “Function Props”
  • Managing State & TypeScript
  • Adding Styling
  • Time to Practice: Removing a Todo
  • The Context API & TypeScript
  • Summary
  • Bonus: Exploring tsconfig.json
  • Module Resources

29. Optional: React Hooks Introduction & Summary

  • Module Introduction
  • What Are React Hooks?
  • The Starting Project
  • React 18 & This Section
  • Getting Started with useState()
  • More on useState() & State Updating
  • Array Destructuring
  • Multiple States
  • Rules of Hooks
  • Passing State Data Across Components
  • Time to Practice: Hooks Basics v
  • Sending Http Requests
  • useEffect() & Loading Data
  • Understanding useEffect() Dependencies
  • More on useEffect()
  • What’s useCallback()?
  • Working with Refs & useRef()
  • Cleaning Up with useEffect()
  • Deleting Ingredients
  • Loading Errors & State Batching
  • More on State Batching & State Updates
  • Understanding useReducer()
  • Using useReducer() for the Http State
  • Working with useContext()
  • Performance Optimizations with useMemo()
  • Getting Started with Custom Hooks
  • Sharing Data Between Custom Hooks & Components
  • Using the Custom Hook
  • Wrap Up
  • Module Resources

30. Optional: React Summary & Core Feature Walkthrough

  • Module Introduction
  • What Is React & Why Would You Use It?
  • React Projects – Requirements
  • Creating React Projects
  • Out Starting Project
  • Understanding How React Works
  • Building A First Custom Component
  • Outputting Dynamic Values
  • Reusing Components
  • Passing Data to Components with Props
  • CSS Styling & CSS Modules
  • Exercise & Another Component
  • Preparing the App For State Management
  • Adding Event Listeners
  • Working with State
  • Lifting State Up
  • The Special “children” Prop
  • State & Conditional Content
  • Adding a Shared Header & More State Managemer
  • Adding Form Buttons
  • Handling Form Submission
  • Updating State Based On Previous State
  • Outputting List Data
  • Adding a Backend to the React SPA
  • Sending a POST HTTP Request
  • Handling Side Effects with useEffect()
  • Handle Loading State
  • Understanding &Adding Routing
  • Adding Routes
  • Working with Layout Routes
  • Refactoring Route Components & More Nesting
  • Linking & Navigating
  • Data Fetching via loader()s
  • Submitting Data with action()s
  • Dynamic Routes
  • Module Summary
  • Module Resources

31. Course Roundup

  • What Now? Next Steps You Could Take!
  • Explore The React Ecosystem!
  • Finishing Thoughts
  • Course Roundup
  • Bonus!

32. Old Course Content

  • Old Course Content Download


  • JavaScript + HTML + CSS fundamentals are essential prerequisites
  • You don’t need to be a JavaScript expert to succeed in this course!
  • Knowledge of ES6+ JavaScript is beneficial but not mandatory
  • No prior experience with React or any other JavaScript framework is required!

How long is this course expected to last?

A: Students can learn everything there is to know about React, React Router, and Redux at your own pace by viewing the more than 30 hours of available video content in this course.

Is this class appropriate for beginners?

A: Absolutely! This course is suitable for students of all skill levels, no mater how much experience you have with React. To guarantee that everyone can benefit from the subject, our instructors give precise explanations and step-by-step instructions.

What specifically will I learn from this course?

A: By taking this course, you’ll learn all there is to know about React, including React Router and Redux. You’ll learn how to create interactive screens, dynamic multi-page apps, and efficient application state management.

Free Download today and embark on a transformative journey to master React – The Complete Guide React, React Router, and Redux!

File Info:
Last Update: 10/2023
File Download Method: Fast Direct Server 
File Size: 19GB+ (apporx)

Wait 15 Second For Download This File For Free

Author :

if you find any wrong activities so kindly read our DMCA policy also contact us. Thank you for understand us…

4.5/5 - (30 votes)

3 thoughts on “React – The Complete Guide 2023 (incl. React Router & Redux)”

Leave a Comment