Semaine 1 · React Débutants

JSX & Composants

Créer votre premier projet React, comprendre JSX, écrire votre premier composant fonctionnel et maîtriser les règles fondamentales.

Créer un projet Vite
Qu'est-ce que JSX
Premier composant
Règles & conventions
3 exercices pratiques
Prérequis : HTML · CSS · JavaScript de base (variables, fonctions, tableaux)
01 — Introduction

Qu'est-ce que React ?

React est une bibliothèque JavaScript créée par Facebook en 2013 pour construire des interfaces utilisateur. L'idée centrale : découper l'interface en petits morceaux réutilisables appelés composants.

React en une phrase
Construire des interfaces avec des composants

En React, une interface n'est pas un fichier HTML monolithique. C'est un assemblage de composants — chacun a son propre code, sa propre logique, et peut être réutilisé partout. Un bouton, une carte, un formulaire — tout est un composant.

🧩
Composants
Briques réutilisables
⚡
Réactif
L'écran se met à jour automatiquement
🌍
Populaire
Le plus demandé en entreprise
Créer un projet avec Vite
4 commandes pour démarrer
1
npm create vite@latest mon-projet -- --template react
Crée le dossier du projet avec tous les fichiers nécessaires
2
cd mon-projet
Entrer dans le dossier du projet
3
npm install
Installer toutes les dépendances
4
npm run dev
Lancer le serveur → ouvrir http://localhost:5173
💡
Node.js requis. Vérifiez avec node --version — il faut la version 18 ou supérieure. Téléchargeable sur nodejs.org.
Structure du projet généré
mon-projet/Structure
mon-projet/
├── src/
│   ├── App.jsx        ← votre composant principal
│   ├── App.css        ← styles de App
│   ├── main.jsx       ← point d'entrée — ne pas modifier
│   └── index.css      ← styles globaux
├── public/
│   └── vite.svg
├── index.html         ← page HTML principale
├── package.json       ← liste des dépendances
└── vite.config.js    ← configuration Vite

Vous travaillerez principalement dans le dossier src/. On crée un nouveau fichier .jsx pour chaque composant.

02 — JSX

Qu'est-ce que le JSX ?

JSX (JavaScript XML) est une extension de syntaxe qui permet d'écrire du HTML directement dans le JavaScript. C'est ce qui donne à React son côté naturel et expressif.

Sans JSX — JavaScript pur (verbeux)
{"// Créer un élément sans JSX"}
const el = React.createElement(
  'h1',
  { className: 'titre' },
  'Bonjour !'
);
{"// Très difficile à lire..."}
✓ Avec JSX — naturel et lisible
{"// Même résultat avec JSX"}
const el = (
  <h1 className="titre">
    Bonjour !
  </h1>
);
{"// On reconnaît le HTML ✓"}
💡
JSX n'est pas du HTML. C'est du JavaScript qui ressemble à du HTML. Le navigateur ne comprend pas JSX directement — Vite le transforme en JavaScript pur automatiquement. Les fichiers JSX ont l'extension .jsx.
JSX — ce qui change par rapport au HTML
HTMLJSXPourquoi
class=className=class est un mot réservé en JavaScript
for=htmlFor=for est un mot réservé en JavaScript
onclick=onClick=Attributs en camelCase en JSX
style="color:red"style={{ color: 'red' }}Style est un objet JS en JSX
<br><br />Toutes les balises doivent être fermées
<img><img />Même règle — auto-fermante
03 — Premier composant

Écrire son premier composant

Un composant React est une fonction JavaScript qui retourne du JSX. C'est tout. Une fonction, un return, du JSX. La simplicité est la force de React.

1
La structure minimale d'un composant
3 éléments : fonction + return + JSX
Bonjour.jsxComposant
{"// 1. Une fonction JavaScript (nom en PascalCase)"}
function Bonjour() {

  {"// 2. Elle retourne du JSX"}
  return (
    <div>
      <h1>Bonjour, React !</h1>
      <p>Mon premier composant.</p>
    </div>
  );
}

{"// 3. On l'exporte pour pouvoir l'utiliser ailleurs"}
export default Bonjour;
Les parenthèses après return sont nécessaires quand le JSX s'étend sur plusieurs lignes. Sans elles, JavaScript pense que le return est vide.
2
Utiliser le composant dans App.jsx
Importer et afficher comme une balise HTML
App.jsxUtilisation
{"// 1. Importer le composant"}
import Bonjour from './Bonjour';

function App() {
  return (
    <div>
      <h1>Mon application</h1>

      {"// 2. Utiliser comme une balise — majuscule obligatoire !"}
      <Bonjour />

      {"// 3. On peut l'utiliser plusieurs fois"}
      <Bonjour />
      <Bonjour />
    </div>
  );
}

export default App;
La majuscule à la première lettre est OBLIGATOIRE. React distingue les composants (majuscule → <Bonjour />) des éléments HTML natifs (minuscule → <div>). Sans majuscule, React cherchera un élément HTML nommé "bonjour" qui n'existe pas.
3
Composant avec des données — variables JS
Mélanger JavaScript et JSX avec les accolades { }
CarteEtudiant.jsxDonnées
function CarteEtudiant() {
  {"// Variables JavaScript dans le composant"}
  const nom     = 'Fatou Diallo';
  const filiere = 'Informatique';
  const note    = 17;
  const annee   = new Date().getFullYear();

  return (
    <div>
      {"// { } pour insérer une expression JS dans le JSX"}
      <h2>{nom}</h2>
      <p>Filière : {filiere}</p>
      <p>Note : {note}/20</p>
      <p>Promo {annee}</p>
      <p>Mention : {note >= 16 ? 'Très bien' : 'Bien'}</p>
    </div>
  );
}
04 — Règles JSX

Les règles fondamentales du JSX

JSX a des règles strictes. Les ignorer produit des erreurs incompréhensibles. Voici les 4 règles à connaître absolument.

Règle 1 — Un seul élément racine
Le return ne peut retourner qu'un seul élément parent
✗ Deux éléments racines — erreur
return (
  {"// ❌ Deux éléments au même niveau"}
  <h1>Titre</h1>
  <p>Texte</p>
);
✓ Enveloppé dans un div ou Fragment
return (
  {"// ✓ Un seul élément parent"}
  <div>
    <h1>Titre</h1>
    <p>Texte</p>
  </div>
);
💡
Astuce — Fragment : si vous ne voulez pas de div supplémentaire dans le DOM, utilisez <>...</> (Fragment vide). Ça regroupe les éléments sans créer de balise HTML.
return (
  <>  {"← Fragment — invisible dans le DOM"}
    <h1>Titre</h1>
    <p>Texte</p>
  </>
);
Règle 2 — Toutes les balises fermées
En JSX, chaque balise doit être fermée — y compris les auto-fermantes HTML
✗ Balises non fermées — erreur
{"// ❌ Valide en HTML, interdit en JSX"}
<img src="photo.jpg">
<br>
<input type="text">
<hr>
✓ Auto-fermées avec /
{"// ✓ Toujours fermées en JSX"}
<img src="photo.jpg" />
<br />
<input type="text" />
<hr />
Règle 3 — className pas class
Les attributs HTML ont des équivalents JSX
attributs.jsx
{"// ❌ HTML → ✓ JSX"}
<div class="carte">     {"→"}  <div className="carte">
<label for="nom">     {"→"}  <label htmlFor="nom">

{"// Le style est un OBJET JavaScript (double accolades)"}
{"// ❌ style='color:red; font-size:16px'"}
{"// ✓"}
<p style={{ color: 'red', fontSize: '16px' }}>Texte</p>
{"//       ↑ 1ère {} = expression JS"}
{"//         ↑ 2ème {} = objet style"}
{"// camelCase pour les propriétés : font-size → fontSize"}
Règle 4 — PascalCase pour les composants
Majuscule = composant React / minuscule = élément HTML
convention.jsx
{"// Minuscule → élément HTML natif"}
<div>  <p>  <h1>  <button>

{"// Majuscule → composant React"}
<CarteEtudiant />
<Bonjour />
<App />

{"// Si on écrit en minuscule un composant React :"}
<carteEtudiant />  {"← React cherche une balise HTML 'carteetudiant' → erreur"}
05 — Expressions { }

Insérer du JavaScript avec les accolades

Les accolades { } dans le JSX permettent d'insérer n'importe quelle expression JavaScript — une variable, un calcul, un appel de fonction, un ternaire. C'est la "porte" entre JSX et JavaScript.

Tout ce qu'on peut mettre entre { }
expressions.jsxExpressions
function Exemples() {
  const nom    = 'Fatou';
  const note   = 17;
  const actif  = true;
  const items  = ['Maths', 'React', 'Node'];

  function getMention(n) {
    return n >= 16 ? 'Très bien' : 'Bien';
  }

  return (
    <div>
      {"// Variable"}
      <p>Nom : {nom}</p>

      {"// Calcul"}
      <p>Double : {note * 2}</p>

      {"// Appel de fonction"}
      <p>Mention : {getMention(note)}</p>

      {"// Ternaire (si/sinon)"}
      <p>{actif ? 'Actif' : 'Inactif'}</p>

      {"// Méthode de tableau"}
      <p>{items.join(', ')}</p>

      {"// Dans les attributs"}
      <img src={`/photos/${nom}.jpg`} alt={nom} />
    </div>
  );
}
🚨
Ce qu'on ne peut PAS mettre entre { } : les instructions JavaScript (if, for, while, switch). Les accolades JSX acceptent uniquement les expressions — des choses qui produisent une valeur. Pour les conditions, on utilise le ternaire ou &&. Pour les boucles, on utilise .map().
06 — Conventions

Nommage & conventions React

React a des conventions de nommage strictes que toute la communauté respecte. Les appliquer dès le début vous évitera des erreurs et rendra votre code lisible par n'importe quel développeur React.

Un composant par fichier — bonne pratique
organisation.txtStructure
src/
├── components/              ← composants réutilisables
│   ├── CarteEtudiant.jsx
│   ├── Navbar.jsx
│   └── BoutonValider.jsx
├── pages/                   ← pages de l'application
│   ├── Accueil.jsx
│   └── ListeEtudiants.jsx
├── App.jsx                  ← composant racine
└── main.jsx                 ← point d'entrée
07 — Structure du projet

Comprendre main.jsx et App.jsx

Deux fichiers sont au cœur de tout projet React. Comprendre leur rôle évite beaucoup de confusions au départ.

→
main.jsx — le point d'entrée
Le fichier qui "démarre" React dans la page HTML
main.jsxPoint d'entrée
import React    from 'react';
import ReactDOM from 'react-dom/client';
import App      from './App.jsx';
import          './index.css';

{"// ReactDOM.createRoot() branche React sur la div#root du HTML"}
ReactDOM
  .createRoot(document.getElementById('root'))
  .render(<App />);

{"// → Dans index.html : 
"}
{"// React prend le contrôle de cette div et affiche App"}
Ne modifiez presque jamais main.jsx. Son rôle est uniquement de "brancher" React sur la page HTML. Tout votre vrai travail se passe dans App.jsx et les composants que vous créez.
→
App.jsx — le composant racine
Votre point de départ pour construire l'interface
App.jsxRacine
{"// Importer les composants qu'on veut afficher"}
import Navbar         from './components/Navbar';
import CarteEtudiant  from './components/CarteEtudiant';

function App() {
  return (
    <div>
      <Navbar />

      <main>
        <h1>Liste des étudiants</h1>
        <CarteEtudiant />
        <CarteEtudiant />
        <CarteEtudiant />
      </main>
    </div>
  );
}

export default App;
Récapitulatif S01 — tout en un coup d'œil
ConceptSyntaxe cléÀ retenir
Composantfunction Nom() { return <jsx /> }Nom en PascalCase, un seul return
Exportexport default NomComposantToujours à la fin du fichier
Importimport Nom from './Fichier'Chemin relatif avec ./ ou ../
Utiliser<NomComposant />Comme une balise HTML, majuscule obligatoire
Expression JS{variable} ou {calcul}N'importe quelle expression, pas d'instruction
classNameclassName="ma-classe"Pas class — mot réservé JS
Élément racine<div>...</div> ou <>...</>Un seul élément parent dans le return
08 — Validation

Quiz & Travaux pratiques

4 questions pour valider la session, puis 3 exercices pratiques à réaliser dans votre projet Vite.

1. Pourquoi les composants React doivent-ils commencer par une majuscule ?
2. Lequel de ces codes JSX est valide ?
3. Comment insérer la valeur de la variable nom dans du JSX ?
4. Quel attribut utilise-t-on à la place de class en JSX ?

S01 — Travaux Pratiques · 3 exercices
Votre premier projet React
1
Créer et lancer un projet Vite
Créez un nouveau projet React avec Vite (npm create vite@latest). Installez les dépendances et lancez le serveur. Ouvrez App.jsx et supprimez tout le contenu existant. Remplacez-le par un composant simple qui affiche votre nom, votre filière et l'année en cours (avec new Date().getFullYear()). Vérifiez que votre page s'affiche correctement dans le navigateur.
2
Créer un composant CarteEtudiant
Dans le dossier src/, créez un fichier CarteEtudiant.jsx. Le composant affiche : nom, filière, note sur 20, et une mention calculée (note >= 16 → "Très bien", note >= 14 → "Bien", sinon "Passable") via un ternaire ou une fonction. Exportez le composant et importez-le dans App.jsx. Affichez-le 3 fois avec des données différentes écrites en dur dans le composant.
3
Composer une interface complète
Créez 3 composants séparés dans src/components/ : Entete.jsx (titre + sous-titre de la page), CarteEtudiant.jsx (comme l'exercice 2), PiedPage.jsx (copyright + année courante). Dans App.jsx, importez et assemblez les 3 composants pour former une page complète. Appliquez un style minimal avec className et les styles dans App.css.