Guide Complet

Les Bases
du Web

Le guide qui t'apprend a construire des sites web solides, de la premiere balise HTML jusqu'a la mise en ligne securisee

8
Chapitres
structures
48
Fondamentaux
expliques
100+
Exemples
de code
HTML · CSS · JavaScript · Responsive · Accessibilite · SEO · Outils · Securite

Sommaire

01 HTML — La structure
01Donne une ossature solide a ta pageStructurep.4
02Donne du sens a tes balisesSemantiquep.4
03Cree des formulaires qui marchentFormulairesp.5
04Organise tes donnees en tableauTableauxp.5
05Integre images, videos et sonsMultimediap.6
06Relie tes pages entre ellesLiensp.6
02 CSS — Le style
07Cible exactement ce que tu veux stylerSelecteursp.7
08Maitrise l'espace autour de chaque elementBox Modelp.7
09Aligne tes elements en une ligneFlexboxp.8
10Cree des mises en page en grilleGridp.8
11Centralise tes couleurs et valeursVariablesp.9
12Ajoute du mouvement a tes elementsTransitionsp.9
13Adapte ton design a chaque ecranResponsivep.10
03 JavaScript — L'interaction
14Stocke et manipule tes donneesVariablesp.11
15Selectionne et modifie ta page en directDOMp.11
16Reagis aux actions de l'utilisateurEventsp.12
17Echange des donnees avec un serveurFetch/APIp.12
18Sauvegarde des donnees dans le navigateurlocalStoragep.13
19Ecris du JavaScript moderne et lisibleES6+p.13
04 Responsive — L'adaptation
20Configure la fenetre mobileViewportp.14
21Designe d'abord pour le mobileMobile-firstp.14
22Definis tes points de ruptureBreakpointsp.15
23Adapte tes images a chaque ecranImagesp.15
24Rends tes boutons tactiles confortablesTouchp.16
25Teste sur de vrais appareilsTestingp.16
05 Accessibilite — L'inclusion
26Rends ta page lisible par tousHTML semantiquep.17
27Enrichis l'accessibilite avec ARIAARIAp.17
28Choisis des couleurs lisiblesContraste WCAGp.18
29Rends tout accessible au clavierClavierp.18
30Parle aux lecteurs d'ecranLecteurs d'ecranp.19
31Respecte les preferences de l'utilisateurPreferencesp.19
06 SEO & Performance — La visibilite
32Fais comprendre ta page a GoogleMeta tagsp.20
33Structure tes titres logiquementHeadingsp.20
34Obtiens un bon score de performanceCore Web Vitalsp.21
35Accelere le chargement de tes imagesOptimisation imagesp.21
36Charge les bonnes ressources en avancePreload/Prefetchp.22
37Reduis le poids de ton codeMinificationp.22
07 Outils — La productivite
38Configure ton editeur de codeVS Codep.23
39Sauvegarde chaque version de ton codeGitp.23
40Inspecte et debogue dans le navigateurDevToolsp.24
41Mets ton site en ligne gratuitementDeploiementp.24
42Choisis ton nom de domaine et hebergeurDomaine/Hostingp.25
08 Securite — La protection
43Chiffre les echanges avec HTTPSHTTPS/SSLp.26
44Controle ce que ta page peut chargerCSPp.26
45Empeche l'injection de code malveillantXSSp.27
46Protege tes formulaires contre les faux envoisCSRFp.27
47Ne fais jamais confiance aux donnees utilisateurSanitizationp.28
48Ajoute des boucliers cote navigateurHeaders securitep.28

Ce guide est fait pour toi

🚀

Du zero au site en ligne

Chaque chapitre te fait progresser etape par etape, du HTML brut jusqu'a la mise en production.

💡

Comprendre, pas juste copier

Un bloc "En clair" vulgarise chaque concept avec des analogies du quotidien.

A personnaliser

Chaque topic te dit quelles valeurs modifier et ce que ca change concretement.

Conseil

Pas besoin de tout lire d'un coup. Essentiel = a connaitre absolument. Important = fortement conseille. Utile = pour aller plus loin.

01

HTML — La structure

6 fondamentaux pour construire des pages solides et bien organisees

01
HTML · Structure
Donne une ossature solide a ta page
Essentiel
En clair : Une page HTML, c'est comme un immeuble. Tu poses d'abord les fondations (<html>), puis le toit (<head>) qui contient les infos invisibles, et enfin les pieces (<body>) ou vit le contenu visible. Sans cette structure, le navigateur ne sait pas quoi afficher ni comment.
<!DOCTYPE html> <!-- dit au navigateur : "c'est du HTML5" --> <html lang="fr"> <!-- langue de la page --> <head> <meta charset="UTF-8"> <!-- accents et caracteres speciaux --> <title>Ma page</title> <!-- titre dans l'onglet du navigateur --> </head> <body> <h1>Bienvenue</h1> <!-- contenu visible de la page --> </body> </html>
A personnaliser
  • Change lang="fr" selon la langue de ton contenu (en, es, etc.)
  • Ajoute <meta name="viewport"> pour que le mobile affiche correctement
  • Le <title> apparait dans Google : soigne-le
Mes notes
02
HTML · Semantique
Donne du sens a tes balises
Essentiel
En clair : Utiliser <div> partout, c'est comme ecrire un livre sans chapitres ni paragraphes. Le texte est la, mais personne ne s'y retrouve. Les balises semantiques (<header>, <nav>, <main>, <footer>) donnent un role a chaque zone. Google et les lecteurs d'ecran comprennent ta page sans la voir.
<header> <!-- en-tete : logo, titre du site --> <nav> <!-- navigation : liens du menu --> </header> <main> <!-- contenu principal (un seul par page) --> <article> <!-- contenu autonome : article, post --> <section> <!-- groupe thematique avec un titre --> <aside> <!-- contenu annexe : sidebar, encart --> </main> <footer> <!-- pied de page : mentions, liens -->
A personnaliser
  • Remplace tes <div> par la balise semantique qui correspond au role
  • Un seul <main> par page, c'est la regle
  • Chaque <section> doit contenir un titre (<h2>, <h3>...)
Mes notes
03
HTML · Formulaires
Cree des formulaires qui marchent
Essentiel
En clair : Un formulaire, c'est un dialogue entre ton site et le visiteur. Chaque champ (<input>) est une question, et le <label> est l'etiquette qui dit a quoi sert le champ. Sans label, c'est comme un formulaire papier sans intitule : le visiteur ne sait pas quoi ecrire ou. Le type du champ (email, tel) adapte meme le clavier sur mobile.
<form action="/envoyer" method="POST"> <label for="email">Ton email</label> <!-- etiquette cliquable --> <input type="email" <!-- clavier email sur mobile --> id="email" <!-- lie au label par le for --> required <!-- champ obligatoire --> placeholder="nom@exemple.fr"> <!-- texte d'aide grise --> <button type="submit">Envoyer</button> </form>
A personnaliser
  • Change le type selon le champ : text, email, tel, password, number
  • Ajoute required sur les champs obligatoires
  • Le placeholder guide, mais ne remplace jamais le label
Mes notes
04
HTML · Tableaux
Organise tes donnees en tableau
Important
En clair : Un tableau HTML, c'est comme un tableur Excel. Tu as des lignes (<tr>), des cellules d'en-tete (<th>) et des cellules de donnees (<td>). Le <thead> et le <tbody> separent l'en-tete du contenu, comme la premiere ligne figee dans un tableur. Utilise les tableaux pour des donnees, jamais pour la mise en page.
<table> <thead> <!-- en-tete du tableau --> <tr> <th>Nom</th> <!-- cellule d'en-tete (gras) --> <th>Prix</th> </tr> </thead> <tbody> <!-- corps du tableau --> <tr><td>Widget</td><td>9,90 EUR</td></tr> </tbody> </table>
A personnaliser
  • Ajoute border-collapse: collapse en CSS pour supprimer les doubles bordures
  • Utilise <caption> pour donner un titre accessible au tableau
  • N'utilise jamais <table> pour aligner des elements : c'est le travail de Flexbox ou Grid
Mes notes
05
HTML · Multimedia
Integre images, videos et sons
Important
En clair : Chaque media a sa balise dediee. <img> pour les images, <video> pour les videos, <audio> pour le son. C'est comme brancher le bon cable sur le bon appareil. L'attribut alt sur une image, c'est la description pour ceux qui ne la voient pas (mal-voyants, connexion lente). Et width/height reserve l'espace pour eviter que la page saute au chargement.
<!-- Image avec description et dimensions reservees --> <img src="photo.webp" alt="Coucher de soleil sur la mer" width="800" height="450" loading="lazy"> <!-- Video avec controles et sous-titres --> <video controls width="640"> <source src="demo.mp4" type="video/mp4"> <track src="sous-titres.vtt" kind="subtitles" srclang="fr"> </video>
A personnaliser
  • Utilise le format WebP pour les images (plus leger que JPEG/PNG)
  • Ajoute loading="lazy" sur les images sous la ligne de flottaison
  • Mets toujours un alt descriptif, jamais vide sauf pour les images decoratives
Mes notes
06
HTML · Liens
Relie tes pages entre elles
Essentiel
En clair : Les liens (<a>) sont les portes entre les pieces de ton site. Un lien interne mene a une autre page de ton site, un lien externe mene ailleurs sur le web. L'attribut href est l'adresse de destination. Et target="_blank" ouvre la porte dans un nouvel onglet, pour que le visiteur ne quitte pas ta page.
<!-- Lien interne (meme site) --> <a href="/contact">Contacte-nous</a> <!-- Lien externe (autre site) — securise --> <a href="https://example.com" target="_blank" <!-- nouvel onglet --> rel="noopener noreferrer"> <!-- securite : empeche l'acces a ta page --> Voir le site </a> <!-- Ancre (lien vers une section de la meme page) --> <a href="#tarifs">Voir les tarifs</a>
A personnaliser
  • Ajoute toujours rel="noopener noreferrer" sur les liens target="_blank"
  • Utilise des textes de lien descriptifs : "Voir les tarifs" plutot que "Cliquer ici"
  • Les ancres (#section) necessitent un id="section" sur l'element cible
Mes notes
02

CSS — Le style

7 fondamentaux pour habiller et mettre en page ton contenu HTML

07
CSS · Selecteurs
Cible exactement ce que tu veux styler
Essentiel
En clair : Un selecteur CSS, c'est l'adresse postale de ton element. Plus tu es precis, plus tu cibles exactement la bonne boite aux lettres. p cible tous les paragraphes. .intro cible les elements avec la classe "intro". #hero cible l'element unique avec cet identifiant. Tu peux combiner pour etre ultra-precis.
p { color: gray; } /* tous les paragraphes */ .intro { font-size: 1.2rem; } /* elements avec class="intro" */ #hero { background: #6366f1; } /* l'element avec id="hero" */ .card h2 { color: navy; } /* les h2 a l'interieur d'une .card */ .btn:hover { opacity: 0.8; } /* au survol de la souris */ input:focus { outline: 2px solid blue; } /* quand le champ est actif */
A personnaliser
  • Prefere les classes (.nom) aux IDs (#nom) pour la reutilisabilite
  • Evite les selecteurs trop longs (div.main ul li a) : plus c'est simple, mieux c'est
  • Les pseudo-classes :hover, :focus, :first-child evitent d'ajouter des classes inutiles
Mes notes
08
CSS · Box Model
Maitrise l'espace autour de chaque element
Essentiel
En clair : Chaque element HTML est comme un colis. Il y a le contenu (l'objet), le padding (le papier bulle autour de l'objet), la border (le carton) et le margin (l'espace entre les colis sur l'etagere). Par defaut, le navigateur ajoute padding et border en plus de la taille. Avec box-sizing: border-box, tout est inclus dans la taille que tu definis.
/* Indispensable : inclut padding et border dans la taille */ * { box-sizing: border-box; } .carte { width: 300px; /* largeur totale = 300px, point final */ padding: 20px; /* espace interieur (papier bulle) */ border: 2px solid #ddd; /* bordure (carton) */ margin: 16px; /* espace exterieur (entre les colis) */ }
A personnaliser
  • Mets toujours * { box-sizing: border-box; } en haut de ton CSS
  • Utilise padding pour l'espace a l'interieur, margin pour l'espace a l'exterieur
  • Astuce : margin: 0 auto centre horizontalement un element avec une largeur fixe
Mes notes
09
CSS · Flexbox
Aligne tes elements en une ligne
Essentiel
En clair : Imagine une etagere. Tu poses des objets dessus, et tu decides : les coller a gauche, les centrer, ou les espacer regulierement. Flexbox fait pareil avec tes elements HTML. Tu dis au parent "deviens une etagere" avec display: flex, puis tu choisis comment repartir les enfants avec justify-content (horizontal) et align-items (vertical).
.menu { display: flex; /* active l'etagere */ justify-content: space-between; /* espace egal entre les elements */ align-items: center; /* aligne verticalement au milieu */ gap: 16px; /* espace fixe entre chaque element */ } /* Valeurs courantes de justify-content : flex-start | center | flex-end | space-between | space-around */
A personnaliser
  • Change justify-content : center pour centrer, space-between pour espacer
  • Ajoute flex-wrap: wrap pour que les elements passent a la ligne si l'espace manque
  • Utilise gap plutot que des margins sur les enfants : plus propre et plus previsible
Mes notes
10
CSS · Grid
Cree des mises en page en grille
Essentiel
En clair : Si Flexbox est une etagere (une dimension), Grid est un damier (deux dimensions). Tu definis des colonnes et des lignes, puis tu places tes elements dans les cases. C'est comme un plan d'architecte : tu dessines la grille d'abord, tu poses les meubles ensuite. Ideal pour les mises en page complexes avec header, sidebar, contenu et footer.
.page { display: grid; /* 3 colonnes : la 2e prend l'espace restant */ grid-template-columns: 250px 1fr 250px; gap: 20px; /* espace entre les cases */ } /* 1fr = 1 fraction de l'espace restant */ /* repeat(3, 1fr) = 3 colonnes egales */
A personnaliser
  • Change le nombre de colonnes : repeat(3, 1fr) pour 3 colonnes egales
  • Utilise minmax(250px, 1fr) pour des colonnes flexibles avec une taille minimum
  • Pour les galeries : grid-template-columns: repeat(auto-fill, minmax(200px, 1fr))
Mes notes
11
CSS · Variables
Centralise tes couleurs et valeurs
Important
En clair : Imagine que tu peins un appartement. Si tu ecris la reference de couleur sur chaque mur, changer d'avis te force a tout repeindre. Mais si tu etiquettes un pot "couleur principale" et que tout le monde pioche dedans, il suffit de changer le pot. Les variables CSS (--nom) fonctionnent pareil : une valeur definie une fois, utilisee partout.
/* On definit les "pots de peinture" une seule fois */ :root { --couleur: #6366f1; /* violet — change ici, ca change partout */ --texte: #1a1a2e; /* couleur du texte */ --radius: 12px; /* coins arrondis */ --espace: 16px; /* espacement standard */ } .bouton { background: var(--couleur); border-radius: var(--radius); }
A personnaliser
  • Remplace les valeurs en dur par des var(--nom) partout dans ton CSS
  • Cree des variables pour : couleurs, espacements, arrondis, ombres
  • Pour un mode sombre, redeclare les variables dans @media (prefers-color-scheme: dark)
Mes notes
12
CSS · Transitions
Ajoute du mouvement a tes elements
Important
En clair : Sans transition, un changement de style est instantane : le bouton est bleu, puis d'un coup il est violet. Avec transition, tu ajoutes un fondu entre les deux etats. C'est comme un variateur de lumiere au lieu d'un interrupteur. Tu choisis ce qui change, en combien de temps, et avec quel rythme (lent au debut, rapide a la fin, etc.).
.bouton { background: #6366f1; color: white; /* transition : quoi | duree | courbe de vitesse */ transition: background 0.3s ease, transform 0.3s ease; } .bouton:hover { background: #4f46e5; /* violet plus fonce */ transform: translateY(-2px); /* monte legerement */ }
A personnaliser
  • Change la duree : 0.2s pour rapide, 0.5s pour lent et elegant
  • Utilise ease-out pour des animations naturelles (rapide au debut, lent a la fin)
  • N'anime que transform et opacity pour des performances optimales
Mes notes
13
CSS · Responsive
Adapte ton design a chaque ecran
Essentiel
En clair : Un site responsive, c'est comme un meuble modulable qui s'adapte a la taille de la piece. Les media queries (@media) sont des regles conditionnelles : "si l'ecran fait moins de 768px, empile les colonnes". Tu ecris d'abord le design mobile (le plus petit), puis tu ajoutes des regles pour les ecrans plus grands. C'est le principe "mobile first".
/* Base = mobile (petit ecran) */ .grille { display: grid; grid-template-columns: 1fr; /* 1 colonne sur mobile */ gap: 16px; } /* Tablette : a partir de 768px */ @media (min-width: 768px) { .grille { grid-template-columns: 1fr 1fr; } /* 2 colonnes */ } /* Desktop : a partir de 1024px */ @media (min-width: 1024px) { .grille { grid-template-columns: repeat(3, 1fr); } /* 3 colonnes */ }
A personnaliser
  • Breakpoints courants : 640px (mobile), 768px (tablette), 1024px (desktop)
  • Utilise min-width (mobile first) plutot que max-width
  • Teste toujours dans les DevTools (F12) en redimensionnant la fenetre
Mes notes
03

JavaScript — L'interaction

6 fondamentaux pour rendre tes pages dynamiques et interactives

14
JavaScript · Variables
Stocke et manipule tes donnees
Essentiel
En clair : Une variable, c'est une boite avec une etiquette. Tu y ranges une valeur (un nom, un chiffre, une liste). let cree une boite modifiable. const cree une boite verrouillee. Les types (texte, nombre, booleen) definissent ce que la boite peut contenir. Sans variables, impossible de retenir quoi que ce soit dans ton programme.
const nom = "Alice"; // texte (string) — ne changera pas let age = 25; // nombre (number) — peut changer let estConnecte = true; // booleen (true/false) const fruits = ["pomme", "poire"]; // tableau (array) const user = { nom: "Alice", age: 25 }; // objet age = 26; // let permet de modifier la valeur console.log(user.nom); // affiche "Alice" dans la console
A personnaliser
  • Utilise const par defaut, let seulement si la valeur doit changer
  • Nomme tes variables clairement : totalPrix plutot que x
  • Evite var : c'est l'ancienne syntaxe, moins fiable que let/const
Mes notes
15
JavaScript · DOM
Selectionne et modifie ta page en direct
Essentiel
En clair : Ta page HTML est un arbre. Chaque branche est un element. Cet arbre s'appelle le DOM (Document Object Model, c'est la version en memoire de ta page). JavaScript peut secouer cet arbre : ajouter des branches, en couper, changer les feuilles. C'est ca, manipuler le DOM. Tu selectionnes un element avec querySelector, puis tu modifies son texte, son style ou ses attributs. Tout se passe en direct, sans recharger la page.
// Selectionner un element const titre = document.querySelector('.titre'); // par classe const btn = document.querySelector('#valider'); // par id // Modifier le contenu et le style titre.textContent = "Nouveau titre"; // change le texte titre.style.color = "#6366f1"; // change la couleur titre.classList.add("visible"); // ajoute une classe CSS
A personnaliser
  • Prefere querySelector (selecteur CSS) a getElementById
  • Utilise textContent (securise) plutot que innerHTML (risque XSS)
  • Manipule les classes avec classList.add/remove/toggle plutot que le style inline
Mes notes
16
JavaScript · Events
Reagis aux actions de l'utilisateur
Essentiel
En clair : Un evenement, c'est quelque chose qui se passe : un clic, une touche pressee, un scroll. addEventListener dit a JavaScript : "quand ca arrive, execute cette action". C'est comme un detecteur de mouvement : tu le places, et il reagit tout seul quand quelqu'un passe. Sans evenements, ta page est une affiche figee.
const btn = document.querySelector('#envoyer'); // Ecoute le clic sur le bouton btn.addEventListener('click', () => { alert('Formulaire envoye !'); // action declenchee au clic }); // Ecoute une touche du clavier (sur toute la page) document.addEventListener('keydown', (e) => { console.log('Touche :', e.key); // affiche la touche pressee });
A personnaliser
  • Evenements courants : click, submit, input, keydown, scroll
  • Utilise addEventListener (propre) plutot que onclick dans le HTML
  • Ajoute e.preventDefault() pour empecher le comportement par defaut (ex: envoi de formulaire)
Mes notes
17
JavaScript · Fetch/API
Echange des donnees avec un serveur
Important
En clair : fetch, c'est le facteur de ton site. Il va chercher des donnees sur un serveur via une API (un guichet de donnees sur un serveur) et te les rapporte. La reponse arrive au format JSON : un texte structure que JavaScript comprend nativement. C'est comme ca que ton site affiche la meteo, charge des articles ou envoie un formulaire sans recharger la page.
// Recuperer des donnees depuis une API const response = await fetch('https://api.exemple.fr/users'); const users = await response.json(); // convertit le JSON en objet JS console.log(users); // [{nom: "Alice"}, ...] // Envoyer des donnees (POST) await fetch('/api/contact', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ nom: "Alice" }) // objet JS → texte JSON });
A personnaliser
  • Verifie toujours response.ok avant de lire les donnees (gestion d'erreur)
  • Utilise async/await (lisible) plutot que .then() (enchainage)
  • Teste tes API avec les DevTools (onglet Network) pour voir les requetes
Mes notes
18
JavaScript · localStorage
Sauvegarde des donnees dans le navigateur
Utile
En clair : C'est un tiroir dans le navigateur. Tu y ranges des infos (theme sombre, panier, preferences). Elles restent meme apres avoir ferme le navigateur. Contrairement aux cookies, ces donnees ne partent jamais vers le serveur. C'est du stockage local, simple et gratuit. Parfait pour retenir les choix du visiteur sans base de donnees.
// Sauvegarder une valeur localStorage.setItem('theme', 'sombre'); // cle → valeur (texte) // Lire une valeur const theme = localStorage.getItem('theme'); // retourne "sombre" // Stocker un objet (convertir en JSON d'abord) const prefs = { theme: 'sombre', lang: 'fr' }; localStorage.setItem('prefs', JSON.stringify(prefs)); // Relire l'objet const saved = JSON.parse(localStorage.getItem('prefs'));
A personnaliser
  • Limite : ~5 Mo par domaine. Ne stocke pas de fichiers lourds
  • Utilise sessionStorage si tu veux que les donnees disparaissent a la fermeture de l'onglet
  • Ne stocke jamais de mots de passe ou de tokens sensibles dans localStorage
Mes notes
19
JavaScript · ES6+
Ecris du JavaScript moderne et lisible
Important
En clair : ES6, c'est la version moderne de JavaScript (sortie en 2015). Avant, le code etait verbeux et dur a lire. Les fleches (=>) raccourcissent les fonctions. Le destructuring extrait les valeurs d'un objet en une ligne. Les template literals (`...`) permettent d'inserer des variables dans du texte. C'est plus propre, plus court, plus lisible.
// Fonction flechee (au lieu de function) const saluer = (nom) => `Salut ${nom} !`; // template literal // Destructuring : extraire des valeurs const { nom, age } = user; // au lieu de user.nom, user.age // Spread : fusionner des objets/tableaux const newUser = { ...user, role: "admin" }; // copie + ajout // Optional chaining : eviter les erreurs const ville = user?.adresse?.ville; // undefined si manquant
A personnaliser
  • Adopte les fleches => pour les callbacks courts (map, filter, forEach)
  • Utilise les backticks `texte ${variable}` au lieu de la concatenation +
  • Le ?. (optional chaining) evite les crashs quand une donnee est absente
Mes notes
04

Responsive & Mobile — L'adaptation

6 fondamentaux pour que ton site s'affiche parfaitement sur tous les ecrans

20
Responsive · Viewport
Configure la fenetre mobile
Essentiel
En clair : Le viewport, c'est la taille de l'ecran visible. Sans cette balise meta, le mobile affiche ta page en version bureau miniature. Illisible. Cette seule ligne dit au navigateur : "adapte la largeur a l'ecran du telephone". C'est la toute premiere chose a mettre dans le <head> de chaque page. Sans elle, aucun design responsive ne fonctionne.
<!-- Dans le <head> de CHAQUE page HTML --> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <!-- width=device-width → largeur = ecran reel --> <!-- initial-scale=1.0 → pas de zoom initial --> <!-- SANS cette balise : le mobile affiche 980px de large --> <!-- AVEC cette balise : le mobile affiche 375px (sa vraie taille) -->
A personnaliser
  • Ne jamais ajouter maximum-scale=1 : ca empeche le zoom accessibilite
  • Place cette balise juste apres <meta charset="UTF-8">
  • Verifie dans les DevTools (mode responsive) que ta page s'adapte bien
Mes notes
21
Responsive · Mobile-first
Designe d'abord pour le mobile
Essentiel
En clair : Mobile-first, c'est construire ta maison en commencant par le studio. Tu dessines d'abord pour le plus petit ecran (mobile), puis tu ajoutes de l'espace et des colonnes pour les grands ecrans. C'est plus simple que l'inverse : ajouter est facile, retirer est penible. Et 60% du trafic web est mobile aujourd'hui.
/* CSS de base = mobile (pas de media query) */ .container { padding: 16px; font-size: 14px; /* taille lisible sur petit ecran */ } /* On AJOUTE des regles pour les grands ecrans */ @media (min-width: 768px) { /* tablette et plus */ .container { max-width: 720px; margin: 0 auto; } }
A personnaliser
  • Ecris toujours le CSS mobile en premier (hors media query)
  • Utilise min-width pour ajouter progressivement (pas max-width)
  • Teste en reduisant la fenetre : si ca casse, c'est pas mobile-first
Mes notes
22
Responsive · Breakpoints
Definis tes points de rupture
Important
En clair : Un breakpoint, c'est la taille d'ecran ou ton design change de forme. Comme une porte pliante : a partir d'une certaine largeur, elle se deplie. Tu n'as pas besoin de 15 breakpoints. Trois suffisent : mobile, tablette, desktop. Choisis-les en fonction de ton contenu, pas d'un modele de telephone precis.
/* 3 breakpoints suffisent pour 95% des sites */ /* Mobile : 0 - 639px (pas de media query = CSS de base) */ /* Tablette : a partir de 640px */ @media (min-width: 640px) { .grid { grid-template-columns: 1fr 1fr; } } /* Desktop : a partir de 1024px */ @media (min-width: 1024px) { .grid { grid-template-columns: repeat(3, 1fr); } }
A personnaliser
  • Breakpoints classiques : 640px, 768px, 1024px, 1280px
  • Ajoute un breakpoint seulement quand le contenu le demande (pas systematiquement)
  • Utilise les DevTools pour trouver ou ton design "casse" naturellement
Mes notes
23
Responsive · Images
Adapte tes images a chaque ecran
Important
En clair : Envoyer une image 4K a un telephone, c'est comme livrer un canape par helicoptere. Ca marche, mais c'est du gaspillage. srcset donne au navigateur une liste de tailles. Il choisit la plus adaptee a l'ecran. Le format WebP est 30% plus leger que le JPEG. Resultat : des pages plus rapides, surtout sur la 4G.
<!-- Le navigateur choisit l'image selon la largeur d'ecran --> <img src="photo-800.webp" srcset="photo-400.webp 400w, photo-800.webp 800w, photo-1200.webp 1200w" sizes="(max-width: 640px) 100vw, 50vw" alt="Description de la photo" loading="lazy"> <!-- charge l'image seulement quand elle est visible -->
A personnaliser
  • Genere 3 tailles par image : 400px, 800px, 1200px de large
  • Utilise le format WebP (ou AVIF) pour un poids 30-50% plus leger
  • Ajoute loading="lazy" sur toutes les images sous la ligne de flottaison
Mes notes
24
Responsive · Touch
Rends tes boutons tactiles confortables
Utile
En clair : Sur un telephone, tu tapes avec ton doigt, pas avec un curseur de souris precis au pixel. Un bouton de 20px, c'est trop petit : tu rates une fois sur deux. La regle : minimum 44x44 pixels pour chaque zone cliquable. C'est la taille d'un bout de doigt. Pense aussi a l'espacement entre les boutons pour eviter les clics accidentels.
/* Taille minimum recommandee pour le tactile */ .btn { min-height: 44px; /* norme Apple/Google */ min-width: 44px; padding: 12px 24px; /* zone confortable */ } /* Espacement entre boutons pour eviter les erreurs */ .btn + .btn { margin-left: 12px; /* espace entre deux boutons */ }
A personnaliser
  • Minimum 44px pour les liens, boutons, cases a cocher et icones cliquables
  • Ajoute du padding plutot que du margin pour agrandir la zone de clic
  • Teste sur un vrai telephone : si tu rates le bouton, il est trop petit
Mes notes
25
Responsive · Testing
Teste sur de vrais appareils
Essentiel
En clair : Le mode responsive des DevTools, c'est une simulation. Pas la realite. Un vrai telephone a un ecran different, un navigateur different, un debit different. Si tu ne testes pas sur un vrai appareil, tu vas decouvrir les bugs en production. Teste au minimum sur un iPhone et un Android. Utilise le Wi-Fi de ton telephone pour voir ton site local.
<!-- 1. Trouve l'IP locale de ton ordinateur --> <!-- Mac : ifconfig | grep "inet " --> <!-- Windows : ipconfig | findstr IPv4 --> <!-- 2. Lance un serveur local --> <!-- python3 -m http.server 8080 --> <!-- 3. Sur ton telephone (meme Wi-Fi), ouvre : --> <!-- http://192.168.1.42:8080 --> <!-- 4. Teste : scroll, tap, formulaires, rotation -->
A personnaliser
  • Teste sur au moins 3 appareils : petit mobile, grand mobile, tablette
  • Verifie la rotation (portrait/paysage) sur chaque appareil
  • Utilise BrowserStack ou LambdaTest si tu n'as pas plusieurs appareils
Mes notes
05

Accessibilite — L'inclusion

6 fondamentaux pour que ton site soit utilisable par tout le monde

26
Accessibilite · HTML semantique
Rends ta page lisible par tous
Essentiel
En clair : Un lecteur d'ecran ne voit pas ta page. Il la lit. Si tu utilises des <div> partout, il ne sait pas ou est le menu, ou est le contenu. Les balises semantiques (<nav>, <main>, <button>) sont des panneaux indicateurs pour les aveugles, les malvoyants et les robots. Un <button> est cliquable au clavier. Un <div>, non.
<!-- MAL : tout en div, rien n'est accessible --> <div onclick="menu()">Menu</div> <div class="titre">Mon article</div> <!-- BIEN : balises semantiques, accessibles nativement --> <button type="button">Menu</button> <!-- focusable + activable au clavier --> <h1>Mon article</h1> <!-- reconnu comme titre principal --> <nav aria-label="Menu principal"> <!-- identifie la navigation --> <a href="/accueil">Accueil</a> </nav>
A personnaliser
  • Remplace chaque <div onclick> par un vrai <button>
  • Structure tes titres en hierarchie : h1 > h2 > h3 (ne saute pas de niveau)
  • Ajoute aria-label sur les <nav> quand tu en as plusieurs
Mes notes
27
Accessibilite · ARIA
Enrichis l'accessibilite avec ARIA
Important
En clair : ARIA, c'est un traducteur pour les lecteurs d'ecran. Quand le HTML seul ne suffit pas (un menu qui s'ouvre, un onglet actif, un spinner de chargement), ARIA ajoute des informations invisibles. aria-expanded dit si un menu est ouvert ou ferme. role="alert" annonce un message important. Mais la regle d'or : si une balise HTML native suffit, utilise-la. ARIA est un complement, pas un remplacement.
<!-- Menu deroulant : indiquer l'etat ouvert/ferme --> <button aria-expanded="false" aria-controls="menu">Menu</button> <ul id="menu" hidden>...</ul> <!-- Message d'alerte annonce automatiquement --> <div role="alert">Erreur : email invalide</div> <!-- Zone de chargement --> <div aria-busy="true" aria-live="polite"> Chargement en cours... </div>
A personnaliser
  • Premiere regle ARIA : n'utilise ARIA que si le HTML natif ne suffit pas
  • Mets a jour aria-expanded en JavaScript quand le menu s'ouvre/se ferme
  • Utilise aria-live="polite" pour les zones qui changent dynamiquement
Mes notes
28
Accessibilite · Contraste WCAG
Choisis des couleurs lisibles
Essentiel
En clair : Imagine lire un texte gris clair sur fond blanc en plein soleil. Impossible. Le ratio 4.5:1, c'est la garantie que tout le monde peut lire, meme dans de mauvaises conditions. Ce ratio compare la luminosite du texte avec celle du fond. Les outils le calculent pour toi. Si c'est en dessous de 4.5, change ta couleur. C'est une regle legale dans beaucoup de pays.
/* MAUVAIS contraste : gris clair sur blanc (ratio ~2:1) */ .texte-illisible { color: #b0b0b0; /* trop clair sur fond blanc */ background: #ffffff; } /* BON contraste : ratio 7:1+ (niveau AAA) */ .texte-lisible { color: #1a1a2e; /* sombre sur fond clair */ background: #ffffff; /* ratio 15.4:1 */ }
A personnaliser
  • Texte normal : ratio minimum 4.5:1 (AA). Gros texte (18px+) : 3:1
  • Outil gratuit : webaim.org/resources/contrastchecker
  • Verifie aussi les boutons, liens et placeholders (souvent trop clairs)
Mes notes
29
Accessibilite · Clavier
Rends tout accessible au clavier
Essentiel
En clair : Certaines personnes n'utilisent pas de souris. Elles naviguent avec Tab (element suivant), Shift+Tab (precedent) et Entree (activer). Si ton site ne fonctionne qu'a la souris, tu exclus ces utilisateurs. Le focus visible (le contour bleu) est essentiel : c'est la fleche du curseur version clavier. Ne le cache jamais. Si tu crees un element cliquable, il doit etre focusable.
/* JAMAIS : ne cache pas le focus visible */ *:focus { outline: none; } /* interdit ! */ /* BIEN : personnalise-le joliment */ :focus-visible { outline: 2px solid #6366f1; /* visible et esthetique */ outline-offset: 2px; /* petit espace autour */ } /* :focus-visible = seulement au clavier (pas au clic souris) */
A personnaliser
  • Teste en naviguant avec Tab : chaque element interactif doit recevoir le focus
  • Utilise :focus-visible (pas :focus) pour cibler uniquement la navigation clavier
  • Ajoute tabindex="0" sur les elements custom cliquables (si tu ne peux pas utiliser <button>)
Mes notes
30
Accessibilite · Lecteurs d'ecran
Parle aux lecteurs d'ecran
Important
En clair : Un lecteur d'ecran (VoiceOver, NVDA) lit ta page a voix haute. Il annonce les titres, les liens, les boutons, les images. Si une image n'a pas de alt, il dit "image" sans rien expliquer. Si un bouton n'a pas de texte, il dit "bouton" tout court. Chaque element interactif doit avoir un nom compréhensible a l'oral. Pense : "est-ce que ca a du sens si je l'entends sans le voir ?"
<!-- Image informative : decrire le contenu --> <img src="graph.png" alt="Ventes en hausse de 25% en mars"> <!-- Image decorative : alt vide (le lecteur l'ignore) --> <img src="deco.svg" alt=""> <!-- Bouton avec icone seule : aria-label obligatoire --> <button aria-label="Fermer">&times;</button> <!-- Contenu visible seulement par les lecteurs d'ecran --> <span class="sr-only">Ouvre le menu</span>
A personnaliser
  • Chaque <img> doit avoir un alt : descriptif (informative) ou vide (decorative)
  • Teste avec VoiceOver (Mac: Cmd+F5) ou NVDA (Windows, gratuit)
  • La classe .sr-only cache visuellement mais reste lisible par le lecteur d'ecran
Mes notes
31
Accessibilite · Preferences
Respecte les preferences de l'utilisateur
Utile
En clair : Ton visiteur a peut-etre active le mode sombre, reduit les animations ou agrandi le texte dans ses reglages systeme. CSS peut detecter ces preferences et s'adapter automatiquement. prefers-color-scheme detecte le mode sombre. prefers-reduced-motion detecte les gens sensibles aux animations. Respecter ces choix, c'est de la politesse numerique.
/* Detecter le mode sombre du systeme */ @media (prefers-color-scheme: dark) { body { background: #0a0a0f; color: #e4e4e7; } } /* Reduire les animations si l'utilisateur le demande */ @media (prefers-reduced-motion: reduce) { * { animation-duration: 0.01ms !important; transition-duration: 0.01ms !important; } }
A personnaliser
  • Utilise des variables CSS (--bg, --text) pour basculer les couleurs facilement
  • Teste : Mac > Reglages > Apparence > Sombre. Windows > Parametres > Couleurs
  • Ajoute prefers-contrast: high pour les utilisateurs qui forcent le contraste eleve
Mes notes
06

SEO & Performance — La visibilite

6 fondamentaux pour que Google te trouve et que tes pages chargent vite

32
SEO · Meta tags
Fais comprendre ta page a Google
Essentiel
En clair : Google ne voit pas ta page comme toi. Il lit le code source. Les balises meta sont ta fiche d'identite pour les moteurs de recherche. Le <title>, c'est le nom sur ta boite aux lettres. La meta description, c'est le petit mot colle dessus. Sans eux, Google invente un resume tout seul. Et c'est rarement joli.
<head> <!-- Titre : 50-60 caracteres, mot-cle principal en premier --> <title>Recettes faciles | MonSite</title> <!-- Description : 150-160 caracteres, donne envie de cliquer --> <meta name="description" content="Decouvre 50 recettes faciles a preparer en 15 min."> <!-- Indique l'URL officielle (evite le contenu duplique) --> <link rel="canonical" href="https://monsite.fr/recettes"> </head>
A personnaliser
  • Chaque page doit avoir un <title> et une meta description uniques
  • Place ton mot-cle principal au debut du titre, pas a la fin
  • Ajoute les balises Open Graph (og:title, og:image) pour un bel apercu sur les reseaux
Mes notes
33
SEO · Headings
Structure tes titres logiquement
Essentiel
En clair : Les titres H1 a H6, c'est la table des matieres de ta page. Google la lit pour comprendre le sujet. Un seul H1 par page (le titre principal). Puis des H2 pour les sections, des H3 pour les sous-sections. Comme un livre : un seul titre de couverture, plusieurs chapitres, plusieurs paragraphes par chapitre. Ne saute jamais de niveau (pas de H1 puis H4).
<!-- BIEN : hierarchie logique, un seul H1 --> <h1>Guide du jardinage</h1> <!-- titre unique --> <h2>Les outils essentiels</h2> <!-- section --> <h3>Le secateur</h3> <!-- sous-section --> <h3>La beche</h3> <!-- sous-section --> <h2>Planter ses legumes</h2> <!-- nouvelle section --> <!-- MAL : H1 en double, niveaux sautes --> <h1>Jardinage</h1> <h1>Outils</h1> <h4>Beche</h4>
A personnaliser
  • Un seul <h1> par page. C'est le titre principal, pas le logo
  • Ne choisis pas un niveau pour la taille du texte. Utilise CSS pour ca
  • Verifie ta hierarchie avec l'extension "HeadingsMap" sur Chrome
Mes notes
34
SEO · Core Web Vitals
Obtiens un bon score de performance
Essentiel
En clair : Google mesure 3 choses sur ta page. LCP : combien de temps avant que le plus gros element s'affiche (ton image hero, par exemple). FID : combien de temps avant que le site reagisse au premier clic. CLS : est-ce que la page bouge toute seule pendant le chargement. C'est comme un restaurant : le plat arrive vite (LCP), le serveur repond vite (FID), et la table ne bouge pas (CLS).
<!-- LCP : charge l'image principale en priorite --> <img src="hero.webp" fetchpriority="high" alt="Hero"> <!-- CLS : reserve l'espace pour les images --> <img src="photo.webp" width="800" height="450" alt="Photo"> <!-- FID : charge le JS lourd en differe --> <script src="app.js" defer></script> /* Objectifs : LCP < 2.5s | FID < 100ms | CLS < 0.1 */
A personnaliser
  • Teste avec PageSpeed Insights (web.dev/measure) pour voir tes scores
  • Ajoute width et height a toutes tes images pour eviter les sauts (CLS)
  • Mets defer sur tous tes scripts qui ne sont pas critiques
Mes notes
35
SEO · Optimisation images
Accelere le chargement de tes images
Essentiel
En clair : Une image de 5 Mo, c'est comme envoyer un colis de 10 kg par la poste pour un objet de 200 g. Le format WebP compresse mieux que JPEG (30% plus leger). Le lazy loading dit au navigateur : "charge cette image seulement quand le visiteur arrive dessus". Moins de poids = page plus rapide = visiteurs plus contents = Google plus content.
<!-- Lazy loading : charge l'image quand elle entre dans l'ecran --> <img src="photo.webp" loading="lazy" alt="Paysage"> <!-- Format moderne avec fallback JPEG --> <picture> <source srcset="photo.avif" type="image/avif"> <source srcset="photo.webp" type="image/webp"> <img src="photo.jpg" alt="Paysage"> </picture>
A personnaliser
  • Convertis toutes tes images en WebP avec Squoosh (squoosh.app, gratuit)
  • Mets loading="lazy" sur toutes les images sauf celles visibles au premier ecran
  • Redimensionne avant d'uploader : pas besoin d'une image 4000px pour un affichage 800px
Mes notes
36
SEO · Preload/Prefetch
Charge les bonnes ressources en avance
Important
En clair : Imagine que tu prepares un repas. Tu sors les ingredients du frigo avant de commencer a cuisiner, pas au dernier moment. preload dit au navigateur : "cette ressource est urgente, telecharge-la tout de suite". prefetch dit : "le visiteur ira probablement sur cette page ensuite, prepare-la en arriere-plan". Le bon timing fait toute la difference.
<head> <!-- Preload : charge la police AVANT qu'elle soit utilisee --> <link rel="preload" href="font.woff2" as="font" type="font/woff2" crossorigin> <!-- Prefetch : prepare la page suivante en arriere-plan --> <link rel="prefetch" href="/page-suivante.html"> <!-- Preconnect : ouvre la connexion au serveur externe --> <link rel="preconnect" href="https://fonts.googleapis.com"> </head>
A personnaliser
  • Utilise preload pour la police principale et l'image hero (LCP)
  • Utilise preconnect pour les domaines externes (Google Fonts, API, CDN)
  • N'abuse pas : trop de preload ralentit au lieu d'accelerer (3-4 max)
Mes notes
37
SEO · Minification
Reduis le poids de ton code
Important
En clair : Ton code CSS et JS contient des espaces, des retours a la ligne, des commentaires. C'est utile pour toi, mais inutile pour le navigateur. La minification supprime tout ca. C'est comme compresser une valise : le contenu est le meme, mais il prend moins de place. Resultat : fichiers plus legers, telechargement plus rapide, visiteurs plus heureux.
/* AVANT minification (lisible, 120 octets) */ .btn { background: #6366f1; padding: 12px 24px; border-radius: 8px; } /* APRES minification (illisible, 52 octets) */ .btn{background:#6366f1;padding:12px 24px;border-radius:8px}
A personnaliser
  • Utilise cssnano (CSS) et Terser (JS) pour minifier automatiquement
  • Garde toujours le fichier original (style.css) et le fichier minifie (style.min.css)
  • En production, lie le fichier .min.css. En dev, le fichier normal
Mes notes
07

Outils & Workflow — La productivite

5 fondamentaux pour travailler vite, bien, et sans stress

38
Outils · VS Code
Configure ton editeur de code
Essentiel
En clair : Un editeur de code, c'est ton atelier. VS Code est gratuit, leger et ultra-populaire. Il colore ton code, complete tes balises, detecte tes erreurs en temps reel. C'est la difference entre ecrire a la main sur du papier blanc et ecrire avec un stylo qui corrige l'orthographe. Installe les bonnes extensions et tu gagnes des heures chaque semaine.
// Extensions indispensables pour VS Code : // 1. Live Server — recharge la page a chaque sauvegarde // 2. Prettier — formate ton code automatiquement // 3. ESLint — detecte les erreurs JavaScript // 4. Auto Rename Tag — renomme la balise fermante // Raccourci magique : Ctrl+Shift+P (palette de commandes) // Tape "format" pour formater ton fichier en 1 seconde
A personnaliser
  • Active "Format on Save" dans les reglages (plus besoin d'y penser)
  • Tape ! puis Tab dans un fichier HTML : VS Code genere le squelette complet
  • Utilise Emmet : ul>li*5 + Tab cree une liste de 5 elements d'un coup
Mes notes
39
Outils · Git
Sauvegarde chaque version de ton code
Essentiel
En clair : Git, c'est un Ctrl+Z surpuissant pour ton projet. Chaque "commit", c'est une photo de ton code a un instant T. Tu peux revenir en arriere, comparer les versions, travailler a plusieurs sans ecraser le travail de l'autre. Sans Git, un fichier supprime par erreur est perdu pour toujours. Avec Git, tu remontes le temps en une commande.
# Initialiser Git dans ton projet git init # Ajouter tous les fichiers modifies git add . # Sauvegarder avec un message clair git commit -m "Ajout de la page contact" # Voir l'historique de tes sauvegardes git log --oneline
A personnaliser
  • Fais un commit a chaque etape fonctionnelle ("page contact OK", "menu mobile OK")
  • Utilise GitHub (gratuit) pour stocker ton code en ligne (sauvegarde cloud)
  • VS Code integre Git : tu peux commit, push et voir les diffs sans quitter l'editeur
Mes notes
40
Outils · DevTools
Inspecte et debogue dans le navigateur
Essentiel
En clair : Les DevTools, c'est une radio du corps humain pour ta page web. Tu vois les os (HTML), les vetements (CSS), les reflexes (JS). Tu cliques sur un element, tu vois son code, ses styles, ses marges. Tu modifies en direct pour tester. Rien n'est sauvegarde : c'est un bac a sable. Tous les navigateurs l'ont. Raccourci : F12 ou clic droit > Inspecter.
/* Onglets essentiels des DevTools */ // Elements : voir et modifier le HTML/CSS en direct // Console : afficher les erreurs JS et tester du code // Network : voir chaque fichier telecharge (taille, temps) // Lighthouse : lancer un audit complet (perf, SEO, a11y) // Astuce : dans Console, tape document.title // pour afficher le titre de la page en cours
A personnaliser
  • Raccourci : Ctrl+Shift+C (Windows) ou Cmd+Shift+C (Mac) pour inspecter un element
  • Onglet Network > cocher "Disable cache" pendant le dev (evite les fichiers perime)
  • Utilise le mode Responsive (icone smartphone) pour simuler un mobile sans en avoir un
Mes notes
41
Outils · Deploiement
Mets ton site en ligne gratuitement
Important
En clair : Ton site marche sur ton ordinateur. Super. Mais personne d'autre ne le voit. Le deploiement, c'est demenager ton site de ton PC vers un serveur accessible a tous. Des services gratuits comme Netlify ou Vercel le font en 2 minutes. Tu relies ton depot GitHub, et a chaque push, le site se met a jour automatiquement. Zero config, zero stress.
# Methode 1 : Netlify (glisser-deposer) # → Va sur app.netlify.com # → Glisse ton dossier de projet sur la page # → Ton site est en ligne en 30 secondes # Methode 2 : Vercel (via GitHub) # → Connecte ton repo GitHub sur vercel.com # → Chaque git push met a jour le site # → URL gratuite : monprojet.vercel.app
A personnaliser
  • Netlify : ideal pour les sites statiques (HTML/CSS/JS). Drop & deploy
  • Vercel : ideal si tu utilises un framework (Next.js, SvelteKit)
  • GitHub Pages : gratuit aussi, parfait pour un portfolio ou une doc
Mes notes
42
Outils · Domaine/Hosting
Choisis ton nom de domaine et hebergeur
Utile
En clair : Un nom de domaine, c'est l'adresse de ta maison (monsite.fr). L'hebergement, c'est le terrain sur lequel ta maison est construite. Sans domaine, les gens tapent une IP cryptique. Sans hebergeur, ta maison n'existe nulle part. Un domaine coute 5-15 euros/an. Un hebergement basique, 3-5 euros/mois. C'est le prix d'un cafe pour etre visible sur Internet.
/* Choisir un bon nom de domaine */ // Court : monsite.fr (pas mon-super-site-de-recettes-2026.fr) // Memorable : facile a epeler au telephone // Extension : .fr pour la France, .com pour l'international /* Hebergeurs recommandes (debutant) */ // OVH — francais, domaine + hebergement, ~3 EUR/mois // Hostinger — pas cher, interface simple, ~2 EUR/mois // Infomaniak — suisse, ecolo, bon support
A personnaliser
  • Verifie la disponibilite de ton domaine sur namecheap.com ou ovh.com
  • Prends le .fr ET le .com si possible (evite qu'un autre le prenne)
  • L'hebergement gratuit (Netlify, Vercel) suffit pour commencer. Passe en payant quand tu as du trafic
Mes notes
08

Securite Web — La protection

6 fondamentaux pour proteger ton site et tes visiteurs des attaques

43
Securite · HTTPS/SSL
Chiffre les echanges avec HTTPS
Essentiel
En clair : C'est le cadenas dans ta barre d'adresse. Sans lui, tout ce que ton visiteur tape (mot de passe, email) voyage en clair sur le reseau. Comme une carte postale que tout le monde peut lire. Avec HTTPS, les donnees sont chiffrees : meme si quelqu'un intercepte le message, il ne voit que du charabia. Google penalise les sites sans HTTPS. Les navigateurs affichent "Non securise".
<!-- Forcer HTTPS dans le HTML --> <meta http-equiv="Content-Security-Policy" content="upgrade-insecure-requests"> # Forcer HTTPS dans .htaccess (Apache) RewriteEngine On RewriteCond %{HTTPS} off RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301] # Certificat gratuit : Let's Encrypt (automatique)
A personnaliser
  • La plupart des hebergeurs proposent un certificat SSL gratuit (Let's Encrypt)
  • Verifie que TOUTES tes ressources (images, scripts) sont aussi en HTTPS
  • Teste avec SSL Labs (ssllabs.com) pour verifier que ton certificat est correct
Mes notes
44
Securite · CSP
Controle ce que ta page peut charger
Important
En clair : C'est la liste des invites a ta fete. Seuls les scripts autorises peuvent entrer. Les autres sont bloques a la porte. La CSP (Content Security Policy) dit au navigateur : "accepte les scripts de mon domaine et de Google Fonts, mais bloque tout le reste". Si un pirate injecte un script malveillant, le navigateur le refuse car il n'est pas sur la liste.
<!-- CSP dans le HTML (meta tag) --> <meta http-equiv="Content-Security-Policy" content=" default-src 'self'; script-src 'self' https://cdn.exemple.com; style-src 'self' https://fonts.googleapis.com; img-src 'self' data: https://stats.optimetier.fr https:; font-src 'self' https://fonts.gstatic.com; ">
A personnaliser
  • 'self' = ton propre domaine. Ajoute les CDN externes que tu utilises
  • Commence strict, puis autorise au cas par cas (mieux que tout ouvrir)
  • Teste avec l'onglet Console des DevTools : les violations CSP y sont affichees
Mes notes
45
Securite · XSS
Empeche l'injection de code malveillant
Essentiel
En clair : Imagine que quelqu'un colle un faux panneau sur ta vitrine. Les visiteurs le croient vrai. Le XSS, c'est pareil : du faux code injecte dans ta page. Un pirate ecrit du JavaScript dans un champ de formulaire. Si tu affiches ce texte tel quel, le code s'execute chez tous les visiteurs. Il peut voler des cookies, rediriger vers un faux site, ou afficher du contenu trompeur.
// DANGER : injecter du texte brut dans le HTML element.innerHTML = texteUtilisateur; // XSS possible ! // SECURISE : utiliser textContent (pas de HTML interprete) element.textContent = texteUtilisateur; // Si tu dois afficher du HTML, echappe les caracteres function escape(str) { return str.replace(/&/g, '&amp;') .replace(/</g, '&lt;') .replace(/>/g, '&gt;'); }
A personnaliser
  • Regle d'or : ne jamais utiliser innerHTML avec des donnees utilisateur
  • Prefere textContent (texte brut) ou createElement (DOM propre)
  • Cote serveur aussi : echappe avec htmlspecialchars() en PHP
Mes notes
46
Securite · CSRF
Protege tes formulaires contre les faux envois
Important
En clair : Imagine qu'un site piege envoie un formulaire a ta banque en ton nom, sans que tu le saches. Le CSRF (Cross-Site Request Forgery), c'est ca : un faux ordre envoye avec tes identifiants. La solution : un token unique et secret dans chaque formulaire. Le serveur verifie que le token est valide. Si quelqu'un envoie le formulaire depuis un autre site, il n'a pas le token. Requete refusee.
<!-- Le serveur genere un token unique par session --> <form method="POST" action="/transfert"> <input type="hidden" name="csrf_token" value="a8f3b9e1c7d2..."> <input type="text" name="montant"> <button type="submit">Envoyer</button> </form> <!-- Le serveur verifie : token recu == token en session -->
A personnaliser
  • Genere un token aleatoire a chaque session (jamais le meme deux fois)
  • Verifie aussi l'en-tete Origin pour confirmer que la requete vient de ton site
  • Les frameworks modernes (Laravel, Django, Express) gerent le CSRF automatiquement
Mes notes
47
Securite · Sanitization
Ne fais jamais confiance aux donnees utilisateur
Essentiel
En clair : Chaque champ de formulaire est une porte d'entree. Un visiteur peut y ecrire n'importe quoi : du code, des commandes, des caracteres bizarres. La sanitization, c'est le vigile qui fouille les sacs a l'entree. Tu nettoies chaque donnee avant de l'utiliser. Tu supprimes les balises HTML, tu limites la longueur, tu verifies le format. Cote client ET cote serveur. Toujours les deux.
// Cote client : valider AVANT d'envoyer const email = input.value.trim(); if (!email.includes('@')) { alert('Email invalide'); } // Cote serveur (PHP) : TOUJOURS re-verifier $email = filter_var($_POST['email'], FILTER_SANITIZE_EMAIL); $nom = htmlspecialchars($_POST['nom'], ENT_QUOTES); // strip_tags() supprime toutes les balises HTML
A personnaliser
  • La validation cote client est pour le confort. La validation cote serveur est pour la securite
  • Utilise les attributs HTML : type="email", required, maxlength, pattern
  • Ne fais jamais de requete SQL avec des donnees brutes. Utilise les requetes preparees
Mes notes
48
Securite · Headers securite
Ajoute des boucliers cote navigateur
Important
En clair : Les headers de securite sont des consignes que ton serveur donne au navigateur. "N'integre pas ma page dans une iframe" (clickjacking). "N'envoie pas le referrer complet" (vie privee). "Force le HTTPS pendant 1 an" (HSTS). C'est comme mettre une alarme, un verrou et une camera sur ta maison. Chaque header bloque un type d'attaque specifique.
# Headers de securite (.htaccess Apache) # Empeche l'affichage dans une iframe (anti-clickjacking) Header set X-Frame-Options "DENY" # Force HTTPS pendant 1 an Header set Strict-Transport-Security "max-age=31536000" # Empeche le sniffing de type MIME Header set X-Content-Type-Options "nosniff" # Limite les infos envoyees aux autres sites Header set Referrer-Policy "strict-origin-when-cross-origin"
A personnaliser
  • Teste tes headers sur securityheaders.com (objectif : note A ou A+)
  • Ajoute Permissions-Policy pour bloquer camera, micro, geolocation si tu n'en as pas besoin
  • Combine avec la CSP (topic 44) pour une protection maximale
Mes notes

Checklist avant de publier

Coche chaque point avant de mettre ton site en ligne. 48 fondamentaux resumes en 48 cases.

01 — HTML
02 — CSS
03 — JavaScript
04 — Responsive
05 — Accessibilite
06 — SEO & Performance
07 — Outils
08 — Securite

Merci d'avoir telecharge
ce guide !

Tu as maintenant les 48 fondamentaux pour construire des sites web solides, rapides et securises. Voici un recap des 8 chapitres :

# Chapitre Topics
01HTML — La structure01-06
02CSS — Le style07-13
03JavaScript — L'interaction14-19
04Responsive — L'adaptation20-25
05Accessibilite — L'inclusion26-31
06SEO & Performance — La visibilite32-37
07Outils & Workflow — La productivite38-42
08Securite Web — La protection43-48
Decouvrir Effect.Labs — 664 effets | 26 templates | 20 categories

Bibliotheque d'effets CSS & JS premium pour accelerer tes projets web

Effect.Labs — 2026 — Tous droits reserves

Ce guide est gratuit. Partage-le librement.