WeCours > Development > Programming Languages > React – Le guide complet (incl Hooks, React Router, Redux)
4.65 sur 5
4.65

React – Le guide complet (incl Hooks, React Router, Redux)

Plongez et apprenez React.js à partir de zéro ! Apprenez Reactjs, Hooks, Redux, React Routing, Animations, Next.js et bien plus encore !
Instructeur :
Mahefa Abel
Français
Construire des applications web puissantes, rapides, conviviales et réactives
Fournissez des expériences utilisateur incroyables en tirant parti de la puissance de JavaScript en toute simplicité
Postulez à des emplois bien rémunérés ou travaillez en tant que pigiste dans l'un des secteurs les plus demandés que vous pouvez trouver dans le développement Web en ce moment
Tout savoir sur React Hooks et React Components

Ce cours est entièrement à jour avec React 18 (la dernière version de React) !

Il a été entièrement mis à jour et réenregistré à partir du à la base – il enseigne la toute dernière version de React avec toutes les fonctionnalités de base et modernes que vous devez connaître !

—

Ce cours comprend également deux parcours que vous pouvez emprunter : Le parcours “complet”  (parcours complet >40h) et le parcours “summary”  chemin (module de résumé d’environ 4 h) – vous pouvez choisir le chemin qui correspond le mieux à vos besoins !  🙂

—

React.js est LA bibliothèque JavaScript la plus populaire que vous pouvez utiliser et apprendre de nos jours pour créer des interfaces utilisateur modernes et réactives pour le Web.

Ce cours vous apprend à réagir en profondeur, à partir de la base, étape par étape en plongeant dans toutes les bases de base, en explorant des tonnes d’exemples et en vous présentant également des concepts avancés.

Vous obtiendrez toutes les théorie, des tonnes d’exemples et de démonstrations, des devoirs et des exercices et des tonnes de connaissances importantes qui sont ignorées par la plupart des autres ressources – après tout, il y a une raison pour laquelle ce cours est si énorme ! 🙂

Et au cas où vous ne sauriez même pas pourquoi vous voudriez apprendre React et que vous êtes juste ici à cause d’une publicité ou de “l’algorithme” – pas de soucis : ReactJS est une clé technologie en tant que développeur Web et dans ce cours, j’expliquerai également POURQUOI c’est si important !

 

Bienvenue dans “React – Le guide complet” !

Ce cours vous apprendra React.js de manière pratique, en utilisant tous les derniers modèles et les meilleures pratiques dont vous avez besoin. Vous apprendrez tous les fondamentaux clés ainsi que des concepts avancés et des sujets connexes pour vous transformer en un développeur React.js.

C’est un cours énorme car il couvre vraiment TOUT ce que vous devez savoir et apprenez à devenir un développeur React.js !

Peu importe si vous ne connaissez rien à React ou si vous avez déjà acquis quelques connaissances de base sur React (pas obligatoire mais pas non plus un problème), vous obtiendrez des tonnes d’informations et de connaissances utiles grâce à ce cours !

Mon objectif avec ce cours est de m’assurer que vous vous sentez travailler en toute confiance avec React, afin que vous puissiez postuler à des emplois React, l’utiliser dans vos propres projets ou simplement améliorer votre portefeuille en tant que développeur – quel que soit votre objectif : ce cours vous y mène !

 

J’ai initialement créé ce cours en 2017 et je l’ai maintenu à jour depuis – en le refaisant à partir de zéro en 2021. Et bien sûr, je m’engage à maintenir ce cours à jour – afin que vous puissiez compter sur ce cours pour apprendre React de la meilleure façon possible !

Que contient ce cours ?

  • Une introduction approfondie à React.js (Qu’est-ce que c’est et pourquoi l’utiliseriez-vous ?)
  • Tous les bases de base : Comment fonctionne React, construire des composants avec React & créer des interfaces utilisateur avec React
  • Composants, accessoires et amp ; liaison de données dynamique
  • Travailler avec les événements et l’état de l’utilisateur pour créer des applications interactives
  • Un aperçu (approfondi) des coulisses pour comprendre comment React fonctionne sous le capot
  • Des explications détaillées sur la façon de travailler avec des listes et du contenu conditionnel
  • React Hooks (en -depth) !
  • Travailler avec les crochets intégrés et créer des crochets personnalisés
  • Comment déboguer les applications React
  • Styler les applications React avec “Composants stylisés” et “Modules CSS”
  • Travailler avec les “Fragments” &amp ; “Portails”
  • Traitement des effets secondaires
  • Composants basés sur les classes et composants fonctionnels
  • Envoi de requêtes Http & gestion des états de transition + réponses
  • Gestion des formulaires et des entrées utilisateur (y compris la validation)
  • Redux &amp ; Boîte à outils Redux
  • Routage avec React Router
  • Une introduction approfondie à Next.js
  • Déployer des applications React
  • Mettre en œuvre l’authentification
  • Tests unitaires
  • Combiner React avec TypeScript
  • Ajouter des animations
  • Des tonnes d’exemples et de projets de démonstration pour que vous puissiez appliquez tout ce que vous avez appris dans des projets réels
  • Et bien plus encore – consultez le programme complet sur cette page !

C’est vraiment le “Guide complet” – promis !

Et le meilleur de tous ?

Vous n’avez besoin d’aucune connaissance préalable de React !

Ce cours commence avec zéro connaissance ! Tout ce dont vous avez besoin est une connaissance de base du développement Web et de JavaScript (bien que le cours inclue même un bref rappel de JavaScript pour vous assurer que nous sommes tous sur la même longueur d’onde !).

Découvrez le programme complet, les vidéos de prévisualisation gratuites et rejoignez le cours sans risque grâce à la garantie satisfait ou remboursé de 30 jours !

Getting Started

1
Welcome To The Course!
2
What is React.js?
3
Why React Instead Of "Just JavaScript"?
4
Building Single-Page Applications (SPAs) with React
5
Exploring React.js Alternatives (Angular / Vue)
6
Join our Online Learning Community

Learning alone is absolutely fine but finding learning partners might be a nice thing, too. Our learning community is a great place to learn and grow together - of course it's 100% free and optional!

7
About This Course & Course Outline
8
The Two Ways (Paths) Of Taking This Course
9
Getting The Most Out Of This Course
10
Setting Up The Course Dev Environment (Code Editor)

JavaScript Refresher

1
Module Introduction

Let me introduce you to this module and to what you're going to learn in it.

2
Understanding "let" and "const"

One important next-gen feature you're going to see a lot is the usage of "const" and "let" instead of "var". What's up with these keywords? This lecture answers the question.

3
Arrow Functions

Arrow functions are another key next-gen feature we'll heavily use in this course. Let's dive into how to write them and how to use them in this lecture.

4
Exports and Imports

We'll write modular code in this course. That means, that the code will be split up across multiple files. In order to connect these files correctly, we'll need imports and exports. So let's dive into that feature in this lecture.

5
Understanding Classes

The "class" keyword is another new feature you'll see quite a bit in this course. Learn what it's about in this lecture.

6
Classes, Properties and Methods

Classes may have properties and methods. There actually are different ways of defining these. Let's dive into the details in this lecture.

7
The Spread & Rest Operator

React also makes heavy usage of the "Spread" operator. Or React projects do, to be precise. Learn more about that new operator in this lecture.

8
Destructuring

Time to destructure! It's a new JavaScript feature and it allows you to ... do what? Let's explore the feature in this lecture.

9
Reference and Primitive Types Refresher

Not next-gen but super important: Knowing the difference between reference and primitive types. This lecture will explore both.

10
Refreshing Array Functions

We'll use a lot of array functions in this course. They're not next-gen but you need to feel confident working with them. So let's explore them in this lecture.

11
Wrap Up

Let me wrap this module up and summarize what we learned thus far.

12
Next-Gen JavaScript - Summary

Have a look at this lecture to get a good overview over the various next-gen JS features you'll encounter in this course.

13
JS Array Functions

Here's something we'll also use quite a bit in this course: Some JavaScript array functions.

React Basics & Working With Components

1
Module Introduction
2
What Are Components? And Why Is React All About Them?
3
React Code Is Written In A "Declarative Way"!
4
A Note About New React Projects & NodeJS
5
Creating a new React Project
6
The Starting Project
7
Analyzing a Standard React Project
8
Introducing JSX
9
How React Works
10
Building a First Custom Component
11
Writing More Complex JSX Code
12
Adding Basic CSS Styling
13
Outputting Dynamic Data & Working with Expressions in JSX
14
Passing Data via "props"
15
Adding "normal" JavaScript Logic to Components
16
Splitting Components Into Multiple Components
17
Time to Practice: React & Component Basics
18
The Concept of "Composition" ("children props")
19
A First Summary
20
A Closer Look At JSX
21
Organizing Component Files
22
An Alternative Function Syntax
23
Learning Check: React Basics, Components, Props & JSX

In this course module, you learned about key React features which you must know for every React app you're going to build! Hence it's time to check what you learned and verify that we're all on the same page!

24
Module Resources

React State & Working with Events

1
Module Introduction
2
Listening to Events & Working with Event Handlers
3
How Component Functions Are Executed
4
Working with "State"
5
A Closer Look at the "useState" Hook
6
State can be updated in many ways!
7
Adding Form Inputs
8
Listening to User Input
9
Working with Multiple States
10
Using One State Instead (And What's Better)
11
Updating State That Depends On The Previous State
12
Handling Form Submission
13
Adding Two-Way Binding
14
Child-to-Parent Component Communication (Bottom-up)
15
Lifting The State Up
16
Time to Practice: Working with Events & State
17
Controlled vs Uncontrolled Components & Stateless vs Stateful Components
18
Learning Check: Working with Events & State
19
Module Resources

Rendering Lists & Conditional Content

1
Module Introduction
2
Rendering Lists of Data
3
Using Stateful Lists
4
Understanding "Keys"
5
Time to Practice: Working with Lists
6
Outputting Conditional Content
7
Adding Conditional Return Statements
8
Time to Practice: Conditional Content
9
Demo App: Adding a Chart
10
Adding Dynamic Styles
11
Wrap Up & Next Steps
12
Fixing a Small Bug
13
Learning Check: Outputting Lists & Conditional Content
14
Module Resources

Styling React Components

1
Module Introduction
2
Setting Dynamic Inline Styles
3
Setting CSS Classes Dynamically
4
Introducing Styled Components
5
Styled Components & Dynamic Props
6
Styled Components & Media Queries
7
Using CSS Modules
8
Dynamic Styles with CSS Modules
9
Module Resources

Debugging React Apps

1
Module Introduction
2
Understanding React Error Messages
3
Analyzing Code Flow & Warnings
4
Working with Breakpoints
5
Using the React DevTools
6
Module Resources

Time to Practice: A Complete Practice Project

1
Module Introduction
2
Adding a "User" Component
3
Adding a re-usable "Card" Component
4
Adding a re-usable "Button" Component
5
Managing the User Input State
6
Adding Validation & Resetting Logic
7
Adding a Users List Component
8
Managing a List Of Users via State
9
Adding The "ErrorModal" Component
10
Managing the Error State
11
Module Resources

Diving Deeper: Working with Fragments, Portals & "Refs"

1
Module Introduction
2
JSX Limitations & Workarounds
3
Creating a Wrapper Component
4
React Fragments
5
Introducing React Portals
6
Working with Portals
7
Working with "ref"s
8
Controlled vs Uncontrolled Components
9
Module Resources

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

1
Module Introduction
2
What are "Side Effects" & Introducing useEffect
3
Using the useEffect() Hook
4
useEffect & Dependencies
5
What to add & Not to add as Dependencies
6
Using the useEffect Cleanup Function
7
useEffect Summary
8
Introducing useReducer & Reducers In General
9
Using the useReducer() Hook
10
useReducer & useEffect
11
Adding Nested Properties As Dependencies To useEffect
12
useReducer vs useState for State Management
13
Introducing React Context (Context API)
14
Using the React Context API
15
Tapping Into Context with the useContext Hook
16
Making Context Dynamic
17
Building & Using a Custom Context Provider Component
18
React Context Limitations
19
Learning the "Rules of Hooks"
20
Refactoring an Input Component
21
Diving into "Forward Refs"
22
Module Resources

Practice Project: Building a Food Order App

1
Module Introduction
2
Starting Setup
3
Adding a "Header" Component
4
Adding the "Cart" Button Component
5
Adding a "Meals" Component
6
Adding Individual Meal Items & Displaying Them
7
Adding a Form
8
Fixing Form Input IDs
9
Working on the "Shopping Cart" Component
10
Adding a Modal via a React Portal
11
Managing Cart & Modal State
12
Adding a Cart Context
13
Using the Context
14
Adding a Cart Reducer
15
Working with Refs & Forward Refs
16
Outputting Cart Items
17
Working on a More Complex Reducer Logic
18
Making Items Removable
19
Using the useEffect Hook
20
Module Resources

A Look Behind The Scenes Of React & Optimization Techniques

1
Module Introduction
2
How React Really Works
3
Component Updates In Action
4
A Closer Look At Child Component Re-Evaluation
5
Preventing Unnecessary Re-Evaluations with React.memo()
6
Preventing Function Re-Creation with useCallback()
7
useCallback() and its Dependencies
8
A First Summary
9
A Closer Look At State & Components
10
Understanding State Scheduling & Batching
11
Optimizing with useMemo()
12
Module Resources

An Alternative Way Of Building Components: Class-based Components

1
Module Introduction
2
What & Why
3
Adding a First Class-based Component
4
Working with State & Events
5
The Component Lifecycle (Class-based Components Only!)
6
Lifecycle Methods In Action
7
Class-based Components & Context
8
Class-based vs Functional Components: A Summary
9
Introducing Error Boundaries
10
Module Resources

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

1
Module Introduction
2
How To (Not) Connect To A Database
3
Using the Star Wars API
4
Our Starting App & Backend
5
Sending a GET Request
6
Using async / await
7
Handling Loading & Data States
8
Handling Http Errors
9
Using useEffect() For Requests
10
Preparing The Project For The Next Steps
11
Sending a POST Request
12
Wrap Up
13
Module Resources

Building Custom React Hooks

1
Module Introduction
2
What are "Custom Hooks"?
3
Creating a Custom React Hook Function
4
Using Custom Hooks
5
Configuring Custom Hooks
6
Onwards To A More Realistic Example
7
Building a Custom Http Hook
8
Using the Custom Http Hook
9
Adjusting the Custom Hook Logic
10
Using The Custom Hook In More Components
11
Module Resources

Working with Forms & User Input

1
Module Introduction
2
Our Starting Setup
3
What's So Complex About Forms?
4
Dealing With Form Submission & Getting User Input Values
5
Adding Basic Validation
6
Providing Validation Feedback
7
Handling the "was touched" State
8
React To Lost Focus
9
Refactoring & Deriving States
10
Managing The Overall Form Validity
11
Time to Practice: Forms
12
Adding A Custom Input Hook
13
Re-Using The Custom Hook
14
A Challenge For You!
15
Applying Our Hook & Knowledge To A New Form
16
Summary
17
Bonus: Using useReducer()
18
Module Resources

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

1
Module Introduction
2
Moving "Meals" Data To The Backend
3
Fetching Meals via Http
4
Handling the Loading State
5
Handling Errors
6
Adding A Checkout Form
7
Reading Form Values
8
Adding Form Validation
9
Submitting & Sending Cart Data
10
Adding Better User Feedback
11
Summary
12
Module Resources

Diving into Redux (An Alternative To The Context API)

1
Module Introduction
2
Another Look At State In React Apps
3
Redux vs React Context
4
How Redux Works
5
Exploring The Core Redux Concepts
6
More Redux Basics
7
Preparing a new Project
8
Creating a Redux Store for React
9
Providing the Store
10
Using Redux Data in React Components
11
Dispatching Actions From Inside Components
12
Redux with Class-based Components
13
Attaching Payloads to Actions
14
Working with Multiple State Properties
15
How To Work With Redux State Correctly
16
Redux Challenges & Introducing Redux Toolkit
17
Adding State Slices
18
Connecting Redux Toolkit State
19
Migrating Everything To Redux Toolkit
20
Working with Multiple Slices
21
Reading & Dispatching From A New Slice
22
Splitting Our Code
23
Summary
24
Module Resources

Advanced Redux

1
Module Introduction
2
Redux & Side Effects (and Asynchronous Code)
3
Refresher / Practice: Part 1/2
4
Refresher / Practice: Part 2/2
5
Redux & Async Code
6
Frontend Code vs Backend Code
7
Where To Put Our Logic
8
Using useEffect with Redux
9
A Problem with useEffect()
10
Handling Http States & Feedback with Redux
11
Using an Action Creator Thunk
12
Getting Started with Fetching Data
13
Finalizing the Fetching Logic
14
Exploring the Redux DevTools
15
Summary
16
Module Resources

Building a Multi-Page SPA with React Router

1
Module Introduction
2
What is Routing & Why?
3
Installing React Router
4
Defining & Using Routes
5
Working with Links
6
Using NavLinks
7
Adding Dynamic Routes with Params
8
Extracting Route Params
9
Using "Switch" and "exact" For Configuring Routes
10
Working with Nested Routes
11
Redirecting The User
12
Time to Practice: Onwards to a New Project
13
Practice Redirecting & Extracting Params
14
Practicing Nested Routes
15
Adding a Layout Wrapper Component
16
Adding Dummy Data & More Content
17
Outputting Data on the "Details" Page
18
Adding a "Not Found" Page
19
Implementing Programmatic (Imperative) Navigation
20
Preventing Possibly Unwanted Route Transitions with the "Prompt" Component
21
Working with Query Parameters
22
Getting Creative With Nested Routes
23
Writing More Flexible Routing Code
24
Sending & Getting Quote Data via Http
25
Adding the "Comments" Features
26
Upgrading To React Router v6
27
Module Resources

Deploying React Apps

1
Module Introduction
2
Deployment Steps
3
Adding Lazy Loading
4
Building The Code For Production
5
Getting Started With Deployment (Uploading Files)
6
Exploring Routing Issues & Finishing Deployment
7
Module Resources

Adding Authentication To React Apps

1
Module Introduction
2
What, How & Why?
3
More on "Authentication Tokens"
4
Starting Setup & First Steps
5
Adding User Signup
6
Showing Feedback To The User
7
Adding User Login
8
Managing The Auth State With Context
9
Using The Token For Requests To Protected Resources
10
Redirecting The User
11
Adding Logout
12
Protecting Frontend Pages
13
Persisting The User Authentication Status
14
Adding Auto-Logout
15
Finishing Steps
16
Module Resources

A (Pretty Deep Dive) Introduction to Next.js

1
Module Introduction
2
What is NextJS?
3
Key Feature 1: Built-in Server-side Rendering (Improved SEO!)
4
Key Feature 2: Simplified Routing with File-based Routing
5
Key Feature 3: Build Fullstack Apps
6
Creating a New Next.js Project & App
7
Analyzing the Created Project
8
Adding First Pages
9
Adding Nested Paths & Pages (Nested Routes)
10
Creating Dynamic Pages (with Parameters)
11
Extracting Dynamic Parameter Values
12
Linking Between Pages
13
Onwards to a bigger Project!
14
Preparing the Project Pages
15
Outputting a List of Meetups
16
Adding the New Meetup Form
17
The "_app.js" File & Layout Wrapper
18
Using Programmatic (Imperative) Navigation
19
Adding Custom Components & CSS Modules
20
How Pre-rendering Works & Which Problem We Face
21
Data Fetching for Static Pages
22
More on Static Site Generation (SSG)
23
Exploring Server-side Rendering (SSR) with "getServerSideProps"
24
Working with Params for SSG Data Fetching
25
Preparing Paths with "getStaticPaths" & Working With Fallback Pages
26
Introducing API Routes
27
Working with MongoDB
28
Sending Http Requests To Our API Routes
29
Getting Data From The Database
30
Getting Meetup Details Data & Preparing Pages
31
Adding "head" Metadata
32
Deploying Next.js Projects
33
Using Fallback Pages & Re-deploying
34
Summary
35
Module Resources

Animating React Apps

1
Module Introduction
2
Preparing the Demo Project
3
Using CSS Transitions

We already have some tools for animating elements - CSS! Learn how to use CSS Transitions in this lecture.

4
Using CSS Animations

CSS Transitions are nice, but we also have CSS Animations. Learn how these work in this lecture.

5
CSS Transition & Animations Limitations

CSS Transitions and Animations allow us to do a lot of things. Let's find out what some potential limitations are though.

6
Using ReactTransitionGroup

Let's leave vanilla CSS and see which tools React (or some third-party package) offers us when it comes to animating React elements.

7
Using the Transition Component

Let's dive into the <Transition> component - the core component of the ReactTransitionGroup package.

8
Wrapping the Transition Component

You may also use the <Transition> inside other components - as a root element there. Learn how that works in this lecture.

9
Animation Timings

Thus far, we used a number as a timing. You have more flexibility than that though - learn how to finetune the timing to your needs.

10
Transition Events

The <Transition> component also exposes some events you can listen to - learn which these are and how that works.

11
The CSSTransition Component

Sometimes, you want an easier way of adding animations. In this lecture, we'll dive into the CSSTransition component - a nice and easy-to-use alternative.

12
Customizing CSS Classnames

When working with the <CSSTransition> component, you can also pick your own classnames. Learn how that works in this lecture.

13
Animating Lists

Thus far, we animated single elements. In this lecture, we'll dive into animating lists.

14
Alternative Animation Packages

ReactTransitionGroup is not the only animation package you may use. Learn about some alternatives in this lecture.

15
Wrap Up

Let me wrap this module up and summarize what we learned.

16
Module Resources

Replacing Redux with React Hooks

1
Module Introduction
2
React 18 & This Section
3
Starting Project & Why You Would Replace Redux
4
Alternative: Using the Context API
5
Toggling Favorites with the Context API
6
Context API Summary (and why NOT to use it instead of Redux)
7
Getting Started with a Custom Hook as a Store
8
Finishing the Store Hook
9
Creating a Concrete Store
10
Using the Custom Store
11
Custom Hook Store Summary
12
Optimizing the Custom Hook Store
13
Bonus: Managing Multiple State Slices with the Custom Store Hook
14
Wrap Up
15
Module Resources

Testing React Apps (Unit Tests)

1
Module Introduction
2
What & Why?
3
Understanding Different Kinds Of Tests
4
What To Test & How To Test
5
Understanding the Technical Setup & Involved Tools
6
Running a First Test
7
Writing Our First Test
8
Grouping Tests Together With Test Suites
9
Testing User Interaction & State
10
Testing Connected Components
11
Testing Asynchronous Code
12
Working With Mocks
13
Summary & Further Resources
14
Module Resources

React + TypeScript

1
Module Introduction
2
What & Why?
3
Installing & Using TypeScript
4
Exploring the Base Types
5
Working with Array & Object Types
6
Understanding Type Inference
7
Using Union Types
8
Understanding Type Aliases
9
Functions & Function Types
10
Diving Into Generics
11
A Closer Look At Generics
12
Creating a React + TypeScript Project
13
Working with Components & TypeScript
14
Working with Props & TypeScript
15
Adding a Data Model
16
Time to Practice: Exercise Time!
17
Form Submissions In TypeScript Projects
18
Working with refs & useRef
19
Working with "Function Props"
20
Managing State & TypeScript
21
Adding Styling
22
Time to Practice: Removing a Todo
23
The Context API & TypeScript
24
Summary
25
Bonus: Exploring tsconfig.json
26
Module Resources

Optional: React Hooks Introduction & Summary

1
Module Introduction
2
What Are React Hooks?
3
The Starting Project
4
React 18 & This Section
5
Getting Started with useState()
6
More on useState() & State Updating
7
Array Destructuring
8
Multiple States
9
Rules of Hooks
10
Passing State Data Across Components
11
Time to Practice: Hooks Basics
12
Sending Http Requests
13
useEffect() & Loading Data
14
Understanding useEffect() Dependencies
15
More on useEffect()
16
What's useCallback()?
17
Working with Refs & useRef()
18
Cleaning Up with useEffect()
19
Deleting Ingredients
20
Loading Errors & State Batching
21
More on State Batching & State Updates
22
Understanding useReducer()
23
Using useReducer() for the Http State
24
Working with useContext()
25
Performance Optimizations with useMemo()
26
Getting Started with Custom Hooks
27
Sharing Data Between Custom Hooks & Components
28
Using the Custom Hook
29
Wrap Up
30
Module Resources

Optional: React Summary & Core Feature Walkthrough

1
Module Introduction
2
What Is React?
3
Why React?
4
Building SPAs (Single Page Applications)
5
React Alternatives
6
Creating a React Project
7
Setting Up A Code Editor
8
React 18
9
Diving Into The Created Project
10
How React Works & Understanding Components
11
More Component Work & Styling with CSS Classes
12
Building & Re-Using Another Component
13
Working with "props" & Dynamic Content
14
Handling Events
15
Adding More Components
16
Introducing State
17
Working with "Event Props" (Passing Function As Props)
18
Use The Right React Router Version
19
Adding Routing
20
Adding Links & Navigation
21
Styling with CSS Modules
22
Outputting Lists of Data
23
Adding More React Components
24
Building Wrapper Components with props.children
25
Adding a Form
26
Getting User Input & Handling Form Submission
27
Preparing the App for Http
28
Sending a POST Request
29
Navigating Programmatically
30
Getting Started with Fetching Data
31
Using the useEffect() Hook
32
Introducing React Context
33
Context Logic & Different Ways Of Updating State
34
Using Context In Components
35
More Context Usage
36
Summary
37
Module Resources

Course Roundup

1
What Now? Next Steps You Could Take!
2
Explore The React Ecosystem!
3
Finishing Thoughts
4
Bonus!

This Course Got Updated!

1
Course Update Overview, Explanation & Migration Guide
2
Course Update & Migration Guide
3
Old Course Content Download
4.7
4.7 sur 5
Notes152705

Détails des Notes

Étoiles 5
98891
Étoiles 4
43860
Étoiles 3
7988
Étoiles 2
1138
Étoiles 1
828
Suivre un cours
Paiement unique S'inscrire avec l'adhésion
Garantie de remboursement de 30 jours

Inclut

48 heures de vidéo à la demande
Accès complet à vie
Accès sur le mobile et la télévision
Certificat d'achèvement

Archive

Working hours

Monday 9:30 am - 6.00 pm
Tuesday 9:30 am - 6.00 pm
Wednesday 9:30 am - 6.00 pm
Thursday 9:30 am - 6.00 pm
Friday 9:30 am - 5.00 pm
Saturday Closed
Sunday Closed