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

We welcome to howtofree.org “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

10. 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
Techniques

• 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
Components

• 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

Requirements

• 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!

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

Join on Telegram

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 : https://www.udemy.com/course/react-the-complete-guide-incl-redux/

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