Éléments sémantiques
Structure du document
HTML5 a introduit des éléments sémantiques qui décrivent leur sens au navigateur comme au développeur. header, nav, main, article, aside, footer définissent la structure du document. DOCTYPE html déclenche le mode standards, lang améliore l'accessibilité et le SEO, et charset UTF-8 est requis pour un encodage correct.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Page Title</title>
</head>
<body>
<header>Header content</header>
<nav>Navigation</nav>
<main>
<article>Article content</article>
<aside>Sidebar</aside>
</main>
<footer>Footer</footer>
</body>
</html>Header et Footer
header représente un contenu introductif (logos, titres, formulaires de recherche) et peut apparaître plusieurs fois. footer porte le contenu de fin comme le copyright, des liens ou les coordonnées. Les deux peuvent s'employer dans des éléments de sectionnement comme article ou section, pas seulement au niveau de la page.
<header>
<h1>Site Title</h1>
<p>Tagline</p>
</header>
<footer>
<nav>
<a href="/about">About</a>
<a href="/contact">Contact</a>
</nav>
<small>© 2024 Example</small>
</footer>Élément de navigation
nav est réservé aux blocs de navigation majeurs. Toute liste de liens ne mérite pas nav — seuls les groupes significatifs pour la navigation du site. Employez aria-label pour distinguer plusieurs nav (ex. principale vs fil d'Ariane). aria-current indique la page courante.
<nav aria-label="Main navigation">
<ul>
<li><a href="/" aria-current="page">Home</a></li>
<li><a href="/blog">Blog</a></li>
<li><a href="/about">About</a></li>
</ul>
</nav>
<nav aria-label="Breadcrumb">
<ol>
<li><a href="/">Home</a></li>
<li><a href="/blog">Blog</a></li>
<li aria-current="page">Post</li>
</ol>
</nav>Main et Article
main enveloppe le contenu dominant de la page et ne devrait apparaître qu'une fois par page (mappé au repère ARIA 'main'). article est une composition autonome — billet de blog, dépêche ou widget — réutilisable indépendamment. section groupe du contenu lié thématiquement, toujours avec un titre.
<body>
<header>Site header</header>
<main>
<article>
<h1>Blog Post Title</h1>
<p>Body content...</p>
<section>
<h2>Subsection</h2>
<p>More content</p>
</section>
</article>
</main>
</body>Section et Aside
section groupe du contenu lié et devrait toujours porter un titre. aside représente un contenu tangentiellement lié au contenu principal — barres latérales, citations détachées ou publicités. Les deux améliorent le plan du document. Employez aria-labelledby pour donner aux sections un nom accessible.
<section aria-labelledby="features-heading">
<h2 id="features-heading">Features</h2>
<p>Feature description</p>
</section>
<aside aria-label="Related links">
<h2>Related</h2>
<ul>
<li><a href="/post-2">Next post</a></li>
</ul>
</aside>Figure et Figcaption
figure groupe du contenu (images, listings de code, citations) référencé depuis le flux principal, avec figcaption comme légende. figcaption doit être le premier ou dernier enfant. figure ne se limite pas aux images — il convient à tout contenu autonome comme des extraits de code ou des blockquotes.
<figure>
<img src="chart.png" alt="Sales chart showing growth">
<figcaption>Figure 1: Quarterly sales growth in 2024.</figcaption>
</figure>
<figure>
<blockquote>
<p>The best way to predict the future is to invent it.</p>
</blockquote>
<figcaption>— Alan Kay</figcaption>
</figure>Améliorations des formulaires
Nouveaux types d'input
HTML5 a ajouté des types d'input comme email, url, tel, date, time, color, range, number, month, week et datetime-local. Les navigateurs offrent une validation native et une UI spécialisée (sélecteurs de dates, de couleurs). type=email/url déclenche une validation automatique du format à l'envoi du formulaire.
<form>
<label>Email: <input type="email" required></label>
<label>URL: <input type="url"></label>
<label>Phone: <input type="tel"></label>
<label>Date: <input type="date"></label>
<label>Time: <input type="time"></label>
<label>Color: <input type="color"></label>
<label>Range: <input type="range" min="0" max="100"></label>
<label>Number: <input type="number" min="0" step="0.01"></label>
<button>Submit</button>
</form>Autocomplétion datalist
datalist fournit des suggestions d'autocomplétion pour un input via l'attribut list. Contrairement à select, l'utilisateur peut taper du texte libre ou choisir une suggestion. La value de chaque option devient une suggestion. datalist se dégrade avec grâce sur les navigateurs non gérés en input texte simple.
<label>
Choose a browser:
<input list="browsers" name="browser">
</label>
<datalist id="browsers">
<option value="Chrome">
<option value="Firefox">
<option value="Safari">
<option value="Edge">
</datalist>Élément output
output représente le résultat d'un calcul ou d'une action utilisateur. Il a une propriété value accessible via JS et un attribut for référençant les inputs qui y ont contribué. C'est un élément associé au formulaire, sa valeur se soumet donc avec le formulaire. Parfait pour des calculateurs en direct.
<form oninput="result.value = (+a.value + +b.value)">
<input type="number" name="a" value="0">
+
<input type="number" name="b" value="0">
=
<output name="result" for="a b">0</output>
</form>Progress et Meter
progress montre l'avancement d'une tâche (value/max) ; omettez value pour un état indéterminé. meter affiche une mesure scalaire dans une plage connue, avec des seuils low/high/optimum qui affectent sa couleur. meter est en lecture seule et ne sert pas à indiquer une progression.
<label>Uploading:
<progress value="70" max="100">70%</progress>
</label>
<label>Disk usage:
<meter value="0.6" min="0" max="1" low="0.4" high="0.8" optimum="0.2">
60%
</meter>
</label>
<!-- Indeterminate progress -->
<progress>Processing...</progress>Attribut form et fieldset
L'attribut form associe un input, un fieldset ou un bouton à un formulaire par id, même quand l'élément n'est pas imbriqué dedans. fieldset groupe des contrôles liés et legend fournit une légende. L'attribut disabled sur fieldset d ésactive d'un coup tous les contrôles contenus.
<form id="myForm" action="/submit" method="post"></form>
<!-- Input outside the form, but associated via form attribute -->
<label>
Name:
<input type="text" name="name" form="myForm" required>
</label>
<fieldset form="myForm" disabled>
<legend>Shipping Options</legend>
<label><input type="radio" name="ship" value="standard"> Standard</label>
<label><input type="radio" name="ship" value="express"> Express</label>
</fieldset>
<button type="submit" form="myForm">Submit</button>Placeholder et autofocus
placeholder montre une indication dans l'input et disparaît au focus — ce n'est pas un remplacement du label. autofocus focalise l'élément au chargement de la page (avec parcimonie, un par page). autocomplete contrôle si le navigateur mémorise les valeurs passées. title fournit une info-bulle mais ne devrait pas remplacer des labels accessibles.
<form>
<label>
Search:
<input type="search" name="q"
placeholder="Type to search..."
autofocus
autocomplete="off">
</label>
<label>
Hint text:
<input type="text" name="hint" title="Helpful tooltip">
</label>
<button type="submit">Go</button>
</form>Validation des formulaires
Attribut required
L'attribut booléen required marque un champ comme obligatoire ; le navigateur bloque l'envoi et montre une bulle d'erreur s'il est vide. Il fonctionne sur tous les contrôles texte, nombre, checkbox, radio, fichier et select. Associez-le aux pseudo-classes CSS :invalid et :valid pour un retour visuel.
<form>
<label>
Email (required):
<input type="email" name="email" required>
</label>
<label>
Optional phone:
<input type="tel" name="phone">
</label>
<button>Submit</button>
</form>Validation par pattern
pattern accepte une expression régulière JavaScript (sans slashes) que la valeur doit respecter. L'ancrage avec ^ et $ est recommandé. L'attribut title donne à l'utilisateur une indication en cas d'échec. Pattern est ancré implicitement pour type=email/url mais explicitement pour les inputs textuels.
<form>
<label>
Product code:
<input type="text" name="code"
pattern="[A-Z]{3}-\d{4}"
title="Three letters, hyphen, four digits (e.g., ABC-1234)"
required>
</label>
<label>
Hex color:
<input type="text" name="color" pattern="^#[0-9A-Fa-f]{6}$">
</label>
<button>Submit</button>
</form>Min, Max et Step
min et max définissent les bornes basse et haute des inputs numériques et de dates. step précise l'incrément ; les valeurs doivent être min + n*step. step='any' autorise tout décimal. Le navigateur rejette les valeurs hors plage à l'envoi et ajuste les clics du compteur.
<form>
<label>
Quantity:
<input type="number" name="qty" min="1" max="99" step="1" value="1">
</label>
<label>
Price:
<input type="number" name="price" min="0" step="0.01">
</label>
<label>
Date range:
<input type="date" name="start" min="2024-01-01" max="2024-12-31">
</label>
<button>Submit</button>
</form>Minlength et Maxlength
minlength et maxlength contraignent le nombre de caractères des inputs texte et textareas. minlength ne déclenche la validation que si le champ a une valeur (combinez avec required pour les champs obligatoires). maxlength piège en dur la saisie au-delà de la limite, empêchant de taper.
<form>
<label>
Username (3-20 chars):
<input type="text" name="user" minlength="3" maxlength="20" required>
</label>
<label>
Bio (max 280 chars):
<textarea name="bio" maxlength="280"></textarea>
</label>
<button>Submit</button>
</form>API Constraint Validation
L'API Constraint Validation expose validity.valid, valueMissing, typeMismatch, patternMismatch, tooShort, rangeOverflow, etc. setCustomValidity(msg) montre un message personnalisé (passez une chaîne vide pour effacer). checkValidity() renvoie un booléen et déclenche l'événement invalid ; reportValidity() montre en plus l'UI.
<form id="f">
<label>
Username:
<input name="u" required minlength="3">
</label>
<button>Submit</button>
</form>
<script>
const input = document.querySelector('#f input[name=u]');
input.addEventListener('input', () => {
if (input.validity.valueMissing) {
input.setCustomValidity('Please pick a username.');
} else if (input.validity.tooShort) {
input.setCustomValidity('At least 3 characters.');
} else {
input.setCustomValidity('');
}
});
</script>novalidate et formnovalidate
novalidate sur le formulaire désactive entièrement la validation du navigateur, utile quand vous validez via JS. formnovalidate sur un bouton submit saute la validation seulement pour l'envoi de ce bouton (ex. un « Enregistrer le brouillon » qui tolère des données incomplètes). Les deux soumettent quand même le formulaire.
<!-- Browser validation disabled for whole form -->
<form novalidate>
<label>Email: <input type="email" name="e" required></label>
<button>Save draft</button>
<!-- Skip validation only for this button -->
<button type="submit" formnovalidate>Cancel</button>
</form>Dessin Canvas
Élément Canvas et contexte 2D
canvas est une surface de dessin bitmap. getContext('2d') renvoie le contexte de rendu 2D ; 'webgl' un contexte 3D. Les attributs width/height règlent la taille du tampon de dessin (pas la taille CSS). Pour un rendu net sur écrans retina, mettez le tampon à l'échelle par devicePixelRatio. Le contenu de repli va entre les balises.
<canvas id="cv" width="400" height="300">
Your browser does not support canvas.
</canvas>
<script>
const canvas = document.getElementById('cv');
const ctx = canvas.getContext('2d');
// High-DPI scaling
const dpr = window.devicePixelRatio || 1;
canvas.width = 400 * dpr;
canvas.height = 300 * dpr;
ctx.scale(dpr, dpr);
</script>Dessiner des rectangles
fillRect(x, y, w, h) dessine un rectangle rempli, strokeRect ne trace que le contour, et clearRect efface les pixels en transparent. fillStyle et strokeStyle acceptent couleurs, dégradés ou motifs. lineWidth affecte l'épaisseur du trait, centrée sur le bord du chemin.
<script>
const ctx = canvas.getContext('2d');
// Filled rectangle
ctx.fillStyle = '#3498db';
ctx.fillRect(10, 10, 100, 50);
// Outlined rectangle
ctx.strokeStyle = '#e74c3c';
ctx.lineWidth = 3;
ctx.strokeRect(130, 10, 100, 50);
// Clear a rectangle (erase)
ctx.clearRect(50, 20, 40, 30);
</script>Chemins et lignes
beginPath démarre un nouveau chemin. moveTo positionne le crayon sans dessiner ; lineTo ajoute un segment de ligne. closePath relie le dernier point au départ. Appelez fill() et/ou stroke() pour rendre. Les arcs (arc), courbes (quadraticCurveTo, bezierCurveTo) et rects peuvent aussi s'ajouter à un chemin.
<script>
const ctx = canvas.getContext('2d');
ctx.beginPath();
ctx.moveTo(20, 20); // starting point
ctx.lineTo(180, 20); // top edge
ctx.lineTo(100, 140); // bottom corner
ctx.closePath(); // back to start
ctx.fillStyle = 'rgba(46,204,113,0.6)';
ctx.fill();
ctx.stroke();
</script>Dessiner du texte
font emploie le même raccourci que la police CSS. textAlign (start, end, left, right, center) et textBaseline (top, middle, alphabetic, bottom) contrôlent l'alignement. fillText dessine du texte plein ; strokeText n'en trace que le contour. measureText('foo').width renvoie la largeur rendue.
<script>
const ctx = canvas.getContext('2d');
ctx.font = '600 24px system-ui, sans-serif';
ctx.textAlign = 'center';
ctx.textBaseline = 'middle';
ctx.fillStyle = '#2c3e50';
ctx.fillText('Hello Canvas', 200, 150);
ctx.lineWidth = 1;
ctx.strokeStyle = '#bdc3c7';
ctx.strokeText('Outlined', 200, 200);
</script>Dessiner des images
drawImage peut prendre un élément img, canvas ou video. Avec 3 arguments il dessine à la taille naturelle ; avec 5 il met à l'échelle en w/h ; avec 9 les quatre premiers sont le rectangle source (recadrage) et les quatre derniers le rectangle destination. Attendez onload avant de dessiner, sinon l'image peut ne pas apparaître.
<script>
const img = new Image();
img.src = 'pic.jpg';
img.onload = () => {
ctx.drawImage(img, 0, 0); // full size
ctx.drawImage(img, 0, 0, 100, 75); // scaled
// Source crop -> destination
ctx.drawImage(img, 32, 32, 64, 64, 200, 0, 64, 64);
};
</script>Dégradés
createLinearGradient(x0, y0, x1, y1) et createRadialGradient(x0, y0, r0, x1, y1, r1) définissent des dégradés. addColorStop(offset, color) ajoute des arrêts de couleur avec un offset de 0 à 1. Passez toujours des chaînes de couleur standards ; des formats dépareillés (mélanger hex et rgba) peuvent casser l'interpolation. Assignez le dégradé à fillStyle ou strokeStyle.
<script>
// Linear gradient
const lg = ctx.createLinearGradient(0, 0, 200, 0);
lg.addColorStop(0, '#1e90ff');
lg.addColorStop(1, '#ffffff');
ctx.fillStyle = lg;
ctx.fillRect(0, 0, 200, 80);
// Radial gradient
const rg = ctx.createRadialGradient(100, 180, 5, 100, 180, 80);
rg.addColorStop(0, 'rgba(255,200,0,1)');
rg.addColorStop(1, 'rgba(255,200,0,0)');
ctx.fillStyle = rg;
ctx.fillRect(0, 100, 200, 160);
</script>SVG en ligne
Bases de l'élément SVG
Le SVG en ligne emploie l'élément svg avec width/height pour la taille d'affichage et viewBox pour le système de coordonnées. xmlns est requis quand le SVG s'emploie seul, optionnel en ligne. SVG est vectoriel : il passe à l'échelle nettement à toute taille, et se cherche et se style avec CSS comme du HTML normal.
<svg width="200" height="120" viewBox="0 0 200 120"
xmlns="http://www.w3.org/2000/svg">
<rect x="10" y="10" width="180" height="100"
fill="#3498db" rx="8" />
<text x="100" y="65" text-anchor="middle"
fill="white" font-size="18">SVG</text>
</svg>Formes de base
Les primitives SVG incluent rect, circle, ellipse, line, polyline (ouverte) et polygon (fermée). cx/cy sont les coordonnées du centre ; r le rayon. Le fill est la couleur intérieure, le stroke le contour. stroke-width règle l'épaisseur du contour. Tous les attributs peuvent aussi se régler via CSS.
<svg width="240" height="120" viewBox="0 0 240 120">
<rect x="10" y="10" width="80" height="80" fill="#e74c3c" />
<circle cx="150" cy="50" r="40" fill="#2ecc71" />
<ellipse cx="200" cy="60" rx="30" ry="18" fill="#f1c40f" />
<line x1="10" y1="110" x2="230" y2="110" stroke="#333" stroke-width="2" />
<polyline points="10,100 60,70 110,100 160,70"
fill="none" stroke="#9b59b6" stroke-width="3" />
</svg>Chemins
path est l'élément SVG le plus puissant, dessinant via un attribut d de commandes. M = moveTo, L = lineTo, H/V = lignes horizontale/verticale, C = Bézier cubique, Q = Bézier quadratique, A = arc, Z = fermer le chemin. Les lettres minuscules emploient des coordonnées relatives. La plupart des SVG exportés par les éditeurs emploient des chemins.
<svg width="200" height="120" viewBox="0 0 200 120">
<!-- M=moveTo, L=lineTo, C=cubicBezier, Z=closePath -->
<path d="M 10 80
C 40 10, 90 10, 120 80
L 180 80 Z"
fill="none" stroke="#3498db" stroke-width="3" />
<!-- A=arc -->
<path d="M 10 100 A 90 90 0 0 1 190 100"
fill="none" stroke="#e74c3c" stroke-width="2" />
</svg>Texte en SVG
text rend du texte redimensionnable et sélectionnable. x/y positionnent la ligne de base. text-anchor (start/middle/end) et dominant-baseline contrôlent l'alignement. tspan permet un style, un positionnement et des sauts de ligne par segment. Le texte SVG reste net à tout zoom et est accessible, contrairement au texte dessiné sur canvas.
<svg width="300" height="100" viewBox="0 0 300 100">
<text x="20" y="40" font-family="system-ui" font-size="20"
fill="#2c3e50">Plain text</text>
<text x="20" y="75" font-size="20" fill="#e74c3c"
text-decoration="underline">Underlined</text>
<text x="180" y="50">
<tspan fill="#3498db">Blue</tspan>
<tspan fill="#27ae60">Green</tspan>
</text>
</svg>Dégradés et motifs
Les dégradés vivent dans defs et se référencent par id via fill='url(#id)'. linearGradient emploie x1/y1/x2/y2 (objectBoundingBox par défaut, 0-1). radialGradient vaut par défaut un cercle centré. Les éléments stop définissent les arrêts de couleur. defs porte aussi des patterns, des chemins de clipping et des symboles réutilisables.
<svg width="220" height="120" viewBox="0 0 220 120">
<defs>
<linearGradient id="g1" x1="0" y1="0" x2="1" y2="0">
<stop offset="0%" stop-color="#1e90ff" />
<stop offset="100%" stop-color="#ffffff" />
</linearGradient>
<radialGradient id="g2">
<stop offset="0%" stop-color="#f1c40f" />
<stop offset="100%" stop-color="#e67e22" />
</radialGradient>
</defs>
<rect x="10" y="10" width="90" height="90" fill="url(#g1)" />
<circle cx="160" cy="55" r="45" fill="url(#g2)" />
</svg>SVG en ligne vs Canvas
SVG est indépendant de la résolution, chaque forme est un nœud DOM qu'on peut styler et auquel on peut attacher des événements — idéal pour les icônes, graphiques à peu d'éléments et graphiques accessibles. Canvas est un seul bitmap, plus rapide pour des milliers d'objets ou la manipulation de pixels (jeux, traitement d'image), mais non redimensionnable et inaccessible au DOM.
<!-- SVG: vector, DOM-accessible, scalable -->
<svg width="100" height="100" viewBox="0 0 100 100">
<circle id="c" cx="50" cy="50" r="40" fill="#3498db" />
</svg>
<button onclick="document.getElementById('c')
.setAttribute('r','20')">Shrink</button>
<!-- Canvas: bitmap, pixel-based, faster for many objects -->
<canvas id="cv" width="100" height="100"></canvas>Audio et vidéo
Élément video
video intègre de la vidéo sans plugin. controls montre l'UI native ; poster est la vignette avant lecture. Plusieurs éléments source laissent le navigateur choisir le premier codec géré. Le texte de repli entre les balises s'affiche sur les navigateurs non gérés. Incluez toujours width/height pour éviter le décalage de mise en page.
<video controls width="640" poster="cover.jpg">
<source src="movie.mp4" type="video/mp4">
<source src="movie.webm" type="video/webm">
Your browser does not support the video tag.
</video>Élément audio
audio fonctionne comme video sans dimensions visuelles. controls ajoute l'UI lecture/pause/avance/volume. Sans controls, l'élément est invisible et doit se contrôler via JS. Fournissez plusieurs sources (mp3, ogg) pour un support multi-navigateurs. autoplay peut être bloqué par les navigateurs sauf si muted.
<audio controls>
<source src="song.mp3" type="audio/mpeg">
<source src="song.ogg" type="audio/ogg">
Your browser does not support audio.
</audio>
<!-- Simple single-source -->
<audio src="beep.mp3" autoplay></audio>Sources multiples
Les navigateurs choisissent la première source dont le type est jouable. Inclure le paramètre codecs les aide à décider sans télécharger. Listez les formats modernes (webm/av1) en premier pour des charges plus légères, mp4 comme repli universel. Un lien de téléchargement entre les balises est un repli gracieux.
<video controls>
<source src="clip.webm" type='video/webm; codecs="vp9, opus"'>
<source src="clip.mp4" type='video/mp4; codecs="hvc1"'>
<source src="clip.ogv" type="video/ogg">
<p>Download <a href="clip.mp4">clip.mp4</a></p>
</video>Élément track (sous-titres)
track ajoute des pistes de texte synchronisées via des fichiers WebVTT (.vtt). kind peut valoir subtitles, captions, descriptions, chapters ou metadata. srclang déclare la langue, label s'affiche dans le menu, et default choisit la piste initiale. Les sous-titres sont essentiels pour l'accessibilité et améliorent le SEO.
<video controls>
<source src="talk.mp4" type="video/mp4">
<track kind="subtitles" src="talk.en.vtt"
srclang="en" label="English" default>
<track kind="captions" src="talk.en.cc.vtt"
srclang="en" label="English CC">
<track kind="chapters" src="talk.chapters.vtt"
srclang="en" label="Chapters">
</video>Attributs des médias
autoplay démarre la lecture automatiquement mais est bloqué sauf si muted est aussi réglé. loop répète sans fin. playsinline empêche le plein écran forcé sur iOS (essentiel pour des fonds en ligne). preload peut valoir none, metadata (seulement durée/dimensions) ou auto (tamponner tout le fichier). Évitez autoplay+preload=auto ensemble pour économiser la bande passante.
<video src="bg.mp4"
autoplay muted loop
playsinline
preload="auto"
width="1280" height="720">
</video>
<video src="preview.mp4"
controls
preload="metadata"
poster="preview.jpg">
</video>API des médias
L'API HTMLMediaElement expose play(), pause(), load(), currentTime, duration, volume, muted, playbackRate et readyState. Les événements incluent play, pause, timeupdate, ended, volumechange, loadedmetadata et waiting. Bâtissez des lecteurs personnalisés en masquant controls et en câblant des boutons à ces méthodes.
<video id="v" src="movie.mp4"></video>
<button onclick="v.play()">Play</button>
<button onclick="v.pause()">Pause</button>
<input type="range" min="0" max="100" oninput="v.volume = this.value/100">
<script>
const v = document.getElementById('v');
v.addEventListener('timeupdate', () => {
console.log(v.currentTime, '/', v.duration);
});
v.addEventListener('ended', () => alert('Done!'));
// Jump 10s forward
function skip() { v.currentTime += 10; }
</script>Géolocalisation
getCurrentPosition
getCurrentPosition prend des callbacks de succès et d'erreur optionnels plus un objet d'options. L'objet position expose coords.latitude, longitude, accuracy et — quand disponibles — altitude, heading et speed. La géolocalisation ne fonctionne qu'en HTTPS (ou localhost) et demande la permission à l'utilisateur.
<script>
if ('geolocation' in navigator) {
navigator.geolocation.getCurrentPosition(
(pos) => {
console.log('Latitude:', pos.coords.latitude);
console.log('Longitude:', pos.coords.longitude);
console.log('Accuracy:', pos.coords.accuracy, 'meters');
},
(err) => console.error(err.message),
{ enableHighAccuracy: true, timeout: 10000 }
);
}
</script>Options de position
enableHighAccuracy demande le résultat le plus précis (GPS) au prix du temps et de la batterie. timeout plafonne l'attente ; dépassé, error.code vaut TIMEOUT (3). maximumAge laisse le navigateur renvoyer une position en cache si elle a moins que les millisecondes données, évitant des appels GPS répétés.
<script>
navigator.geolocation.getCurrentPosition(success, error, {
enableHighAccuracy: true, // use GPS, slower
timeout: 5000, // max wait in ms
maximumAge: 60000 // accept cached fix up to 60s old
});
function success(pos) { /* ... */ }
function error(err) { /* ... */ }
</script>watchPosition
watchPosition appelle le callback de succès à chaque changement de position, en renvoyant un ID. Passez cet ID à clearWatch pour arrêter les mises à jour. Essentiel pour les apps de navigation. Attention à la batterie — employez un intervalle de mise à jour raisonnable et cessez la surveillance quand ce n'est plus nécessaire.
<script>
const watchId = navigator.geolocation.watchPosition(
(pos) => updateMap(pos.coords),
(err) => console.warn(err.message),
{ enableHighAccuracy: true }
);
// Stop tracking
document.getElementById('stop').onclick = () => {
navigator.geolocation.clearWatch(watchId);
};
</script>Gestion des erreurs
Le callback d'erreur reçoit un GeolocationPositionError avec code et message. PERMISSION_DENIED (1) signifie que l'utilisateur a refusé ou que le navigateur a bloqué. POSITION_UNAVAILABLE (2) que l'appareil n'a pu déterminer une position. TIMEOUT (3) que la requête a dépassé l'option timeout. Gérez toujours les trois cas avec grâce.
<script>
navigator.geolocation.getCurrentPosition(
(pos) => console.log(pos),
(err) => {
switch (err.code) {
case err.PERMISSION_DENIED: // 1
console.log('User denied permission'); break;
case err.POSITION_UNAVAILABLE: // 2
console.log('Position unavailable'); break;
case err.TIMEOUT: // 3
console.log('Timed out'); break;
}
console.log(err.message);
}
);
</script>API Permissions
L'API Permissions permet de vérifier l'état d'une permission sans déclencher de demande. query({ name: 'geolocation' }) renvoie un PermissionStatus dont le state vaut granted, denied ou prompt. Écoutez onchange pour réagir quand l'utilisateur accorde ou retire la permission ailleurs. Géré pour geolocation, notifications, caméra, microphone et autres.
<script>
navigator.permissions
.query({ name: 'geolocation' })
.then((result) => {
// result.state: 'granted' | 'denied' | 'prompt'
if (result.state === 'granted') {
startTracking();
} else if (result.state === 'prompt') {
showEnableButton();
} else {
showInstructions();
}
result.onchange = () => console.log(result.state);
});
</script>Web Storage
Bases de localStorage
localStorage stocke des paires clé/valeur en chaînes sans expiration ; les données persistent entre onglets et sessions. Les valeurs sont des chaînes, nombres et booléens se convertissent donc automatiquement. La limite est ~5 Mo par origine. Le stockage est synchrone et bloque le thread principal, évitez les grosses écritures. Y accéder en mode privé peut lever, enveloppez dans un try/catch.
<script>
// Store a value (strings only)
localStorage.setItem('theme', 'dark');
// Read a value
const theme = localStorage.getItem('theme'); // 'dark'
// Remove one key
localStorage.removeItem('theme');
// Remove everything
localStorage.clear();
// Number of stored keys
console.log(localStorage.length);
</script>sessionStorage
sessionStorage a la même API que localStorage mais se limite à un seul onglet et se vide à sa fermeture. Utile pour des données transitoires comme un brouillon de formulaire multi-étapes, un panier temporaire ou des tokens CSRF. Les données ne se partagent pas entre onglets, même de même origine.
<script>
// sessionStorage works like localStorage but per-tab
sessionStorage.setItem('cart', '3 items');
console.log(sessionStorage.getItem('cart'));
sessionStorage.removeItem('cart');
// Survives a page reload but not a tab close
// Also isolated per tab (not shared)
</script>Stockage de données JSON
Comme Web Storage ne stocke que des chaînes, employez JSON.stringify et JSON.parse pour les objets et tableaux. Enveloppez toujours le parse dans un try/catch car des données corrompues ou éditées à la main lèveront. Pour des données complexes, versionnez la clé (ex. 'settings.v2') pour que les changements de schéma ne cassent pas les vieilles données.
<script>
const settings = { theme: 'dark', fontSize: 16, lang: 'en' };
// Serialize before saving
localStorage.setItem('settings', JSON.stringify(settings));
// Parse when reading
try {
const saved = JSON.parse(localStorage.getItem('settings'));
console.log(saved.theme); // 'dark'
} catch (e) {
console.warn('Corrupted data', e);
}
</script>Événements de stockage
L'événement storage se déclenche dans tous les autres onglets de la même origine quand localStorage ou sessionStorage change — mais PAS dans l'onglet à l'origine du changement. C'est le canal de communication inter-onglets le plus simple. L'objet événement porte key, oldValue, newValue, url et storageArea. Employez-le pour synchroniser déconnexion, changements de thème ou mises à jour en direct entre onglets.
<script>
// Listen in OTHER tabs (same origin) for changes
window.addEventListener('storage', (e) => {
console.log('Key changed:', e.key);
console.log('Old value:', e.oldValue);
console.log('New value:', e.newValue);
console.log('URL:', e.url);
});
// The tab that calls setItem does NOT receive the event
localStorage.setItem('count', '42');
</script>Vider le stockage
clear() retire chaque clé de l'origine — avec parcimonie et après confirmation de l'utilisateur. key(n) renvoie le nom de la clé à l'index n, ou null hors plage. L'ordre d'itération dépend de l'implémentation, n'en dépendez pas. Pour un nettoyage partiel, listez les clés avec un préfixe (ex. 'cache:') et retirez-les par removeItem dans une boucle.
<script>
// Remove a single key
localStorage.removeItem('temp');
// Wipe all keys for this origin
localStorage.clear();
// Iterate keys
const keys = [];
for (let i = 0; i < localStorage.length; i++) {
keys.push(localStorage.key(i));
}
console.log(keys);
// Indexed access (order is not guaranteed)
localStorage.key(0);
</script>IndexedDB
Ouvrir une base
indexedDB.open(name, version) ouvre ou crée une base. onupgradeneeded se déclenche quand la version augmente ou à la première création — c'est le SEUL endroit où créer ou altérer object stores et index. Augmentez le numéro de version à chaque changement de schéma. Les stores exigent un keyPath (la propriété employée comme clé) ou une clé auto-incrémentée.
<script>
const request = indexedDB.open('MyDB', 1);
request.onupgradeneeded = (e) => {
const db = e.target.result;
if (!db.objectStoreNames.contains('users')) {
const store = db.createObjectStore('users', { keyPath: 'id' });
store.createIndex('email', 'email', { unique: true });
}
};
request.onsuccess = (e) => {
const db = e.target.result;
console.log('DB ready:', db.name, db.version);
};
request.onerror = (e) => console.error(e.target.error);
</script>Object stores
Un object store ressemble à une table ; chaque enregistrement a une clé et une valeur (tout objet clonable structurellement). keyPath indique au store quelle propriété porte la clé. autoIncrement assigne des clés entières séquentielles. Les index permettent de requêter par une propriété non clé ; unique: true impose l'absence de doublons sur ce champ.
<script>
request.onupgradeneeded = (e) => {
const db = e.target.result;
// With a key path
const users = db.createObjectStore('users', { keyPath: 'id' });
// Auto-incrementing integer key
const logs = db.createObjectStore('logs', { autoIncrement: true });
// Indexes for fast lookups
users.createIndex('name', 'name', { unique: false });
users.createIndex('email', 'email', { unique: true });
};
</script>Ajouter des données
Toutes les opérations se déroulent dans une transaction créée avec db.transaction(storeName, mode). Le mode vaut 'readonly' (défaut) ou 'readwrite'. add() rejette les doublons ; put() fait de l'upsert. La transaction se commit automatiquement quand toutes les requêtes sont finies ; écoutez oncomplete. Gardez les transactions courtes — elles bloquent les autres transactions sur les mêmes stores.
<script>
function addUser(db, user) {
const tx = db.transaction('users', 'readwrite');
const store = tx.objectStore('users');
store.add(user); // throws on duplicate key
// store.put(user); // inserts OR overwrites
tx.oncomplete = () => console.log('Saved');
tx.onerror = () => console.error(tx.error);
}
addUser(db, { id: 1, name: 'Ada', email: '[email protected]' });
</script>Lire des données
get(key) lit un enregistrement par clé primaire ; getAll() renvoie tous les enregistrements en tableau. Pour chercher par un champ non clé, ouvrez l'index avec store.index(name) et appelez get/getAll dessus. Chaque requête a onsuccess et onerror. Les résultats sont dans event.target.result ou request.result.
<script>
const tx = db.transaction('users', 'readonly');
const store = tx.objectStore('users');
// By primary key
const req = store.get(1);
req.onsuccess = () => console.log(req.result);
// By index
const byEmail = store.index('email');
byEmail.get('[email protected]').onsuccess = (e) => {
console.log(e.target.result);
};
// All records
store.getAll().onsuccess = (e) => {
console.log(e.target.result); // array
};
</script>Curseurs et index
openCursor() permet d'itérer les enregistrements un par un, idéal pour les grands jeux de données qui ne tiennent pas en mémoire. Appelez cursor.continue() pour avancer. cursor.update(value) modifie l'enregistrement courant ; cursor.delete() le retire. IDBKeyRange (bound, only, lowerBound, upperBound) borne les requêtes d'index — utile pour les recherches par préfixe ou plage.
<script>
const tx = db.transaction('users', 'readwrite');
const store = tx.objectStore('users');
// Iterate and modify
const req = store.openCursor();
req.onsuccess = (e) => {
const cursor = e.target.result;
if (cursor) {
if (cursor.value.name === 'Ada') {
cursor.value.role = 'admin';
cursor.update(cursor.value);
}
cursor.continue();
}
};
// Range query on an index
const range = IDBKeyRange.bound('A', 'M');
store.index('name').openCursor(range).onsuccess = (e) => { /* ... */ };
</script>API Drag and Drop
Rendre des éléments draggables
Mettez draggable='true' sur tout élément pour le rendre déplaçable. L'événement dragstart se déclenche au début du glissement ; employez dataTransfer.setData pour empaqueter les données vers la cible de dépôt. effectAllowed (copy, move, link, all, none) indique l'opération prévue. dragend se déclenche à la fin du glissement, qu'il y ait eu dépôt ou non.
<div id="card" draggable="true">
Drag me!
</div>
<script>
const card = document.getElementById('card');
card.addEventListener('dragstart', (e) => {
e.dataTransfer.setData('text/plain', card.id);
e.dataTransfer.effectAllowed = 'move';
card.classList.add('dragging');
});
card.addEventListener('dragend', () => {
card.classList.remove('dragging');
});
</script>Événements de glissement
Pour accepter un dépôt, il FAUT appeler preventDefault() sur dragover et drop — sinon le navigateur ne fait rien. dragenter/dragleave se déclenchent quand le pointeur entre/sort de la cible. dropEffect (copy, move, link, none) contrôle le curseur. L'événement drag se déclenche en continu sur la source pendant le glissement.
<script>
// Events on the SOURCE element:
// dragstart, drag, dragend
// Events on the TARGET element:
// dragenter, dragover, dragleave, drop
const drop = document.getElementById('drop');
drop.addEventListener('dragover', (e) => {
e.preventDefault(); // REQUIRED to allow drop
e.dataTransfer.dropEffect = 'move';
});
drop.addEventListener('drop', (e) => {
e.preventDefault();
const id = e.dataTransfer.getData('text/plain');
drop.appendChild(document.getElementById(id));
});
</script>DataTransfer
dataTransfer transporte les données entre source et cible de dépôt. setData(format, data) stocke une chaîne ; getData(format) la lit. Les formats standards incluent text/plain, text/uri-list, text/html et files. On peut aussi enregistrer des types MIME personnalisés. Certains navigateurs restreignent getData aux événements de dépôt pour la sécurité.
<script>
card.addEventListener('dragstart', (e) => {
// Multiple data types
e.dataTransfer.setData('text/plain', 'Hello');
e.dataTransfer.setData('text/uri-list', 'https://example.com');
e.dataTransfer.setData('application/json', JSON.stringify({ a: 1 }));
// Read in the drop handler
// e.dataTransfer.getData('text/plain')
});
</script>Zone de dépôt
Un pattern courant : surligner la zone de dépôt sur dragenter/dragover, l'effacer sur dragleave/drop. dataTransfer.files donne une FileList quand on glisse des fichiers depuis l'OS, permettant les uploads par glisser-déposer. Faites toujours preventDefault sur dragover sinon l'événement drop ne se déclenchera pas. Employez des compteurs dragenter/leave si vous avez des éléments imbriqués.
<style>
.dropzone { border: 2px dashed #bbb; padding: 24px; }
.dropzone.over { background: #eaf6ff; border-color: #3498db; }
</style>
<div class="dropzone" id="dz">Drop files here</div>
<script>
const dz = document.getElementById('dz');
dz.addEventListener('dragenter', () => dz.classList.add('over'));
dz.addEventListener('dragover', (e) => e.preventDefault());
dz.addEventListener('dragleave', () => dz.classList.remove('over'));
dz.addEventListener('drop', (e) => {
e.preventDefault();
dz.classList.remove('over');
const files = e.dataTransfer.files; // FileList
for (const f of files) console.log(f.name, f.size);
});
</script>Image de glissement
setDragImage(element, offsetX, offsetY) remplace le fantôme de glissement par défaut par un élément personnalisé. L'élément doit être dans le DOM et rendu, créez-le, ajoutez-le, puis retirez-le après dragstart. Les offsets positionnent le curseur relativement au coin haut-gauche de l'image. Sans image passée, le navigateur photographie l'élément glissé.
<script>
card.addEventListener('dragstart', (e) => {
const ghost = document.createElement('div');
ghost.textContent = 'Dragging card';
ghost.style.cssText = 'position:absolute;top:-999px;' +
'padding:8px;background:#3498db;color:#fff;';
document.body.appendChild(ghost);
e.dataTransfer.setDragImage(ghost, 20, 20);
setTimeout(() => document.body.removeChild(ghost), 0);
});
</script>Web Workers
Bases du Worker
new Worker(url) crée un thread d'arrière-plan qui exécute le fichier de script. La communication passe par postMessage et onmessage, avec données copiées (clonage structuré) entre threads. Les workers ne peuvent toucher ni DOM, ni window, ni document — mais ils peuvent employer fetch, IndexedDB et setTimeout. Employez-les pour les calculs lourds afin que l'UI reste réactive.
<!-- main.js -->
<script>
const worker = new Worker('worker.js');
worker.postMessage({ cmd: 'sum', nums: [1, 2, 3] });
worker.onmessage = (e) => {
console.log('Result:', e.data); // 6
};
worker.onerror = (e) => {
console.error(e.message, e.filename, e.lineno);
};
</script>Script du Worker
Dans un worker, self (ou this) est la portée globale — postMessage et onmessage y pendouillent. Pas de window ni de document. Les workers peuvent employer fetch, importScripts(), setTimeout/setInterval et IndexedDB. importScripts('a.js','b.js') charge synchroniquement d'autres scripts dans le worker. Chaque worker tourne dans son propre isolat.
// worker.js
self.onmessage = (e) => {
const { cmd, nums } = e.data;
if (cmd === 'sum') {
let total = 0;
for (const n of nums) total += n;
self.postMessage(total);
} else if (cmd === 'heavy') {
const result = doExpensiveWork();
self.postMessage(result);
}
};
function doExpensiveWork() {
// ... long-running computation
return 'done';
}Envoyer des messages
postMessage(data, transferables) envoie des données, copiées par clonage structuré. Passez un tableau de ArrayBuffer, MessagePort ou ImageBitmap en second argument pour TRANSFÉRER la propriété au lieu de copier — bien plus rapide pour les gros tampons, mais l'original devient inutilisable dans le thread émetteur.
<script>
const w = new Worker('worker.js');
// Plain object
w.postMessage({ type: 'start' });
// Transferable: zero-copy move of a buffer
const buffer = new ArrayBuffer(1024);
w.postMessage(buffer, [buffer]);
// buffer is now "neutered" in main thread
// Two-way communication
w.onmessage = (e) => console.log('Worker said:', e.data);
</script>Objets transférables
Les objets transférables (ArrayBuffer, MessagePort, ImageBitmap, OffscreenCanvas) se déplacent entre threads sans copie. transferControlToOffscreen confie un canvas à un worker, qui peut alors y rendre indépendamment — parfait pour des animations fluides pendant que le thread principal est occupé. Le thread principal perd l'accès à l'objet transféré.
<script>
// Send a canvas ImageBitmap to a worker for processing
const offscreen = canvas.transferControlToOffscreen();
const worker = new Worker('paint.js');
worker.postMessage({ canvas: offscreen }, [offscreen]);
// Now the worker draws directly to the canvas
// without round-trips to the main thread.
</script>
<!-- paint.js -->
self.onmessage = (e) => {
const ctx = e.data.canvas.getContext('2d');
ctx.fillStyle = '#3498db';
ctx.fillRect(0, 0, 100, 100);
};Shared Workers
Un SharedWorker est un worker unique partagé par plusieurs onglets de même origine. Chaque connexion reçoit un MessagePort via l'événement connect. Employez-le pour l'état inter-onglets (compteurs en direct, caches partagés) ou un fan-out WebSocket unique. Les SharedWorkers ne sont pas gérés par Safari sur iOS et ont des particularités ; testez avant d'en dépendre.
<!-- main.js -->
<script>
const sw = new SharedWorker('shared.js');
sw.port.onmessage = (e) => console.log('Broadcast:', e.data);
sw.port.start();
sw.port.postMessage({ from: 'tab-A' });
</script>
<!-- shared.js -->
const ports = new Set();
self.onconnect = (e) => {
const port = e.ports[0];
ports.add(port);
port.onmessage = (ev) => {
// Broadcast to every connected tab
for (const p of ports) p.postMessage(ev.data);
};
port.start();
};WebSockets
Ouvrir une connexion
new WebSocket(url) ouvre une connexion persistante et bidirectionnelle. Employez wss:// (TLS) en production — ws:// est en clair et bloqué sur les pages HTTPS. Le readyState passe de CONNECTING (0) à OPEN (1) à CLOSING (2) à CLOSED (3). Écoutez les événements open, message, error et close.
<script>
const ws = new WebSocket('wss://echo.example.com/chat');
ws.addEventListener('open', () => {
console.log('Connected');
ws.send('Hello server!');
});
ws.addEventListener('message', (e) => {
console.log('Received:', e.data);
});
ws.addEventListener('close', (e) => {
console.log('Closed', e.code, e.reason);
});
</script>Envoyer des messages
send() accepte chaînes, Blobs, ArrayBuffers et ArrayBufferViews. Pour des données structurées, JSON.stringify d'abord et parsez de l'autre côté. Les messages se mettent en file s'ils partent avant l'ouverture, mais par prudence vérifiez readyState === OPEN. Le protocole est full-duplex — chaque côté peut envoyer à tout moment.
<script>
// Strings
ws.send('plain text');
// JSON
ws.send(JSON.stringify({ type: 'chat', text: 'hi' }));
// Binary
const blob = new Blob([new Uint8Array([1,2,3])]);
ws.send(blob);
ws.send(new ArrayBuffer(8));
// Check state before sending
if (ws.readyState === WebSocket.OPEN) ws.send(data);
</script>Recevoir des messages
Les événements message livrent e.data en chaîne (texte), Blob (binaire par défaut) ou ArrayBuffer (réglez ws.binaryType = 'arraybuffer'). Pour les protocoles texte, JSON est l'encodage le plus courant. Pour le binaire, choisissez Blob pour les fichiers/images et ArrayBuffer pour le parsing numérique. Définissez un schéma de messages pour que les deux côtés s'accordent sur la forme.
<script>
ws.addEventListener('message', (e) => {
// Text messages: e.data is a string
if (typeof e.data === 'string') {
const msg = JSON.parse(e.data);
console.log(msg.type, msg.text);
}
// Binary: e.data is a Blob or ArrayBuffer
else {
e.data.arrayBuffer().then((buf) => {
const view = new DataView(buf);
console.log(view.getInt32(0));
});
}
});
// Force binary type
ws.binaryType = 'arraybuffer';
</script>Erreurs et fermeture
Les événements error portent peu de détails pour la sécurité ; vérifiez l'événement close ensuite. close(code, reason) initie un arrêt propre ; le code 1000 est une fermeture normale, 1006 signifie que la connexion est tombée sans frame de fermeture (problème réseau). Les codes 4000-4999 sont réservés aux applications. wasClean ne vaut true que si les deux côtés ont achevé la poignée de main.
<script>
ws.addEventListener('error', (e) => {
console.error('Socket error', e);
});
ws.addEventListener('close', (e) => {
console.log('code:', e.code, 'reason:', e.reason, 'clean:', e.wasClean);
});
// Close gracefully (1000 = normal closure)
ws.close(1000, 'goodbye');
// Common codes:
// 1000 normal, 1001 going away, 1006 abnormal (no close frame)
// 4000-4999 app-defined
</script>Reconnexion
Les navigateurs ne se reconnectent pas automatiquement, implémentez-le vous-même avec un backoff exponentiel (délai = min(base * 2^reprise, max)). Envoyez des pings périodiques pour détecter et fermer les sockets morts. Reconnectez à la fermeture mais plafonnez l'intervalle de reprise pour ne pas marteler le serveur. Remettez le compteur de reprises à zéro une fois connecté avec succès.
<script>
let ws;
let retry = 0;
function connect() {
ws = new WebSocket('wss://example.com/live');
ws.onopen = () => { retry = 0; console.log('open'); };
ws.onmessage = (e) => console.log(e.data);
ws.onclose = () => {
const delay = Math.min(1000 * 2 ** retry, 30000);
retry++;
setTimeout(connect, delay);
};
}
connect();
// Heartbeat to detect dead connections
setInterval(() => {
if (ws.readyState === WebSocket.OPEN) ws.send('ping');
}, 30000);
</script>API History
pushState
pushState(state, title, url) ajoute une nouvelle entrée à l'historique de session et met à jour la barre d'adresse sans recharger la page — le cœur du routage côté client. L'URL doit être de même origine ou pushState lève. L'argument title est actuellement ignoré par les navigateurs. L'objet state est sérialisable et récupérable via history.state.
<script>
// Add a new entry WITHOUT reloading
history.pushState(
{ page: 'about' }, // state object
'About', // title (ignored by most browsers)
'/about' // URL
);
console.log(history.length); // entries count
console.log(history.state); // { page: 'about' }
</script>replaceState
replaceState(state, title, url) fonctionne comme pushState mais remplace l'entrée courante au lieu d'en ajouter — donc retour/avance sautent l'original. Employez-le pour mettre à jour l'URL ou l'état sans polluer l'historique, ex. après application d'un filtre à travers lequel l'utilisateur ne doit pas « revenir ».
<script>
// Replace the CURRENT entry (no new history item)
history.replaceState(
{ page: 'home', tab: 'featured' },
'',
'/home?tab=featured'
);
// Useful for: cleaning up redirects, updating URL after
// AJAX filter changes, or normalizing the entry URL.
</script>Événement popstate
popstate se déclenche quand l'utilisateur clique retour/avance ou que history.go/back/forward est appelé — pas sur pushState/replaceState. event.state est l'objet d'état de l'entrée vers laquelle on navigue. La plupart des routeurs SPA appellent la fonction de rendu à la fois dans navigate() et le handler popstate pour que toutes les navigations mettent à jour la vue.
<script>
window.addEventListener('popstate', (e) => {
console.log('Location:', location.pathname);
console.log('State:', e.state);
renderRoute(location.pathname);
});
function navigate(path) {
history.pushState({ path }, '', path);
renderRoute(path);
}
// NOTE: pushState/replaceState do NOT fire popstate.
// Only back/forward (and history.go) do.
</script>Méthodes de navigation
back(), forward() et go(delta) parcourent l'historique de session ; go(0) recharge. history.length est le nombre d'entrées de la session courante, plafonné par le navigateur. Ces méthodes sont asynchrones — popstate se déclenche une fois la navigation achevée. Appeler go au-delà des bornes ne fait rien.
<script>
history.back(); // go back one entry
history.forward(); // go forward one entry
history.go(-2); // go back two entries
history.go(2); // go forward two entries
history.go(0); // reload current page
if (history.length === 1) {
console.log('First page in this tab');
}
</script>Routage SPA
Un routeur SPA minimal : interceptez les clics des liens internes, pushState pour mettre à jour l'URL, et rendez la nouvelle vue. Gérez popstate pour que retour/avance fonctionne. Employez data-link ou une classe pour marquer les liens internes, et sautez les liens externes ou target=_blank. Les vrais frameworks ajoutent routes imbriquées, params, guards et restauration du scroll.
<script>
document.body.addEventListener('click', (e) => {
const a = e.target.closest('a');
if (!a || !a.matches('[data-link]')) return;
if (a.origin !== location.origin) return;
e.preventDefault();
history.pushState({ path: a.pathname }, '', a.pathname);
render(a.pathname);
});
window.addEventListener('popstate', () => render(location.pathname));
function render(path) {
fetch(path, { headers: { 'X-Ajax': '1' } })
.then((r) => r.text())
.then((html) => {
document.querySelector('#app').innerHTML = html;
});
}
</script>Éléments sémantiques en ligne
Élément time
time représente une date, heure ou durée précise. La valeur lisible par machine va dans l'attribut datetime (AAAA-MM-JJ, HH:MM ou ISO 8601 complet avec fuseau) ; le texte lisible par humain est le contenu. Les moteurs de recherche et apps calendrier emploient datetime pour extraire des événements. Sans datetime, le contenu lui-même doit être une chaîne de date valide.
<p>
Published on
<time datetime="2024-07-04">July 4, 2024</time>.
</p>
<p>
Event starts at
<time datetime="2024-07-04T19:00-05:00">7 PM EST</time>.
</p>
<p>
Open
<time datetime="09:00">9:00 AM</time>-
<time datetime="17:00">5:00 PM</time> daily.
</p>Élément mark
mark surligne du texte comme pertinent au contexte courant de l'utilisateur, comme les correspondances de termes de recherche ou des notes ajoutées par l'utilisateur. Contrairement à strong ou em il ne porte pas d'emphase sémantique — juste un surlignage visuel. Le style par défaut est un fond jaune. Utile aussi dans les blockquotes pour marquer le texte que le citateur veut mettre en avant.
<p>
The function <code>querySelector()</code> returns the
first match, while <mark>querySelectorAll()</mark>
returns a static NodeList.
</p>
<p>
Search results: <mark>HTML5</mark> is the latest
version of the Hypertext Markup Language.
</p>details et summary
details crée un widget de divulgation que l'utilisateur peut déplier ou replier — sans JS. summary est le label toujours visible ; cliquez-le pour basculer. Ajoutez l'attribut open pour déplier par défaut. L'événement toggle se déclenche à l'ouverture ou fermeture. Parfait pour FAQ, réglages avancés et divulgation progressive du contenu.
<details>
<summary>What is HTML5?</summary>
<p>HTML5 is the fifth major revision of the HTML standard,
introducing semantic elements, new form controls, and APIs
for graphics, media, and offline apps.</p>
</details>
<details open>
<summary>System requirements</summary>
<ul>
<li>Modern browser (Chrome, Firefox, Safari, Edge)</li>
<li>JavaScript enabled</li>
</ul>
</details>Élément dialog
dialog représente une boîte modale ou non modale. show() l'ouvre non modalement ; showModal() l'ouvre modalement avec un fond et le reste de la page inerte. method='dialog' sur un formulaire ferme le dialogue et règle returnValue à la valeur du bouton cliqué. L'événement close se déclenche après fermeture. ::backdrop style l'overlay.
<button onclick="dlg.showModal()">Open dialog</button>
<dialog id="dlg">
<form method="dialog">
<p>Are you sure?</p>
<menu>
<button value="cancel">Cancel</button>
<button value="confirm">OK</button>
</menu>
</form>
</dialog>
<script>
const dlg = document.getElementById('dlg');
dlg.addEventListener('close', () => {
console.log('User chose:', dlg.returnValue);
});
</script>abbr, cite et q
abbr développe les abréviations via title (info-bulle au survol) et aide les lecteurs d'écran. cite marque le titre d'une œuvre (livre, article, film) — pas l'auteur. q est une citation en ligne (les navigateurs ajoutent les guillemets) ; blockquote est pour le niveau bloc. dfn marque l'instance de définition d'un terme ; les usages suivants peuvent y renvoyer avec un a.
<p>
<abbr title="World Health Organization">WHO</abbr>
was founded in 1948.
</p>
<p>
As <cite>MDN Web Docs</cite> notes,
<q>HTML is the standard markup language.</q>
</p>
<p>
Use <dfn>semantics</dfn> to describe the meaning of
content, then refer to it normally.
</p>Design responsif
Meta viewport
La balise meta viewport dit aux navigateurs mobiles d'employer la largeur de l'appareil comme viewport de mise en page et de démarrer à l'échelle 1. Sans elle, les téléphones prétendent être larges de 980px. initial-scale=1 prévient le zoom au chargement. viewport-fit=cover permet d'employer la zone d'encoche avec env(safe-area-inset-*). Évitez user-scalable=no — cela casse l'accessibilité.
<head>
<meta name="viewport"
content="width=device-width, initial-scale=1, viewport-fit=cover">
</head>
<!-- Without this tag, mobile browsers render the page at a
~980px "desktop" width and shrink it down, making text
unreadable. -->
<!-- viewport-fit=cover lets content extend into the notch
area on iPhone X+. -->Élément picture
picture permet de servir différentes images selon des conditions médias (direction artistique). Le navigateur choisit la première source dont le media matche et ignore le reste. L'img est obligatoire comme repli et porte le texte alt. Employez-le quand il faut recadrer ou changer entièrement l'image par breakpoint, pas seulement la redimensionner.
<picture>
<!-- Art direction: different image per viewport -->
<source media="(min-width: 800px)" srcset="wide.jpg">
<source media="(orientation: portrait)" srcset="tall.jpg">
<img src="default.jpg" alt="A responsive photo">
</picture>
<!-- Browser picks the first matching <source>,
falling back to the <img>. -->srcset et sizes
srcset liste des candidats d'image avec leur largeur intrinsèque (480w = 480px de large). sizes dit au navigateur quelle largeur l'image occupera à chaque breakpoint. Le navigateur choisit alors le meilleur candidat selon la fenêtre et le pixel ratio de l'appareil — sans JS. Employez-le quand la même image n'exige que des résolutions différentes.
<img src="small.jpg"
srcset="small.jpg 480w,
medium.jpg 800w,
large.jpg 1200w"
sizes="(max-width: 600px) 100vw,
(max-width: 1200px) 50vw,
33vw"
alt="A responsive photo">Unités de viewport
vw et vh sont des pourcentages de la largeur/hauteur de la fenêtre. Sur mobile, 100vh peut inclure la barre d'URL, causant des sauts — préférez dvh (dynamique), svh (petit) ou lvh (grand). clamp(min, préféré, max) est la façon la plus propre de faire une typographie fluide ni trop petite ni trop grande. vmin/vmax emploient la dimension la plus petite/grande.
<style>
.hero { height: 100vh; } /* full viewport height */
.half { width: 50vw; } /* half the viewport width */
/* Responsive typography */
h1 {
font-size: clamp(1.5rem, 4vw + 1rem, 3rem);
}
/* Use dvh/svh/lvh to handle mobile browser UI bars */
.hero { height: 100dvh; }
</style>Picture avec type
source avec type permet de servir des formats d'images modernes avec un repli JPEG/PNG. Le navigateur choisit le premier type qu'il gère, en ignorant le reste. AVIF et WebP offrent des fichiers 30-50% plus petits que JPEG à qualité égale. Combiné à loading='lazy' sur l'img, c'est la façon la plus efficace de livrer des images.
<picture>
<!-- Modern format first, smaller file size -->
<source type="image/avif" srcset="photo.avif">
<source type="image/webp" srcset="photo.webp">
<img src="photo.jpg" alt="Optimized photo" loading="lazy">
</picture>
<!-- Browser picks the first type it supports.
AVIF and WebP are ~30-50% smaller than JPEG/PNG. -->Accessibilité (ARIA)
Rôles ARIA
Les rôles ARIA disent aux technologies d'assistance ce que fait un élément, mais la première règle d'ARIA est : ne l'employez pas si un élément HTML natif existe. header, nav, main, article, footer exposent déjà les rôles banner, navigation, main, article, contentinfo. Employez ARIA pour les widgets personnalisés (tab, dialog, slider, menu) sans équivalent natif, et associez les rôles au support clavier.
<div role="banner"> <!-- like <header> -->
<h1>Site title</h1>
</div>
<div role="navigation"> <!-- like <nav> -->
<a href="/">Home</a>
</div>
<div role="main"> <!-- like <main> -->
<div role="article"> <!-- like <article> -->
<p>Content</p>
</div>
</div>
<button role="button" aria-pressed="false">Toggle</button>aria-label et aria-labelledby
aria-label fournit un nom accessible quand aucun texte visible n'existe (boutons à icône seule, etc.). aria-labelledby référence l'id d'un texte visible à employer comme nom — utile quand un titre étiquette déjà une section. Préférez un <label for> visible pour les champs de formulaire. aria-describedby pointe vers un texte d'indication lu après le label.
<button aria-label="Close menu">×</button>
<nav aria-labelledby="main-nav-heading">
<h2 id="main-nav-heading" class="sr-only">Main navigation</h2>
<ul>...</ul>
</nav>
<input id="email" type="email">
<label id="email-label" for="email">Email address</label>
<!-- aria-labelledby="email-label" would also work -->aria-hidden
aria-hidden='true' retire un élément de l'arbre d'accessibilité — employez-le pour les icônes purement décoratives, le texte dupliqué ou le contenu hors écran qui ne doit pas être annoncé. Ne masquez jamais d'éléments focalisables. Le pattern .sr-only cache le texte visuellement tout en le gardant pour les lecteurs d'écran — essentiel pour les labels qui doivent être dits mais pas vus.
<!-- Decorative icon: hide from screen readers -->
<svg aria-hidden="true" focusable="false">
<use href="#icon-check"></use>
</svg>
<!-- Visually hidden but still announced -->
<span class="sr-only">3 new messages</span>
<style>
.sr-only {
position: absolute;
width: 1px; height: 1px;
padding: 0; margin: -1px;
overflow: hidden;
clip: rect(0, 0, 0, 0);
white-space: nowrap; border: 0;
}
</style>Régions aria-live
aria-live marque les régions dont les mises à jour doivent être annoncées automatiquement. polite attend une pause ; assertive interrompt. role='alert' implique assertive et est le standard des messages d'erreur. aria-atomic='true' annonce toute la région au changement ; aria-relevant contrôle quels changements sont énoncés. Avec parcimonie — l'abus rend les interfaces bruyantes.
<!-- Polite: announce when screen reader is idle -->
<div aria-live="polite" id="status">Saving...</div>
<!-- Assertive: announce immediately, may interrupt -->
<div aria-live="assertive" role="alert" id="error"></div>
<script>
function show(msg) {
document.getElementById('status').textContent = msg;
}
function fail(msg) {
document.getElementById('error').textContent = msg;
}
</script>Gestion du focus
Les utilisateurs clavier naviguent par Tab ; le focus doit toujours être visible et logique. :focus-visible style le focus seulement pour le clavier, pas la souris. À l'ouverture d'une modale, déplacez le focus dedans ; à la fermeture, rendez-le au déclencheur. Piégez Tab dans la modale pour que le focus ne s'échappe pas vers le contenu caché. Ne réglez jamais tabindex > 0 ; employez 0 pour rendre les éléments focalisables et -1 pour les rendre focalisables par programme.
<style>
:focus-visible {
outline: 3px solid #3498db;
outline-offset: 2px;
}
</style>
<script>
// Move focus into a modal
function openModal(dlg) {
dlg.showModal();
dlg.querySelector('input, button').focus();
}
// Trap focus inside the modal (simplified)
// Restore focus to the trigger on close
const trigger = document.activeElement;
dlg.addEventListener('close', () => trigger.focus());
</script>Liens d'évitement
Un lien d'évitement est le premier élément focalisable de la page et laisse les utilisateurs clavier sauter la navigation répétitive pour atteindre le contenu principal. Il est caché visuellement jusqu'au focus. Essentiel pour l'accessibilité — critère de succès WCAG 2.1 2.4.1. Associez-le à un repère <main id='main'> pour que la cible soit claire.
<body>
<a href="#main" class="skip-link">Skip to main content</a>
<header>...nav with 30 links...</header>
<main id="main">...</main>
</body>
<style>
.skip-link {
position: absolute;
left: -999px;
top: 0;
background: #000; color: #fff;
padding: 8px 16px;
z-index: 1000;
}
.skip-link:focus {
left: 0;
}
</style>Web Components
Custom Elements
customElements.define(name, class) enregistre un élément personnalisé. Le nom doit contenir un tiret. Héritez d'HTMLElement pour les éléments autonomes, ou d'une classe précise comme HTMLButtonElement (avec is='name') pour étendre un élément intégré. Les custom elements sont le fondement des web components — UI réutilisable et indépendante des frameworks.
<script>
class MyButton extends HTMLElement {
constructor() {
super();
this.addEventListener('click', () => {
console.log('Custom button clicked');
});
}
}
customElements.define('my-button', MyButton);
// Autonomous element: extends HTMLElement
// Customized built-in: extends HTMLButtonElement
// <button is="my-button">
</script>
<my-button>Click me</my-button>Shadow DOM
attachShadow({ mode: 'open' }) crée un arbre DOM encapsulé attaché à l'élément. Les styles et ids de l'arbre d'ombre ne fuient pas dehors, et les styles de page ne fuient pas dedans (sauf propriétés héritables). :host vise l'élément hôte ; ::slotted() style les enfants insérés. mode: 'closed' bloque l'accès externe au shadowRoot — rarement nécessaire.
<script>
class FancyCard extends HTMLElement {
constructor() {
super();
const shadow = this.attachShadow({ mode: 'open' });
shadow.innerHTML = `
<style>
:host { display: block; padding: 16px;
background: #f4f4f4; border-radius: 8px; }
::slotted(*) { color: #333; }
</style>
<div class="card">
<slot></slot>
</div>
`;
}
}
customElements.define('fancy-card', FancyCard);
</script>Templates HTML
L'élément template porte du HTML inerte, parsé mais non rendu tant qu'il n'est pas cloné. Accédez à son contenu via template.content, puis cloneNode(true) et append. Les templates sont parfaits pour les structures répétées et forment le versant balisage des web components. Contrairement à innerHTML, les templates peuvent contenir <tr>, <td>, <option> et d'autres éléments aux particularités de parsing.
<template id="row-template">
<tr>
<td class="name"></td>
<td class="age"></td>
</tr>
</template>
<script>
const tpl = document.getElementById('row-template');
const tbody = document.querySelector('tbody');
function addRow(name, age) {
const clone = tpl.content.cloneNode(true);
clone.querySelector('.name').textContent = name;
clone.querySelector('.age').textContent = age;
tbody.appendChild(clone);
}
addRow('Ada', 36);
</script>Slots
Les slots laissent les consommateurs passer des enfants du light-DOM à des endroits précis de l'arbre d'ombre. Un <slot name='x'> reçoit les enfants avec slot='x' ; un <slot> sans nom reçoit le reste. Les enfants insérés restent dans le light DOM — le slot n'est qu'un point d'insertion. Écoutez slotchange sur le slot pour réagir quand les nœuds insérés changent.
<fancy-card>
<h2 slot="title">Card Title</h2>
<p>Body text goes here.</p>
</fancy-card>
<!-- Inside the shadow DOM of <fancy-card>: -->
<template>
<div class="card">
<slot name="title"></slot>
<div class="body"><slot></slot></div>
</div>
</template>Callbacks de cycle de vie
Les éléments personnalisés ont des callbacks de cycle de vie : connectedCallback (inséré dans le DOM), disconnectedCallback (retiré), attributeChangedCallback (seulement pour les attributs listés dans observedAttributes) et adoptedCallback (déplacé vers un nouveau document). Le constructeur tourne à la création — gardez-le léger. Faites la mise en place dans connectedCallback, le nettoyage dans disconnectedCallback. La mise à niveau se fait automatiquement pour les éléments déjà dans le DOM quand define() est appelé.
<script>
class Observed extends HTMLElement {
static get observedAttributes() {
return ['count', 'label'];
}
constructor() { super(); }
connectedCallback() {
console.log('Added to DOM');
}
disconnectedCallback() {
console.log('Removed from DOM');
}
attributeChangedCallback(name, oldVal, newVal) {
console.log(name, 'changed', oldVal, '->', newVal);
}
}
customElements.define('observed-el', Observed);
</script>Applications hors ligne
Enregistrement du Service Worker
Un service worker est un script que le navigateur exécute en arrière-plan, séparé de la page, permettant le support hors ligne, les notifications push et la synchronisation en arrière-plan. Enregistrez-le depuis un script de page ; le fichier SW doit être servi en HTTPS (ou localhost) et sa portée est son répertoire par défaut. Une fois installé, il contrôle le chargement des pages via les événements fetch.
<script>
if ('serviceWorker' in navigator) {
window.addEventListener('load', () => {
navigator.serviceWorker
.register('/sw.js', { scope: '/' })
.then((reg) => console.log('SW registered', reg.scope))
.catch((err) => console.error('SW failed', err));
});
}
</script>API Cache
L'API Cache stocke des paires Request/Response, persistées entre sessions. Dans l'événement install, pré-cachez les ressources critiques. Dans l'événement fetch, répondez d'abord depuis le cache puis repliez vers le réseau (stratégie cache-first). Autres stratégies : network-first, stale-while-revalidate, cache-only, network-only. Augmentez le nom du cache pour invalider les vieilles entrées.
// sw.js
const CACHE = 'app-v1';
const ASSETS = ['/', '/styles.css', '/app.js', '/offline.html'];
self.addEventListener('install', (e) => {
e.waitUntil(
caches.open(CACHE).then((c) => c.addAll(ASSETS))
);
});
self.addEventListener('fetch', (e) => {
e.respondWith(
caches.match(e.request).then((r) => r || fetch(e.request))
);
});Repli hors ligne
Une stratégie network-first avec repli hors ligne essaie le réseau, puis le cache, puis une page hors ligne générique. L'événement activate tourne après la fin de l'install et est le bon endroit pour supprimer les vieux caches — sinon ils s'accumulent. Les clients peuvent réclamer les onglets existants immédiatement avec self.clients.claim() dans activate.
// sw.js
self.addEventListener('fetch', (e) => {
e.respondWith(
fetch(e.request).catch(() =>
caches.match(e.request).then((r) =>
r || caches.match('/offline.html')
)
)
);
});
// Activate event: clean up old caches
self.addEventListener('activate', (e) => {
e.waitUntil(
caches.keys().then((keys) =>
Promise.all(
keys.filter((k) => k !== 'app-v1')
.map((k) => caches.delete(k))
)
)
);
});Manifest d'app web
Un manifest d'app web est un fichier JSON décrivant comment l'app doit paraître une fois installée sur l'écran d'accueil. name/short_name, icons, start_url et display (standalone, fullscreen, minimal-ui, browser) sont les champs clés. Combiné à un service worker, un manifest rend l'app installable (PWA). theme_color affecte l'habillage de l'UI de l'OS.
<!-- index.html -->
<link rel="manifest" href="manifest.json">
<!-- manifest.json -->
{
"name": "My App",
"short_name": "App",
"start_url": "/",
"display": "standalone",
"background_color": "#ffffff",
"theme_color": "#3498db",
"icons": [
{ "src": "/icon-192.png", "sizes": "192x192", "type": "image/png" },
{ "src": "/icon-512.png", "sizes": "512x512", "type": "image/png" }
]
}Background Sync
Background Sync (enregistré via navigator.serviceWorker.ready.then(r => r.sync.register('tag'))) diffère le travail jusqu'à ce que l'utilisateur ait une connectivité. Le navigateur déclenche un événement sync dans le service worker au retour du réseau — même si la page est fermée. Employez-le pour envoyer des soumissions de formulaires en file, des messages ou de l'analytique. tag identifie la sync ; les doublons se fusionnent.
// sw.js
self.addEventListener('sync', (e) => {
if (e.tag === 'send-messages') {
e.waitUntil(sendQueuedMessages());
}
});
async function sendQueuedMessages() {
const queue = await getQueue();
for (const msg of queue) {
try { await fetch('/api/send', { method: 'POST', body: msg }); }
catch (e) { throw e; } // retry later
}
}Bonnes pratiques SEO
Title et meta description
Le title (moins de ~60 caractères) est le signal SEO sur page le plus important et apparaît comme le titre du résultat de recherche. La meta description (moins de ~160 caractères) est le texte d'extrait — elle n'affecte pas le classement mais le taux de clic. Employez un title par page, incluez le mot-clé principal, rendez-le accrocheur. canonical prévient les problèmes de contenu dupliqué.
<head>
<title>HTML5 Cheatsheet - Semantic Elements & APIs</title>
<meta name="description"
content="A quick reference to HTML5 semantic elements,
form types, and browser APIs with examples.">
<meta name="robots" content="index, follow">
<link rel="canonical" href="https://example.com/html5">
</head>Open Graph et Twitter Cards
Les tags Open Graph contrôlent l'apparence de votre page en partage sur Facebook, LinkedIn, Slack et la plupart des plateformes sociales. og:image devrait faire 1200x630px. Les Twitter Cards emploient un jeu semblable avec les préfixes twitter: (ou replient vers OG). Sans eux, les partages obtiennent une image d'aperçu aléatoire ou absente, réduisant fortement le taux de clic.
<head>
<!-- Open Graph (Facebook, LinkedIn, etc.) -->
<meta property="og:title" content="HTML5 Cheatsheet">
<meta property="og:description" content="Quick HTML5 reference.">
<meta property="og:image" content="https://example.com/og.png">
<meta property="og:url" content="https://example.com/html5">
<meta property="og:type" content="article">
<!-- Twitter Card -->
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:site" content="@example">
</head>Canonical et hreflang
rel='canonical' indique aux moteurs quelle URL est la version maîtresse quand plusieurs URLs ont un contenu semblable (impression, tri, paramètres de requête) — prévenant les pénalités de contenu dupliqué. hreflang pointe vers les versions traduites ou régionales pour que Google serve la bonne. Incluez toujours un x-default pour les locales non appariées. Les deux doivent être des URLs absolues.
<head>
<!-- Canonical: the master URL for duplicate content -->
<link rel="canonical" href="https://example.com/article">
<!-- hreflang: language/region alternatives -->
<link rel="alternate" hreflang="en" href="https://example.com/en/article">
<link rel="alternate" hreflang="es" href="https://example.com/es/article">
<link rel="alternate" hreflang="x-default" href="https://example.com/article">
</head>Données structurées (JSON-LD)
Les données structurées JSON-LD décrivent votre page dans un format lisible par machine (vocabulaire schema.org) et activent les résultats enrichis de recherche : carrousels d'articles, fils d'Ariane, FAQ, avis, événements, produits. Placez-les dans un <script type='application/ld+json'>. Validez avec le Rich Results Test de Google. Cela ne booste pas directement le classement mais améliore l'apparence des résultats.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "HTML5 Cheatsheet",
"author": { "@type": "Person", "name": "Ada" },
"datePublished": "2024-07-04",
"image": "https://example.com/cover.png",
"publisher": {
"@type": "Organization",
"name": "Example"
}
}
</script>Titres sémantiques
Les moteurs de recherche et lecteurs d'écran emploient les titres pour comprendre le plan de la page. Employez un h1 (le titre de la page), puis h2 pour les sections majeures, h3 pour les sous-sections — ne sautez jamais de niveaux (pas de h2 direct à h4). Ne choisissez pas un titre pour sa taille ; employez le CSS pour le style. Une hiérarchie de titres logique améliore SEO et accessibilité.
<article>
<h1>Article Title (only one h1 per page)</h1>
<p>Intro paragraph.</p>
<section>
<h2>First major section</h2>
<p>Content...</p>
<h3>Subsection</h3>
<p>Detail...</p>
</section>
<section>
<h2>Second major section</h2>
<p>Content...</p>
</section>
</article>Optimisation des performances
preload
rel='preload' dit au navigateur de récupérer à haute priorité une ressource dont la page courante aura besoin, avant sa découverte normale. Précisez toujours as (font, style, script, image, fetch, etc.) pour que le navigateur applique les bonnes priorités et la CSP. Les polices exigent crossorigin. Employez preload seulement pour les ressources vraiment critiques — l'abus gaspille la bande passante.
<head>
<!-- Preload critical resources for the current page -->
<link rel="preload" href="/fonts/main.woff2"
as="font" type="font/woff2" crossorigin>
<link rel="preload" href="/css/critical.css" as="style">
<link rel="preload" href="/js/app.js" as="script">
<!-- Preload a hero image -->
<link rel="preload" href="/hero.webp" as="image">
</head>prefetch et preconnect
preconnect achève DNS, TCP et TLS vers une origine en avance, économisant ~100-300ms quand la vraie requête survient — employez-le pour les domaines tiers critiques. dns-prefetch est la version légère (DNS seulement). prefetch récupère à basse priorité une ressource pour une navigation suivante probable. Avec parcimonie : trop de preconnects gaspillent des sockets, et les ressources pré-récupérées peuvent rester inutilisées.
<head>
<!-- preconnect: early handshake to a third-party origin -->
<link rel="preconnect" href="https://cdn.example.com">
<link rel="preconnect" href="https://api.example.com" crossorigin>
<!-- dns-prefetch: just DNS lookup, lighter -->
<link rel="dns-prefetch" href="https://cdn.example.com">
<!-- prefetch: fetch a resource for the NEXT navigation -->
<link rel="prefetch" href="/next-page.html">
</head>Chargement paresseux
loading='lazy' sur img et iframe diffère le chargement jusqu'à l'approche du viewport — économisant bande passante et CPU au rendu initial. decoding='async' empêche le décodage d'image de bloquer le thread principal. Réglez toujours width/height pour éviter le décalage de mise en page. Employez loading='eager' (défaut) et fetchpriority='high' seulement pour les images vedettes au-dessus de la ligne de flottaison. Géré par tous les navigateurs modernes.
<!-- Native lazy loading (no JS needed) -->
<img src="photo.jpg" loading="lazy" decoding="async" alt="...">
<iframe src="embed.html" loading="lazy"></iframe>
<!-- Eager (default) loads immediately -->
<img src="hero.jpg" loading="eager" fetchpriority="high" alt="Hero">
<!-- Defer non-critical images until they near the viewport -->
<img src="below-fold.jpg" loading="lazy" width="800" height="600" alt="">defer et async
Un <script> simple bloque l'analyse HTML pendant son téléchargement et exécution. async télécharge en parallèle et s'exécute dès qu'il est prêt — employez-le pour les scripts indépendants (analytique, pubs) où l'ordre n'importe pas. defer télécharge en parallèle mais attend pour s'exécuter, dans l'ordre, après l'analyse du document — employez-le pour les scripts principaux qui dépendent du DOM. Les scripts defer s'exécutent avant DOMContentLoaded.
<head>
<!-- async: download in parallel, run ASAP (order not guaranteed) -->
<script src="analytics.js" async></script>
<!-- defer: download in parallel, run after parse, in order -->
<script src="app.js" defer></script>
<script src="page.js" defer></script>
<!-- Classic: block parsing to download and run -->
<script src="blocking.js"></script>
</head>Résumé des indices de ressources
preload (page courante), prefetch (page suivante), preconnect (poignée de main d'origine) et dns-prefetch (DNS seulement) sont les indices de ressources principaux. prerender est déprécié au profit de l'API Speculation Rules, qui peut pré-rendre entièrement des pages pour une navigation instantanée. Appliquez les indices selon le comportement réel des utilisateurs — trop d'indices gaspillent des données et peuvent nuire à la performance.
<head>
<link rel="preload" href="/critical.woff2" as="font" crossorigin>
<link rel="preconnect" href="https://cdn.example.com">
<link rel="dns-prefetch" href="https://cdn.example.com">
<link rel="prefetch" href="/next-page.html">
<!-- Speculation Rules API (Chrome) -->
<script type="speculationrules">
{ "prerender": [{ "where": { "href_matches": "/next/*" } }] }
</script>
</head>Rendu critique
Inliner le CSS critique du contenu au-dessus de la ligne de flottaison retire la requête bloquante de rendu et améliore le First Contentful Paint. Chargez le reste via preload+swap. content-visibility: auto laisse le navigateur sauter le rendu des sections hors écran, améliorant fortement la performance de défilement des longues pages — associez contain-intrinsic-size pour réserver l'espace et éviter les à-coups de barre de défilement.
<head>
<!-- Inline critical CSS for above-the-fold -->
<style>
body { margin: 0; font: system-ui; }
.hero { height: 60vh; background: #3498db; }
</style>
<!-- Load the rest asynchronously -->
<link rel="preload" href="/full.css" as="style" onload="this.rel='stylesheet'">
<noscript><link rel="stylesheet" href="/full.css"></noscript>
</head>
<body>
<!-- Use content-visibility to skip off-screen rendering -->
<section style="content-visibility: auto; contain-intrinsic-size: 500px;">
Heavy content here
</section>
</body>Snippets HTML5 associés
Copy-paste ready code for common tasks.
Semantic Elements
Structure a page with header, nav, main, article, and footer.
Form Input Types
Use native HTML5 input types, validation, and datalist.
Canvas Basics
Draw shapes, lines, and text on a 2D canvas.
Video & Audio
Embed media with multiple sources and control playback.
Local & Session Storage
Persist data in the browser with the Web Storage API.
Geolocation
Get the user's position and watch for changes.
Drag and Drop
Accept dropped files with the Drag and Drop API.
Web Workers
Run heavy computation on a background thread.
Was this helpful?