Understanding "let" and "const"
Classes Properties and Methods
The Spread and Rest Operator
Reference and Primitive Types Refresher
Refreshing Array Functions
What are Components? And Why is React All About Them?
React Code is Written in a Declarative Way
Creating a New React Project
Analyzing a Standard React Project
Building a First Custom Component
Writing More Complex JSX Code
Outputting Dynamic Data and Working with Expressions in JSX
Adding "normal" JavaScript Logic to Components
Splitting Components into Multiple Components
Time to Practice: React and Component Basics - Problem
Time to Practice: React and Component Basics - Solution
The Concept of "Composition" ("children props")
Organizing Component Files
An Alternative Function Syntax
Listening to Events and Working with Event Handlers
How Component Functions are Executed
A r Look at the "useState" Hook
Working with Multiple States
Using One State Instead (and What's Better)
Updating State that Depends on the Previous State
Child-to-Parent Component Communication
Time to Practice: Working with Events and State - Problem
Time to Practice: Working with Events and State - Solution
Controlled Versus Uncontrolled Components and Stateless Versus Stateful Components
Time to Practice: Working with Lists - Problem
Time to Practice: Working with Lists - Solution
Outputting Conditional Content
Adding Conditional Return Statements
Time to Practice: Conditional Content - Problem
Time to Practice: Conditional Content - Solution
Setting Dynamic Inline Styles
Setting CSS Classes Dynamically
Introducing Styled Components
Styled Components and Dynamic Props
Styled Components and Media Queries
Dynamic Styles with CSS Modules
Adding a "User" Component
Adding a Reusable "Card" Component
Adding a Reusable "Button" Component
Managing the User Input State
Adding Validation and Resetting Logic
Adding a User List Component
Managing a List of Users Through State
Adding the "ErrorModal" Component
What are "Side Effects" and Introducing useEffect()
Using the useEffect() Hook
useEffect() and Dependencies
Using the useEffect() Cleanup Function
Introducing useReducer() and Reducers in General
Using the useReducer() Hook
useReducer() and useEffect()
useReducer() Versus useState() for State Management
Introducing React Context
Using the React Context API
Tapping into Context with the useContext() Hook
Building and Using a Custom Context Provider Component
React Context Limitations
Learning the "Rules of Hooks"
Refactoring an Input Component
Diving into "Forward Refs"
Adding a "Header" Component
Adding the "Cart" Button Component
Adding a "Meals" Component
Adding Individual Meal Items and Displaying Them
Working on the "Shopping Cart" Component
Adding a Modal via a React Portal
Managing Cart and Modal State
Working with Refs and Forward Refs
Working on a More Complex Reducer Logic
Using the useEffect() Hook
Component Updates in Action
A r Look at Child Component Re-Evaluation
Preventing Unnecessary Re-Evaluations with React.memo()
Preventing Function Recreation with useCallback()
useCallback() and its Dependencies
A r Look at State and Components
Understanding State Scheduling and Batching
Optimizing with useMemo()
Adding the First Class-Based Component
Working with State and Events
The Component Lifecycle (Class-Based Components Only)
Lifecycle Methods in Action
Class-Based Components and Context
Class-based versus Functional Components: A Summary
Introducing Error Boundaries
How to Connect to a Database
Our Starting App and Backend
Handling Loading and Data States
Using useEffect() for Requests
Preparing the Project for the Next Steps
Creating a Custom React Hook Function
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
What's so Complex about Forms?
Dealing with Form Submission and Getting User Input Values
Providing Validation Feedback
Handling the "was touched" State
Refactoring and Deriving States
Managing the Overall Form Validity
Time to Practice: Forms - Problem
Time to Practice: Forms - Solution
Adding a Custom Input Hook
Applying Our Hook and Knowledge to a New Form
Another Look at State in React Apps
Redux versus React Context
Exploring the Core Redux Concepts
Creating a Redux Store for React
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 and Introducing Redux Toolkit
Connecting Redux Toolkit State
Migrating Everything to Redux Toolkit
Working with Multiple Slices
Reading and Dispatching from a New Slice
Redux and Side Effects (and Asynchronous Code)
Refresher/Practice: Part 1
Refresher/Practice: Part 2
Frontend Code Versus Backend Code
Using useEffect() with Redux
Handling HTTP States and Feedback with Redux
Using an Action Creator Thunk
Getting Started with Fetching Data
Finalizing the Fetching Logic
Exploring the Redux DevTools
Defining and Using Routes
Adding Dynamic Routes with Params
Using "Switch" and "exact" for Configuring Routes
Working with Nested Routes
Time to Practice: Onwards to a New Project
Practice Redirecting and Extracting Params
Adding a Layout Wrapper Component
Adding Dummy Data and More Content
Outputting Data on the "Details" Page
Adding a "Not Found" Page
Implementing Programmatic (Imperative) Navigation
Preventing Possibly Unwanted Route Transitions with the "Prompt" Component
Working with Query Parameters
Getting Creative with Nested Routes
Writing More Flexible Routing Code
Sending and Getting Quote Data via HTTP
Adding the "Comments" Feature
Upgrading to React Router v6
Starting Setup and First Steps
Showing Feedback to the User
Managing the Auth State with Context
Using the Token for Requests to Protected Resources
Protecting Frontend Pages
Persisting the User Authentication Status
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 and App
Analyzing the Created Project
Adding Nested Paths and Pages (Nested Routes)
Creating Dynamic Pages (with Parameters)
Extracting Dynamic Parameter Values
Onwards to a Bigger Project
Preparing the Project Pages
Outputting a List of Meetups
Adding the New Meetup Form
The "_app.js" File and Layout Wrapper
Using Programmatic (Imperative) Navigation
Adding Custom Components and CSS Modules
How Pre-Rendering Works and Which Problem We Face
Data Fetching for Static Pages
Static Site Generation (SSG)
Exploring Server-side Rendering (SSR) with "getServerSideProps"
Working with Params for SSG Data Fetching
Preparing Paths with "getStaticPaths" and Working with Fallback Pages
Sending HTTP Requests to Our API Routes
Getting Data from the Database
Getting Meetup Details Data and Preparing Pages
Deploying Next.js Projects
Using Fallback Pages and Redeploying
Preparing the Demo Project
CSS Transition and Animations Limitations
Using ReactTransitionGroup
Using the Transition Component
Wrapping the Transition Component
The CSSTransition Component
Customizing CSS Classnames
Alternative Animation Packages
Starting Project and Why You Would Replace Redux
Alternative: Using the Context API
Toggling Favorites with the Context API
Getting Started with a Custom Hook as a Store
Creating a Concrete Store
Custom Hook Store Summary
Optimizing the Custom Hook Store
Understanding Different Kinds of Tests
What to Test and How to Test
Understanding the Technical Setup and Involved Tools
Grouping Tests Together with Test Suites
Testing User Interaction and State
Testing Connected Components
Testing Asynchronous Code
Installing and Using TypeScript
Working with Array and Object Types
Understanding Type Inference
Understanding Type Aliases
Functions and Function Types
Creating a React + TypeScript Project
Working with Components and TypeScript
Working with Props and TypeScript
Time to Practice: Exercise Time!
Form Submissions in TypeScript Projects
Working with refs and useRef()
Working with "Function Props"
Managing State and TypeScript
Time to Practice: Removing a Todo
The Context API and TypeScript
Getting Started with useState()
More on useState() and State Updating
Passing State Data Across Components
Time to Practice: Hooks Basics - Problem
Time to Practice: Hooks Basics - Solution
useEffect() and Loading Data
Understanding useEffect() Dependencies
Working with Refs and useRef()
Cleaning Up with useEffect()
Loading Errors and State Batching
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 and Components
Building SPAs (Single-Page Applications)
Diving into the Created Project
How React Works and Understanding Components
More Component Work and Styling with CSS Classes
Building and Reusing Another Component
Working with "props" and Dynamic Content
Working with "Event Props" (Passing Function as Props)
Adding Links and Navigation
Adding More React Components
Building Wrapper Components with props.children
Getting User Input and Handling Form Submission
Preparing the App for HTTP
Navigating Programmatically
Getting Started with Fetching Data
Using the useEffect() Hook
Introducing React Context
Context Logic and Different Ways of Updating State
Using Context in Components