UDEMY.React.The.Complete.Guide.incl.Next.js.Redux.2026.BOOKWARE-MiMiR

Section

eBooks/Audiobooks

Group

MiMiR

Size

54,52 GB

Files

86

Date

2026-02-07

NFO

Mímir, Keeper of the Well of Wisdom
  
  React - The Complete Guide (incl. Next.js, Redux)

  https://www.udemy.com/course/react-the-complete-guide-incl-
  redux/

  Year         : 2026
  Language     : English
  Level        : All Levels
  Category     : Development
  Subcategory  : Programming Languages
  Duration     : 70h 45m
  Lectures     : 728
  Rating       : 4.7/5 (238,239 reviews)
  Students     : 1,006,863

  INSTRUCTOR(S)


  HEADLINE
    Dive in and learn React.js from scratch! Learn React, Hooks,
    Redux, React Router, Next.js, Best Practices and way more!


  WHAT YOU'LL LEARN
  * Learn React from the ground up and finish the course as an
    advanced React developer
  * Build multiple high-quality demo apps, including a fullstack
    app built with NextJS
  * Join more than 900,000 students in this course & more than
    3,000,000 students I taught across all my courses
  * Build fullstack React apps with NextJS 14+
  * Follow along locally or in a cloud development environment
  * Learn all about React Hooks and React Components
  * Manage complex state efficiently with React's Context API &
    React Redux
  * Build standalone React apps & applications connected to a
    backend via HTTP
  * Learn about routing & route-related data fetching with React
    Router
  * Implement user authentication in React apps
  * Get started with React Unit Testing


  REQUIREMENTS
  * JavaScript + HTML + CSS fundamentals are absolutely required
  * You DON'T need to be a JavaScript expert to succeed in this
    course!
  * ES6+ JavaScript knowledge is beneficial but not a must-have
  * NO prior React or any other JS framework experience is
    required!


  WHO IS THIS COURSE FOR
  * Students who want to learn how to build reactive and fast
    web
    apps
  * Anyone who's interested in learning an extremely popular
    technology used by leading tech companies like Netflix
  * Students who want to take their web development skills to
    the
    next level and learn a future-proof technology


  DESCRIPTION
  This bestselling course by the author of "React Key Concepts"
  has turned more students into ReactJS developers than any
    other
  courses - more than 1,000,000 and counting! - Fully updated
    for
  React 19! - A Course For Busy Customers & Business
  Professionals! This course also comes with two paths which you
  can take: The "complete" path (full >40h course) and the
  "summary" (fast-track) path (~4h summary module) - you can
  choose the path that best fits your time requirements!
    React.js
  is THE most popular JavaScript library you can use and learn
  these days to build modern, reactive user interfaces for the
  web. This course teaches you React in-depth, from the ground
    up,
  step by step by diving into all the core basics, exploring
    tons
  of examples and also introducing you to advanced concepts as
  well. You'll get all the theory, tons of examples and demos,
  assignments and exercises and tons of important knowledge that
  is skipped by most other resources - after all, there is a
  reason why this course is that huge! :) And in case you don't
  even know why you would want to learn React and you're just
    here
  because of some ad or "the algorithm" - no worries: ReactJS is
    a
  key technology as a web developer and in this course I will
    also
  explain WHY it's that important! Welcome to "React - The
  Complete Guide"! This course will teach you React.js in a
  practice-oriented way, using all the latest patterns and best
  practices you need. You will learn all the key fundamentals as
  well as advanced concepts and related topics to turn you into
    a
  React.js developer. This is a huge course because it really
  covers EVERYTHING you need to know and learn to become a
  React.js developer! No matter if you know nothing about React
    or
  if you already got some basic React knowledge (not required
    but
  also not a problem), you will get tons of useful information
    and
  knowledge out of this course! My goal with this course is to
  ensure that you feel confident working with React, so that you
  can apply for React jobs, use it in your own projects or
    simply
  enhance your portfolio as a developer - whatever your goal is:
  This course gets you there! I kept this course updated since
    its
  initial launch to ensure that you always learn React in the
    best
  possible and up-do-date way! What's in this course? A thorough
  introduction to React.js (What is it and why would you use
    it?)
  All the core basics: How React works, building components with
  React & building UIs with React Components, props & dynamic
    data
  binding Working with user events and state to create
    interactive
  applications A (thorough) look behind the scenes to understand
  how React works under the hood Detailed explanations on how to
  work with lists and conditional content React Hooks (in-
    depth)!
  Working with built-in Hooks and building custom Hooks How to
  debug React apps Styling React apps with "Styled Components"
    and
  "CSS Modules" Working with "Fragments" & "Portals" Dealing
    with
  side effects Class-based components and functional components
  Sending Http requests & handling transitional states +
    responses
  Handling forms and user input (incl. validation) Using React
  Form Actions Redux & Redux Toolkit Routing with React Router
  Understanding React Server Components An in-depth introduction
  into Next.js Deploying React Apps Implementing Authentication
  Unit Tests Combining React with TypeScript Adding Animations
  Tons of examples and demo projects so that you can apply all
    the
  things you learned in real projects And so much more - check
    out
  the full curriculum on this page! This really is the "Complete
  Guide" - promised! And best of all? You don't need any prior
  React knowledge! This course starts with zero knowledge
    assumed!
  All you need is basic web development and JavaScript knowledge
  (though the course even includes a brief JavaScript refresher
    to
  ensure that we're all on the same page!). Check out the full
  curriculum, the free preview videos and join the course risk-
  free thanks to the 30-day money-back guarantee!


  COURSE CONTENT

  Chapter 1: Getting Started
    1. Welcome To The Course!
    2. What is React.js? And Why Would You Use It?
    3. ReactJS vs "Vanilla JavaScript": Why Use React?
    4. Editing Our First React App
    5. About This Course & Course Outline
    6. The Two Ways (Paths) Of Taking This Course
    7. Getting The Most Out Of This Course
    8. Join our Online Learning Community
    9. Creating React Projects
    10. Why Do You Need A Special Project Setup?
    11. Course Setup

  Chapter 2: JavaScript Refresher
    12. Module Introduction
    13. Starting Project
    14. Adding JavaScript To A Page & How React Projects Differ
    15. React Projects Use a Build Process
    16. "import" & "export"
    17. Revisiting Variables & Values
    18. Revisiting Operators
    19. Revisiting Functions & Parameters
    20. Arrow Functions
    21. More on the Arrow Function Syntax
    22. Revisiting Objects & Classes
    23. Arrays & Array Methods like map()
    24. Destructuring
    25. Destructuring in Function Parameter Lists
    26. The Spread Operator
    27. Revisiting Control Structures
    28. Manipulating the DOM - Not With React!
    29. Using Functions as Values
    30. Defining Functions Inside Of Functions
    31. Reference vs Primitive Values
    32. Next-Gen JavaScript - Summary
    33. JS Array Functions
    34. Module Resources

  Chapter 3: React Essentials - Components, JSX, Props, State &
    More
    35. Module Introduction
    36. It's All About Components! [Core Concept]
    37. Setting Up The Starting Project
    38. JSX & React Components [Core Concept]
    39. Creating & Using a First Custom Component
    40. A Closer Look: Components & File Extensions
    41. How React Handles Components & How It Builds A
        "Component Tree" [Core Concept]
    42. Using & Outputting Dynamic Values [Core Concept]
    43. Setting HTML Attributes Dynamically & Loading Image
        Files
    44. Making Components Reusable with Props [Core Concept]
    45. Alternative Props Syntaxes
    46. More Prop Syntaxes
    47. Best Practice: Storing Components in Files & Using a
        Good Project Structure
    48. Storing Component Style Files Next To Components
    49. Component Composition: The special "children" Prop [Core
        Concept]
    50. Reacting to Events [Core Concept]
    51. Passing Functions as Values to Props
    52. Passing Custom Arguments to Event Functions
    53. How NOT to Update the UI - A Look Behind The Scenes of
        React [Core Concept]
    54. Managing State & Using Hooks [Core Concept]
    55. Deriving & Outputting Data Based on State
    56. Rendering Content Conditionally
    57. CSS Styling & Dynamic Styling
    58. Outputting List Data Dynamically
    59. Essentials Summary Slides
    60. Module Summary

  Chapter 4: React Essentials - Deep Dive
    61. Module Introduction
    62. You Don't Have To Use JSX!
    63. Working with Fragments
    64. When Should You Split Components?
    65. Splitting Components By Feature & State
    66. Problem: Props Are Not Forwarded To Inner Elements
    67. Forwarding Props To Wrapped Elements
    68. Working with Multiple JSX Slots
    69. Setting Component Types Dynamically
    70. Setting Default Prop Values
    71. Onwards To The Next Project & Advanced Concepts
    72. Not All Content Must Go Into Components
    73. Closer Look: public/ vs assets/ for Image Storage
    74. New Project: First Steps Towards Our Tic-Tac-Toe Game
    75. Concept Repetition: Splitting Components & Building
        Reusable Components
    76. Concept Repetition: Working with State
    77. Component Instances Work In Isolation!
    78. Conditional Content & A Suboptimal Way Of Updating State
    79. Best Practice: Updating State Based On Old State
        Correctly
    80. User Input & Two-Way-Binding
    81. Rendering Multi-Dimensional Lists
    82. Best Practice: Updating Object State Immutably
    83. Lifting State Up [Core Concept]
    84. Avoid Intersecting States!
    85. Prefer Computed Values & Avoid Unnecessary State
        Management
    86. Deriving State From Props
    87. Sharing State Across Components
    88. Reducing State Management & Identifying Unnecessary
        State
    89. Disabling Buttons Conditionally
    90. Outsourcing Data Into A Separate File
    91. Lifting Computed Values Up
    92. Deriving Computed Values From Other Computed Values
    93. Tic-Tac-Toe Game: The "Game Over" Screen & Checking for
        a Draw
    94. Why Immutability Matters - Always!
    95. When NOT To Lift State Up
    96. An Alternative To Lifting State Up
    97. Final Polishing & Improving Components
    98. Summary Slides

  Chapter 5: React Essentials - Practice Project
    99. Module Introduction & A Challenge For You!
    100. Adding a Header Component
    101. Getting Started with a User Input Component
    102. Handling Events & Using Two-Way-Binding
    103. Lifting State Up
    104. Computing Values & Properly Handling Number Values
    105. Outputting Results in a List & Deriving More Values
    106. Outputting Content Conditionally

  Chapter 6: Styling React Components
    107. Module Introduction & Starting Project
    108. Splitting CSS Code Across Multiple Files
    109. Styling React Apps with Vanilla CSS - Pros & Cons
    110. Vanilla CSS Styles Are NOT Scoped To Components!
    111. Styling React Apps with Inline Styles
    112. Dynamic & Conditional Inline Styles
    113. Dynamic & Conditional Styling with CSS Files & CSS
         Classes
    114. Scoping CSS Rules with CSS Modules
    115. Introducing "Styled Components" (Third-party Package)
    116. Creating Flexible Components with Styled Components
    117. Dynamic & Conditional Styling with Styled Components
    118. Styled Components: Pseudo Selectors, Nested Rules &
         Media Queries
    119. Creating Reusable Components & Component Combinations
    120. Introducing Tailwind CSS For React App Styling
    121. Tailwind 3 vs 4
    122. Adding & Using Tailwind CSS In A React Project
    123. Tailwind: Media Queries & Pseudo Selectors
    124. Dynamic & Conditional Styling with Tailwind
    125. Migrating The Demo App to Tailwind CSS
    126. Tailwind CSS: Pros & Cons

  Chapter 7: Debugging React Apps
    127. Module Introduction
    128. The Starting Project
    129. Understanding React Error Messages
    130. Using the Browser Debugger & Breakpoints
    131. Understanding React's "Strict Mode"
    132. Using the React DevTools (Browser Extension)

  Chapter 8: Working with Refs & Portals
    133. Module Introduction & Starting Project
    134. Repetition: Managing User Input with State (Two-Way-
         Binding)
    135. Repetition: Fragments
    136. Introducing Refs: Connecting & Accessing HTML Elements
         via Refs
    137. Manipulating the DOM via Refs
    138. Refs vs State Values
    139. Adding Challenges to the Demo Project
    140. Setting Timers & Managing State
    141. Using Refs for More Than "DOM Element Connections"
    142. Adding a Modal Component
    143. Forwarding Refs to Custom Components
    144. Exposing Component APIs via the useImperativeHandle
         Hook
    145. More Examples: When To Use Refs & State
    146. Sharing State Across Components
    147. Enhancing the Demo App "Result Modal"
    148. Closing the Modal via the ESC (Escape) Key
    149. Introducing & Understanding "Portals"

  Chapter 9: Practice Project: Project Management App (with
    Components, State, Refs & More)
    150. Module Introduction & Starting Project
    151. Adding a "Projects Sidebar" Component
    152. Styling the Sidebar & Button with Tailwind CSS
    153. Adding the "New Project" Component & A Reusable "Input"
         Component
    154. Styling Buttons & Inputs with Tailwind CSS
    155. Splitting Components to Split JSX & Tailwind Styles
         (for Higher Reusability)
    156. Managing State to Switch Between Components
    157. Collecting User Input with Refs & Forwarded Refs
    158. Handling Project Creation & Updating the UI
    159. Validating User Input & Showing an Error Modal via
         useImperativeHandle
    160. Styling the Modal via Tailwind CSS
    161. Making Projects Selectable & Viewing Project Details
    162. Handling Project Deletion
    163. Adding "Project Tasks" & A Tasks Component
    164. Managing Tasks & Understanding Prop Drilling
    165. Clearing Tasks & Fixing Minor Bugs

  Chapter 10: React's Context API & useReducer - Advanced State
    Management
    166. Module Introduction
    167. Understanding Prop Drilling & Project Overview
    168. Prop Drilling: Component Composition as a Solution
    169. Introducing the Context API
    170. Creating & Providing The Context
    171. Consuming the Context
    172. Linking the Context to State
    173. A Different Way Of Consuming Context
    174. What Happens When Context Values Change?
    175. Migrating the Entire Demo Project to use the Context
         API
    176. Outsourcing Context & State Into a Separate Provider
         Component
    177. Introducing the useReducer Hook
    178. Dispatching Actions & Editing State with useReducer

  Chapter 11: Handling Side Effects & Working with the
    useEffect() Hook
    179. Module Introduction & Starting Project
    180. What's a "Side Effect"? A Thorough Example
    181. A Potential Problem with Side Effects: An Infinite Loop
    182. Using useEffect for Handling (Some) Side Effects
    183. Not All Side Effects Need useEffect
    184. useEffect Not Needed: Another Example
    185. Preparing Another Use-Case For useEffect
    186. Using useEffect for Syncing With Browser APIs
    187. Understanding Effect Dependencies
    188. Fixing a Small Bug
    189. Preparing Another Problem That Can Be Fixed with
         useEffect
    190. Introducing useEffect's Cleanup Function
    191. The Problem with Object & Function Dependencies
    192. The useCallback Hook
    193. useEffect's Cleanup Function: Another Example
    194. Optimizing State Updates

  Chapter 12: Practice Project: Building a Quiz App
    195. Module Introduction & Starting Project
    196. A First Component & Some State
    197. Deriving Values, Outputting Questions & Registering
         Answers
    198. Shuffling Answers & Adding Quiz Logic
    199. Adding Question Timers
    200. Working with Effect Dependencies & useCallback
    201. Using Effect Cleanup Functions & Using Keys for
         Resetting Components
    202. Highlighting Selected Answers & Managing More State
    203. Splitting Components Up To Solve Problems
    204. Moving Logic To Components That Actually Need It
         ("Moving State Down")
    205. Setting Different Timers Based On The Selected Answer
    206. Outputting Quiz Results

  Chapter 13: A Look Behind The Scenes Of React & Optimization
    Techniques
    207. Module Introduction
    208. React Builds A Component Tree / How React Works Behind
         The Scenes
    209. Analyzing Component Function Executions via React's
         DevTools Profiler
    210. Avoiding Component Function Executions with memo()
    211. Avoiding Component Function Executions with Clever
         Structuring
    212. Understanding the useCallback() Hook
    213. Understanding the useMemo() Hook
    214. React Uses A Virtual DOM - Time To Explore It!
    215. Why Keys Matter When Managing State!
    216. More Reasons For Why Keys Matter
    217. Using Keys For Resetting Components
    218. State Scheduling & Batching
    219. Optimizing React with MillionJS

  Chapter 14: An Alternative Way Of Building Components: Class-
    based Components
    220. Module Introduction
    221. What & Why
    222. Adding a First Class-based Component
    223. Working with State & Events
    224. The Component Lifecycle (Class-based Components Only!)
    225. Lifecycle Methods In Action
    226. Class-based Components & Context
    227. Class-based vs Functional Components: A Summary
    228. Introducing Error Boundaries
    229. Module Resources

  Chapter 15: Sending Http Requests (e.g. Connecting to a
    Database)
    230. Module Introduction
    231. How (Not) To Connect To A Database
    232. Starting Project & Dummy Backend API
    233. Preparing the App For Data Fetching
    234. How NOT To Send HTTP Requests (And Why It's Wrong)
    235. Sending HTTP Requests (GET Request) via useEffect
    236. Using async / await
    237. Handling Loading States
    238. Importing from Error.jsx
    239. Handling HTTP Errors
    240. Transforming Fetched Data
    241. Extracting Code & Improving Code Structure
    242. Sending Data with POST Requests
    243. Using Optimistic Updating
    244. Deleting Data (via DELETE HTTP Requests)
    245. Practice: Fetching Data

  Chapter 16: Building Custom React Hooks
    246. Module Introduction & Starting Project
    247. Revisiting the "Rules of Hooks" & Why To Use Hooks
    248. Creating a Custom Hook
    249. Custom Hook: Managing State & Returning State Values
    250. Exposing Nested Functions From The Custom Hook
    251. Using A Custom Hook in Multiple Components
    252. Creating Flexible Custom Hooks

  Chapter 17: Working with Forms & User Input
    253. Module Introduction & Starting Project
    254. What Are Forms & What's Tricky About Them?
    255. Handling Form Submission
    256. Managing & Getting User Input via State & Generic
         Handlers
    257. Getting User Input via Refs
    258. Getting Values via FormData & Native Browser APIs
    259. Resetting Forms
    260. Validating Input on Every Keystroke via State
    261. Validating Input Upon Lost Focus (Blur)
    262. Validating Input Upon Form Submission
    263. Validating Input via Built-in Validation Props
    264. Mixing Custom & Built-in Validation Logic
    265. Building & Using a Reusable Input Component
    266. Outsourcing Validation Logic
    267. Creating a Custom useInput Hook
    268. Using Third-Party Form Libraries

  Chapter 18: Handling Forms via Form Actions
    269. Module Introduction
    270. What are Form Actions?
    271. Adding Validation Checks
    272. Managing Form-dependent State with useActionState()
    273. Using User Input
    274. Moving the Action Function out of the Component
    275. A Demo App: Introduction
    276. Handling Form Submission
    277. Working with Asynchronous Form Actions
    278. Updating the UI with useFormStatus()
    279. Registering Multiple Form Actions
    280. Sending an HTTP Request via a Form Action
    281. Using the "pending" State from useActionState()
    282. Adding Optimistic Updating
    283. Module Summary

  Chapter 19: Practice Project: Building a Food Order App
    284. Module Introduction & Starting Project
    285. Planning the App & Adding a First Component
    286. Fetching Meals Data (GET HTTP Request)
    287. Adding a "MealItem" Component
    288. Formatting & Outputting Numbers as Currency
    289. Creating a Configurable & Flexible Custom Button
         Component
    290. Getting Started with Cart Context & Reducer
    291. Finishing & Using the Cart Context & Reducer
    292. Adding a Reusable Modal Component with useEffect
    293. Opening the Cart in the Modal via a New Context
    294. Working on the Cart Items
    295. Adding a Custom Input Component & Managing Modal
         Visibility
    296. Handling Form Submission & Validation
    297. Sending a POST Request with Order Data
    298. Adding a Custom HTTP Hook & Avoiding Common Errors
    299. Handling HTTP Loading & Error States
    300. Finishing Touches
    301. Migrating To Form Actions
    302. Managing Form Status with Form Actions

  Chapter 20: Diving into Redux (An Alternative To The Context
    API)
    303. Module Introduction
    304. Another Look At State In React Apps
    305. Redux vs React Context
    306. How Redux Works
    307. MUST READ: Redux createStore() is (not) deprecated
    308. Exploring The Core Redux Concepts
    309. More Redux Basics
    310. Preparing a new Project
    311. Creating a Redux Store for React
    312. Providing the Store
    313. Using Redux Data in React Components
    314. Dispatching Actions From Inside Components
    315. Redux with Class-based Components
    316. Attaching Payloads to Actions
    317. Working with Multiple State Properties
    318. How To Work With Redux State Correctly
    319. Redux Challenges & Introducing Redux Toolkit
    320. Adding State Slices
    321. Connecting Redux Toolkit State
    322. Migrating Everything To Redux Toolkit
    323. Working with Multiple Slices
    324. Reading & Dispatching From A New Slice
    325. Splitting Our Code
    326. Summary

  Chapter 21: Advanced Redux
    327. Module Introduction
    328. Redux & Side Effects (and Asynchronous Code)
    329. Refresher / Practice: Part 1/2
    330. Refresher / Practice: Part 2/2
    331. Using Firebase as a Backend
    332. Redux & Async Code
    333. Frontend Code vs Backend Code
    334. Where To Put Our Logic
    335. Using useEffect with Redux
    336. A Problem with useEffect()
    337. Handling Http States & Feedback with Redux
    338. Using an Action Creator Thunk
    339. Getting Started with Fetching Data
    340. Finalizing the Fetching Logic
    341. Exploring the Redux DevTools
    342. Summary

  Chapter 22: Building a Multi-Page SPA with React Router
    343. Module Introduction
    344. Routing: Multiple Pages in Single-Page Applications
    345. Project Setup & Installing React Router
    346. Defining Routes
    347. Adding a Second Route
    348. Exploring an Alternative Way of Defining Routes
    349. Navigating between Pages with Links
    350. Layouts & Nested Routes
    351. Showing Error Pages with errorElement
    352. Working with Navigation Links (NavLink)
    353. Navigating Programmatically
    354. Defining & Using Dynamic Routes
    355. Adding Links for Dynamic Routes
    356. Understanding Relative & Absolute Paths
    357. Working with Index Routes
    358. Onwards to a new Project Setup
    359. Time to Practice: Problem
    360. Time to Practice: Solution
    361. Data Fetching with a loader()
    362. Using Data From A Loader In The Route Component
    363. More loader() Data Usage
    364. Where Should loader() Code Be Stored?
    365. When Are loader() Functions Executed?
    366. Reflecting The Current Navigation State in the UI
    367. Returning Responses in loader()s
    368. Which Kind Of Code Goes Into loader()s?
    369. Error Handling with Custom Errors
    370. Extracting Error Data & Throwing Responses
    371. The json() Utility Function
    372. Dynamic Routes & loader()s
    373. The useRouteLoaderData() Hook & Accessing Data From
         Other Routes
    374. Planning Data Submission
    375. Working with action() Functions
    376. Submitting Data Programmatically
    377. Updating the UI State Based on the Submission Status
    378. Validating User Input & Outputting Validation Errors
    379. Reusing Actions via Request Methods
    380. Behind-the-Scenes Work with useFetcher()
    381. Deferring Data Fetching with defer()
    382. defer() and json() with React Router v7
    383. Controlling Which Data Should Be Deferred
    384. Module Summary
    385. Module Resources
    386. Old Lectures

  Chapter 23: Adding Authentication To React Apps
    387. Module Introduction
    388. How Authentication Works
    389. Project Setup & Route Setup
    390. Working with Query Parameters
    391. Implementing the Auth Action
    392. Validating User Input & Outputting Validation Errors
    393. Adding User Login
    394. Attaching Auth Tokens to Outgoing Requests
    395. Adding User Logout
    396. Updating the UI Based on Auth Status
    397. Important: loader()s must return null or any other
         value
    398. Adding Route Protection
    399. Adding Automatic Logout
    400. Managing the Token Expiration
    401. Module Resources

  Chapter 24: Deploying React Apps
    402. Module Introduction
    403. Deployment Steps
    404. Understanding Lazy Loading
    405. Adding Lazy Loading
    406. Building the Code For Production
    407. Deployment Example
    408. Server-side Routing & Required Configuration

  Chapter 25: React Query / Tanstack Query: Handling HTTP
    Requests With Ease
    409. Module Introduction
    410. Project Setup & Overview
    411. React Query: What & Why?
    412. Installing & Using Tanstack Query - And Seeing Why It's
         Great!
    413. Understanding & Configuring Query Behaviors - Cache &
         Stale Data
    414. Dynamic Query Functions & Query Keys
    415. The Query Configuration Object & Aborting Requests
    416. Enabled & Disabled Queries
    417. Changing Data with Mutations
    418. Fetching More Data & Testing the Mutation
    419. Acting on Mutation Success & Invalidating Queries
    420. A Challenge! The Problem
    421. A Challenge! The Solution
    422. Disabling Automatic Refetching After Invalidations
    423. Enhancing the Demo App & Repeating Mutation Concepts
    424. React Query Advantages In Action
    425. Updating Data with Mutations
    426. Optimistic Updating
    427. Using the Query Key As Query Function Input
    428. React Query & React Router

  Chapter 26: A (Pretty Deep Dive) Introduction to Next.js
    429. Module Introduction
    430. Creating a NextJS Project
    431. Understanding File-based Routing & React Server
         Components
    432. Adding Another Route via the Filesystem
    433. Navigating Between Pages
    434. Working with Pages & Layouts
    435. Reserved File Names, Custom Components & How To
         Organize A NextJS Project
    436. Reserved Filenames
    437. Configuring Dynamic Routes & Using Route Parameters
    438. Onwards to the Main Project: The Foodies App
    439. Exercise: Your Task
    440. Exercise: Solution
    441. Revisiting The Concept Of Layouts
    442. Adding a Custom Component To A Layout
    443. Styling NextJS Project: Your Options & Using CSS
         Modules
    444. Optimizing Images with the NextJS Image Component
    445. Using More Custom Components
    446. Populating The Starting Page Content
    447. Preparing an Image Slideshow
    448. React Server Components vs Client Components - When To
         Use What
    449. Using Client Components Efficiently
    450. Outputting Meals Data & Images With Unknown Dimensions
    451. Setting Up A SQLite Database
    452. Fetching Data By Leveraging NextJS & Fullstack
         Capabilities
    453. Adding A Loading Page
    454. Using Suspense & Streamed Responses For Granular
         Loading State Management
    455. Handling Errors
    456. Handling "Not Found" States
    457. Loading & Rendering Meal Details via Dynamic Routes &
         Route Parameters
    458. Throwing Not Found Errors For Individual Meals
    459. Getting Started with the "Share Meal" Form
    460. Getting Started with a Custom Image Picker Input
         Component
    461. Adding an Image Preview to the Picker
    462. Improving the Image Picker Component
    463. Introducing & Using Server Actions for Handling Form
         Submissions
    464. Storing Server Actions in Separate Files
    465. Creating a Slug & Sanitizing User Input for XSS
         Protection
    466. Storing Uploaded Images & Storing Data in the Database
    467. Managing the Form Submission Status with useFormStatus
    468. Adding Server-Side Input Validation
    469. Working with Server Action Responses & useFormState
    470. Building For Production & Understanding NextJS Caching
    471. Triggering Cache Revalidations
    472. Don't Store Files Locally On The Filesystem!
    473. Bonus: Storing Uploaded Images In The Cloud (AWS S3)
    474. Adding Static Metadata
    475. Adding Dynamic Metadata
    476. Module Summary
    477. About the NextJS Pages Router
    478. Creating a NextJS Project
    479. Analyzing the Created Project
    480. Adding First Pages
    481. Adding Nested Paths & Pages (Nested Routes)
    482. Creating Dynamic Pages (with Parameters)
    483. Extracting Dynamic Parameter Values
    484. Linking Between Pages
    485. Onwards to a bigger Project!
    486. Preparing the Project Pages
    487. Outputting a List of Meetups
    488. Adding the New Meetup Form
    489. The "_app.js" File & Layout Wrapper
    490. Using Programmatic (Imperative) Navigation
    491. Adding Custom Components & CSS Modules
    492. How Pre-rendering Works & Which Problem We Face
    493. Data Fetching for Static Pages
    494. More on Static Site Generation (SSG)
    495. Exploring Server-side Rendering (SSR) with
         "getServerSideProps"
    496. Working with Params for SSG Data Fetching
    497. Preparing Paths with "getStaticPaths" & Working With
         Fallback Pages
    498. Introducing API Routes
    499. Working with MongoDB
    500. Sending Http Requests To Our API Routes
    501. Getting Data From The Database
    502. Getting Meetup Details Data & Preparing Pages
    503. Adding "head" Metadata
    504. Deploying Next.js Projects
    505. Using Fallback Pages & Re-deploying
    506. Summary
    507. Module Resources

  Chapter 27: React Server Components (RSC) & Server Actions - A
    Closer Look
    508. Module Introduction
    509. Why We Need A Special Project Setup
    510. Understanding React Server Components
    511. Changing Server to Client Components
    512. Combining Server and Client Components
    513. Fetching Data with RSCs
    514. Submitting Data with Server Actions
    515. Using the use() Hook for Promises & Data Fetching
    516. The use() Hook In Action
    517. Handling Errors
    518. Theory Wrap Up

  Chapter 28: Animating React Apps
    519. Module Introduction
    520. Project Setup & Overview
    521. Animating with CSS Transitions
    522. Animating with CSS Animations
    523. Introducing Framer Motion
    524. Framer Motion Basics & Fundamentals
    525. Animating Between Conditional Values
    526. Adding Entry Animations
    527. Animating Element Disappearances / Removal
    528. Making Elements "Pop" With Hover Animations
    529. Reusing Animation States
    530. Nested Animations & Variants
    531. Animating Staggered Lists
    532. Animating Colors & Working with Keyframes
    533. Imperative Animations
    534. Animating Layout Changes
    535. Orchestrating Multi-Element Animations
    536. Combining Animations With Layout Animations
    537. Animating Shared Elements
    538. Re-triggering Animations via Keys
    539. Scroll-based Animations

  Chapter 29: React Patterns & Best Practices
    540. Module Introduction
    541. Project Overview
    542. Introducing Compound Components
    543. Managing Multi-Component State with the Context API
    544. Grouping Compound Components
    545. Adding Extra Components For Reusability &
         Configurability
    546. Sharing Cross-Component State When Working With
         Compound Components
    547. Introducing & Using Render Props
    548. Adding Search To A React App
    549. Implementing a Search Functionality With Help Of Render
         Props
    550. Handling Keys Dynamically
    551. Working with Debouncing

  Chapter 30: Replacing Redux with React Hooks
    552. Module Introduction
    553. React 18 & This Section
    554. Starting Project & Why You Would Replace Redux
    555. Alternative: Using the Context API
    556. Toggling Favorites with the Context API
    557. Context API Summary (and why NOT to use it instead of
         Redux)
    558. Getting Started with a Custom Hook as a Store
    559. Finishing the Store Hook
    560. Creating a Concrete Store
    561. Using the Custom Store
    562. Custom Hook Store Summary
    563. Optimizing the Custom Hook Store
    564. Bonus: Managing Multiple State Slices with the Custom
         Store Hook
    565. Wrap Up
    566. Module Resources

  Chapter 31: Testing React Apps (Unit Tests)
    567. Module Introduction
    568. What & Why?
    569. Understanding Different Kinds Of Tests
    570. What To Test & How To Test
    571. Understanding the Technical Setup & Involved Tools
    572. Running a First Test
    573. Writing Our First Test
    574. Grouping Tests Together With Test Suites
    575. Testing User Interaction & State
    576. Testing Connected Components
    577. Testing Asynchronous Code
    578. Working With Mocks
    579. Summary & Further Resources

  Chapter 32: React + TypeScript
    580. Module Introduction
    581. What & Why?
    582. Installing & Using TypeScript
    583. Exploring the Base Types
    584. Working with Array & Object Types
    585. Understanding Type Inference
    586. Using Union Types
    587. Understanding Type Aliases
    588. Functions & Function Types
    589. Diving Into Generics
    590. A Closer Look At Generics
    591. Creating a React + TypeScript Project
    592. Working with Components & TypeScript
    593. Working with Props & TypeScript
    594. Adding a Data Model
    595. Time to Practice: Exercise Time!
    596. Form Submissions In TypeScript Projects
    597. Working with refs & useRef
    598. Working with "Function Props"
    599. Managing State & TypeScript
    600. Adding Styling
    601. Time to Practice: Removing a Todo
    602. The Context API & TypeScript
    603. Summary
    604. Bonus: Exploring tsconfig.json

  Chapter 33: Optional: React Summary & Core Feature Walkthrough
    605. Module Introduction
    606. What Is React & Why Would You Use It?
    607. React Projects - Requirements
    608. Creating React Projects
    609. Out Starting Project
    610. Understanding How React Works
    611. Building A First Custom Component
    612. Outputting Dynamic Values
    613. Reusing Components
    614. Passing Data to Components with Props
    615. CSS Styling & CSS Modules
    616. Exercise & Another Component
    617. Preparing the App For State Management
    618. Adding Event Listeners
    619. Working with State
    620. Lifting State Up
    621. The Special "children" Prop
    622. State & Conditional Content
    623. Adding a Shared Header & More State Management
    624. Adding Form Buttons
    625. Handling Form Submission
    626. Updating State Based On Previous State
    627. Outputting List Data
    628. Adding a Backend to the React SPA
    629. Sending a POST HTTP Request
    630. Handling Side Effects with useEffect()
    631. Handle Loading State
    632. Understanding & Adding Routing
    633. Adding Routes
    634. Working with Layout Routes
    635. Refactoring Route Components & More Nesting
    636. Linking & Navigating
    637. Data Fetching via loader()s
    638. Submitting Data with action()s
    639. Dynamic Routes
    640. Module Summary
    641. Module Resources

  Chapter 34: Course Roundup
    642. Course Roundup
    643. Bonus!

  Chapter 35: Course Update & Old Course Content
    644. Course Update Overview, Explanation & Migration Guide
    645. Old Course Content Download

  Chapter 36: [BONUS / OPTIONAL] React Basics & Working With
    Components
    646. About these [BONUS / OPTIONAL] sections
    647. Module Introduction
    648. What Are Components? And Why Is React All About Them?
    649. React Code Is Written In A "Declarative Way"!
    650. Creating a new React Project
    651. The Starting Project
    652. Analyzing a Standard React Project
    653. Introducing JSX
    654. How React Works
    655. Building a First Custom Component
    656. Writing More Complex JSX Code
    657. Adding Basic CSS Styling
    658. Outputting Dynamic Data & Working with Expressions in
         JSX
    659. Passing Data via "props"
    660. Alternative Ways of Passing & Receiving / Handling
         "props"
    661. Adding "normal" JavaScript Logic to Components
    662. Splitting Components Into Multiple Components
    663. The Concept of "Composition" ("children props")
    664. A First Summary
    665. A Closer Look At JSX
    666. Organizing Component Files
    667. An Alternative Function Syntax
    668. Module Resources

  Chapter 37: [BONUS / OPTIONAL] Time to Practice: Component
    Basics
    669. Module Introduction
    670. The Starting Project & Your Tasks
    671. Exercise Hints
    672. Outputting Key Concepts Data
    673. Identifying Possible Components
    674. Creating & Using a Custom Component
    675. Outsourcing Concept Items Into a Reusable Component
    676. Module Resources

  Chapter 38: [BONUS / OPTIONAL] React State & Working with
    Events
    677. Module Introduction
    678. Listening to Events & Working with Event Handlers
    679. How Component Functions Are Executed
    680. Working with "State"
    681. A Closer Look at the "useState" Hook
    682. State can be updated in many ways!
    683. Adding Form Inputs
    684. Listening to User Input
    685. Working with Multiple States
    686. Using One State Instead (And What's Better)
    687. Updating State That Depends On The Previous State
    688. Alternative: Creating A Shared Handler Function
    689. Handling Form Submission
    690. Adding Two-Way Binding
    691. Child-to-Parent Component Communication (Bottom-up)
    692. Lifting The State Up
    693. Derived / Computed State
    694. Controlled vs Uncontrolled Components & Stateless vs
         Stateful Components
    695. Module Resources

  Chapter 39: [BONUS / OPTIONAL] Rendering Lists & Conditional
    Content
    696. Module Introduction
    697. Rendering Lists of Data
    698. Using Stateful Lists
    699. Understanding "Keys"
    700. Outputting Conditional Content
    701. Adding Conditional Return Statements
    702. Demo App: Adding a Chart
    703. Adding Dynamic Styles
    704. Wrap Up & Next Steps
    705. Fixing a Small Bug
    706. Module Resources

  Chapter 40: [BONUS / OPTIONAL] Time to Practice: A Complete
    Practice Project
    707. Module Introduction
    708. The First Practice Project & Your Tasks
    709. Exercise Hints
    710. Splitting the App Into Components
    711. Handling Events
    712. Managing State
    713. Lifting the State Up
    714. Outputting Results Conditionally
    715. Adding CSS Modules
    716. Fixing a Small Bug
    717. Introducing the Second Project
    718. Exercise Hints
    719. Adding a "User" Component
    720. Adding a re-usable "Card" Component
    721. Adding a re-usable "Button" Component
    722. Managing the User Input State
    723. Adding Validation & Resetting Logic
    724. Adding a Users List Component
    725. Managing a List Of Users via State
    726. Adding The "ErrorModal" Component
    727. Managing the Error State
    728. Module Resources


  DATES
  Published    : 2017-10-24
  Last Updated : 2026-01-16

If you fear the truth, don?t come to my well.

Files