Structure de base
Squelette de document SVG
L'attribut xmlns déclare le namespace SVG. width/height fixent la taille rendue en pixels. viewBox définit le système de coordonnées interne. Un SVG peut être un fichier .svg autonome ou intégré en ligne dans le HTML, où la déclaration XML et xmlns sont optionnelles.
<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg"
width="200" height="200"
viewBox="0 0 200 200">
<!-- SVG content goes here -->
<rect x="0" y="0" width="200" height="200" fill="#eee"/>
</svg>Intégrer du SVG dans le HTML
Le SVG en ligne est le plus flexible — on peut le styliser en CSS et le scripter en JS comme du HTML. <img> et background-image traitent le SVG comme image statique (pas de CSS/JS interne). <object> le charge comme document séparé avec son propre DOM, permettant du scripting partiel.
<!-- 1. Inline (best for styling and scripting) -->
<svg width="100" height="100">
<circle cx="50" cy="50" r="40" fill="red"/>
</svg>
<!-- 2. As an image (no CSS/JS interaction) -->
<img src="icon.svg" alt="Icon" width="100" height="100">
<!-- 3. As a background (limited styling) -->
<div style="background: url('icon.svg') no-repeat;"></div>
<!-- 4. Via object/embed (allows scripting) -->
<object data="icon.svg" type="image/svg+xml"></object>Système de coordonnées
SVG utilise un système de coordonnées main gauche : origine en haut à gauche, X vers la droite, Y vers le bas. L'attribut viewBox définit l'espace de coordonnées interne — le SVG met à l'échelle le contenu pour remplir la width/height de l'élément, donc un viewBox de 0 0 100 100 dans un élément de 200px rend tout à 2x.
<svg width="200" height="100" viewBox="0 0 200 100">
<!-- Origin (0,0) is top-left, like Canvas -->
<!-- X increases rightward, Y increases downward -->
<!-- A point at (50, 25) -->
<circle cx="50" cy="25" r="3" fill="black"/>
<!-- The viewBox stretches content to fill width/height -->
<!-- viewBox="minX minY width height" -->
</svg>
<!-- viewBox 0 0 100 100 in a 200x200 element = 2x zoom -->
<svg width="200" height="200" viewBox="0 0 100 100">
<circle cx="50" cy="50" r="50" fill="blue"/>
</svg>Width, height et unités
Les unités utilisateur (sans suffixe) équivalent aux px. Les pourcentages sont relatifs au parent. Pour un SVG responsive, omettez width/height et réglez viewBox — le SVG s'adapte à son conteneur en préservant le ratio d'aspect. 'auto' sur height avec un viewBox garde les proportions.
<svg width="200" height="100">
<!-- Default unit is the user unit (px equivalent) -->
</svg>
<!-- Common units: px, em, %, pt, cm, mm, in -->
<svg width="50%" height="auto" viewBox="0 0 100 100">
<!-- % is relative to the parent element -->
</svg>
<!-- No width/height + viewBox = fully responsive -->
<svg viewBox="0 0 100 100" style="width:100%;height:auto;">
<!-- Scales to container, preserves aspect ratio -->
</svg>Namespaces et xlink
SVG 2 a introduit le support direct de href sur <use>, <image> et <a>, dépréciant xlink:href. Les navigateurs modernes supportent le href simple. Gardez le namespace xlink seulement si vous devez supporter de très vieux navigateurs. Le SVG en ligne dans le HTML n'exige pas strictement l'attribut xmlns.
<svg xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink">
<!-- Modern SVG 2: use href directly -->
<use href="#icon"/>
<!-- Legacy SVG 1.1: use xlink:href -->
<use xlink:href="#icon"/>
</svg>
<!-- In HTML5 inline SVG, the xmlns is optional -->
<!-- But xlink namespace is needed if you use xlink:href -->Commentaires et métadonnées
<title> et <desc> fournissent du texte d'accessibilité lu par les lecteurs d'écran — incluez-les toujours pour des SVG significatifs. <metadata> héberge des données structurées (RDF, Dublin Core) pour l'outillage. Les commentaires utilisent la même syntaxe <!-- --> que le HTML.
<svg width="100" height="100" viewBox="0 0 100 100">
<!-- This is an XML comment (same as HTML) -->
<!-- Metadata is hidden from rendering -->
<metadata>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<dc:title xmlns:dc="http://purl.org/dc/elements/1.1/">My Icon</dc:title>
</rdf:RDF>
</metadata>
<!-- title and desc for accessibility -->
<title>Shopping Cart Icon</title>
<desc>A red shopping cart with 3 items</desc>
<circle cx="50" cy="50" r="40" fill="red"/>
</svg>Formes
Rectangle (rect)
rect exige x, y, width, height. rx/ry créent des coins arrondis (si seul rx est réglé, ry passe par défaut à rx). fill='none' rend l'intérieur transparent. stroke-width est centré sur le bord, donc la moitié déborde de la géométrie.
<svg width="200" height="100" viewBox="0 0 200 100">
<!-- Basic rectangle -->
<rect x="10" y="10" width="80" height="50" fill="steelblue"/>
<!-- Rounded corners -->
<rect x="110" y="10" width="80" height="50"
rx="10" ry="10" fill="tomato"/>
<!-- Stroked, no fill -->
<rect x="10" y="70" width="80" height="20"
fill="none" stroke="black" stroke-width="2"/>
</svg>Cercle et ellipse
circle se définit par centre (cx, cy) et rayon r. ellipse a des rx et ry séparés pour l'étirement. Les deux passent cx/cy à 0 si omis. Contrairement à rect, cercles et ellipses ne peuvent pas avoir de coins arrondis — ils sont déjà courbes.
<svg width="200" height="120" viewBox="0 0 200 120">
<!-- circle: cx, cy (center), r (radius) -->
<circle cx="50" cy="60" r="40" fill="gold"/>
<!-- ellipse: cx, cy, rx (x radius), ry (y radius) -->
<ellipse cx="150" cy="60" rx="50" ry="30" fill="mediumpurple"/>
<!-- Circle as an ellipse (rx == ry) -->
<ellipse cx="100" cy="20" rx="15" ry="15" fill="black"/>
</svg>Line
line relie deux points. Elle n'a pas de fill (seulement stroke). stroke-dasharray crée des lignes pointillées — le motif est 'longueur-trait,longueur-trou' répété. stroke-linecap (butt, round, square) contrôle les extrémités.
<svg width="200" height="100" viewBox="0 0 200 100">
<!-- line: x1,y1 (start) to x2,y2 (end) -->
<line x1="10" y1="10" x2="190" y2="10" stroke="black" stroke-width="2"/>
<!-- Diagonal line -->
<line x1="10" y1="90" x2="190" y2="10" stroke="red" stroke-width="3"/>
<!-- Dashed line -->
<line x1="10" y1="50" x2="190" y2="50"
stroke="blue" stroke-width="2" stroke-dasharray="10,5"/>
</svg>Polyline et polygon
polyline trace des segments connectés sans fermer la forme (le fill s'applique comme si fermée, mais aucun trait ne relie les extrémités). polygon se ferme automatiquement en reliant le dernier point au premier. points est une liste de paires x,y séparées par espaces ou virgules.
<svg width="200" height="120" viewBox="0 0 200 120">
<!-- polyline: open shape (no auto-close) -->
<polyline points="10,10 50,90 100,10 150,90 190,10"
fill="none" stroke="green" stroke-width="2"/>
<!-- polygon: closed shape (auto-connects last to first) -->
<polygon points="100,10 190,110 10,110"
fill="lime" stroke="black" stroke-width="1"/>
<!-- Star (polygon with 10 points) -->
<polygon points="50,5 61,38 95,38 67,58 78,90 50,70 22,90 33,58 5,38 39,38"
fill="gold" stroke="orange"/>
</svg>Attributs de forme courants
fill et stroke sont les deux principales propriétés de peinture. opacity affecte tout l'élément ; fill-opacity et stroke-opacity agissent indépendamment. stroke-linecap (butt/round/square) façonne les fins de ligne ; stroke-linejoin (miter/round/bevel) façonne les angles.
<svg width="200" height="100" viewBox="0 0 200 100">
<rect x="10" y="10" width="80" height="80"
fill="#3498db"
fill-opacity="0.5"
stroke="#2c3e50"
stroke-width="3"
stroke-opacity="0.8"
stroke-dasharray="5,3"
stroke-linecap="round"
stroke-linejoin="round"
opacity="0.9"/>
<!-- opacity affects the whole element -->
<!-- fill-opacity/stroke-opacity affect parts independently -->
</svg>Règles de remplissage (evenodd)
fill-rule détermine comment les régions qui se recouvrent d'une forme se remplissent. 'nonzero' (défaut) remplit selon le sens d'enroulement. 'evenodd' remplit les régions encloses un nombre impair de fois — créant l'effet classique « trou de donut » pour les chemins auto-intersectants et les polygones concentriques.
<svg width="200" height="100" viewBox="0 0 200 100">
<!-- Default fill-rule: nonzero -->
<polygon points="50,10 90,90 10,90 50,30 80,80 20,80"
fill="red" fill-rule="nonzero"/>
<!-- fill-rule: evenodd creates holes in overlapping shapes -->
<polygon points="150,10 190,90 110,90 150,30 180,80 120,80"
fill="blue" fill-rule="evenodd"/>
</svg>Path
Aperçu des commandes de path
L'élément <path> est la forme SVG la plus puissante — son attribut d contient une chaîne de commandes de dessin. Les commandes majuscules utilisent des coordonnées absolues ; les minuscules des coordonnées relatives à la position courante du stylo. M, L, C, Q, A, Z sont les commandes cœur.
<svg width="200" height="100" viewBox="0 0 200 100">
<!-- The d attribute contains all path commands -->
<path d="M 10 10 L 190 10 L 100 90 Z" fill="none" stroke="black"/>
<!-- Uppercase = absolute, lowercase = relative -->
<!-- M = moveto (lift pen, move) -->
<!-- L = lineto (draw straight line) -->
<!-- H = horizontal lineto, V = vertical lineto -->
<!-- C = cubic bezier, S = smooth cubic -->
<!-- Q = quadratic bezier, T = smooth quadratic -->
<!-- A = arc, Z = closepath -->
</svg>M, L, H, V, Z (lignes)
M déplace le stylo sans dessiner. L trace vers un point. H/V tracent des lignes horizontales/verticales (une coordonnée). Z referme le chemin vers le départ. Les versions minuscules (l, h, v, z) interprètent les coordonnées comme des offsets depuis la position courante, rendant les sous-chemins réutilisables.
<svg width="200" height="120" viewBox="0 0 200 120">
<!-- M = moveto, L = lineto, Z = close path -->
<path d="M 10 10 L 190 10 L 190 110 L 10 110 Z"
fill="none" stroke="black"/>
<!-- H = horizontal line, V = vertical line (one coord each) -->
<path d="M 10 60 H 190" stroke="red"/>
<!-- Relative commands (lowercase): coords are offsets -->
<path d="M 10 80 l 30 -20 l 30 20 l 30 -20 l 30 20"
fill="none" stroke="blue"/>
<!-- Multiple M's create subpaths (disconnected segments) -->
<path d="M 10 100 L 50 100 M 100 100 L 150 100" stroke="green"/>
</svg>C et S (bezier cubique)
C trace une bezier cubique avec deux points de contrôle qui tirent la courbe. Le premier contrôle (x1,y1) affecte la tangente de départ ; le second (x2,y2) la tangente d'arrivée. S continue en douceur en miroir du second point de contrôle de la courbe précédente — ne spécifiez que le nouveau second contrôle et le point final.
<svg width="240" height="120" viewBox="0 0 240 120">
<!-- C = cubic bezier: two control points + endpoint -->
<!-- C x1 y1, x2 y2, x y -->
<path d="M 10 60 C 60 10, 180 110, 230 60"
fill="none" stroke="red" stroke-width="2"/>
<!-- S = smooth cubic: control point mirrors the previous -->
<!-- S x2 y2, x y (first control point is auto-mirrored) -->
<path d="M 10 100 C 60 50, 100 50, 120 100 S 200 150, 230 100"
fill="none" stroke="blue" stroke-width="2"/>
<!-- Multiple cubics in one path -->
<path d="M 10 20 C 40 0, 70 40, 100 20 C 130 0, 160 40, 190 20"
fill="none" stroke="green"/>
</svg>Q et T (bezier quadratique)
Q utilise un seul point de contrôle au lieu de deux — plus simple mais moins flexible que C. T continue un Q en douceur par miroir de son point de contrôle, n'exigeant que le point final. Les courbes quadratiques sont courantes dans les glyphes de polices et les chemins d'icônes simples où un seul point de contrôle suffit.
<svg width="200" height="120" viewBox="0 0 200 120">
<!-- Q = quadratic bezier: one control point + endpoint -->
<!-- Q x1 y1, x y -->
<path d="M 10 100 Q 100 0, 190 100"
fill="none" stroke="purple" stroke-width="2"/>
<!-- T = smooth quadratic: control point auto-mirrored -->
<path d="M 10 60 Q 50 20, 90 60 T 170 60"
fill="none" stroke="orange" stroke-width="2"/>
<!-- Q is simpler than C but less precise — good for curves -->
<!-- with a single bend, like basic arcs and waves -->
</svg>A (arc)
A trace un arc elliptique. rx, ry sont les rayons ; x-rotation incline l'ellipse. large-arc-flag (0/1) choisit l'arc court ou long entre les points. sweep-flag (0/1) choisit le sens antihoraire ou horaire. Les arcs sont délicats — beaucoup de designers utilisent des courbes C à la place pour la prévisibilité.
<svg width="200" height="150" viewBox="0 0 200 150">
<!-- A rx ry, x-rotation, large-arc-flag, sweep-flag, x y -->
<path d="M 10 75 A 60 60, 0, 0, 1, 130 75"
fill="none" stroke="red" stroke-width="2"/>
<!-- large-arc-flag: 0 = small arc, 1 = large arc -->
<!-- sweep-flag: 0 = counterclockwise, 1 = clockwise -->
<!-- Large arc (the long way around) -->
<path d="M 10 75 A 60 60, 0, 1, 1, 130 75"
fill="none" stroke="blue" stroke-width="2"/>
<!-- Elliptical arc (rx != ry) -->
<path d="M 10 120 A 80 30, 0, 0, 0, 170 120"
fill="none" stroke="green" stroke-width="2"/>
</svg>Exemples de chemins pratiques
Les icônes réelles combinent M, L, C et Z pour tracer des formes. Le cœur utilise des beziers cubiques pour des courbes lisses. Le check n'est que trois points avec embouts ronds. La bulle de dialogue mêle des lignes H/V pour le rectangle et des commandes L pour la queue. Commencez simple, puis raffinez les points de contrôle.
<svg width="200" height="120" viewBox="0 0 200 120">
<!-- Heart shape -->
<path d="M 100 30
C 70 0, 20 20, 20 60
C 20 90, 60 110, 100 120
C 140 110, 180 90, 180 60
C 180 20, 130 0, 100 30 Z"
fill="red"/>
<!-- Checkmark -->
<path d="M 20 60 L 50 90 L 100 20"
fill="none" stroke="green" stroke-width="6"
stroke-linecap="round" stroke-linejoin="round"/>
<!-- Speech bubble (combines lines and curves) -->
<path d="M 20 20 H 180 V 80 H 60 L 40 100 L 45 80 H 20 Z"
fill="lightblue" stroke="navy"/>
</svg>Texte
Texte simple
La coordonnée y désigne par défaut la ligne de base du texte, pas le haut. text-anchor (start/middle/end) contrôle l'alignement horizontal relatif à x. dominant-baseline (auto/middle/hanging/...) contrôle l'alignement vertical. Les deux sont essentiels pour centrer le texte.
<svg width="200" height="100" viewBox="0 0 200 100">
<text x="10" y="50" font-family="Arial" font-size="24"
fill="black">Hello SVG!</text>
<!-- x, y sets the baseline position (y is the text baseline) -->
<!-- Use dominant-baseline to change the vertical anchor -->
<text x="100" y="50" font-size="20" fill="blue"
text-anchor="middle" dominant-baseline="middle">Centered</text>
</svg>Styliser le texte
Le texte SVG supporte la plupart des propriétés de police CSS comme attributs. font-family accepte les piles de polices standard. stroke sur le texte dessine un contour — utilisez un petit stroke-width pour ne pas masquer le fill. letter-spacing et word-spacing marchent comme en CSS.
<svg width="300" height="120" viewBox="0 0 300 120">
<text x="10" y="30"
font-family="Georgia, serif"
font-size="28"
font-weight="bold"
font-style="italic"
fill="darkblue"
stroke="navy"
stroke-width="0.5"
text-decoration="underline"
letter-spacing="2">Styled Text</text>
<!-- font-family uses CSS font stacks -->
<!-- font-weight: normal, bold, 100-900 -->
<!-- font-style: normal, italic, oblique -->
</svg>tspan (sous-texte)
<tspan> permet de styliser ou positionner différemment des parties du texte — comme <span> en HTML. dx/dy décalent relativement au caractère précédent ; x/y absolus sautent à une nouvelle position (utilisez x avec la valeur d'origine et dy pour les sauts de ligne). tspan est la façon de bâtir du texte multi-lignes en SVG.
<svg width="300" height="100" viewBox="0 0 300 100">
<text x="10" y="50" font-size="20" fill="black">
<tspan font-weight="bold" fill="red">Bold red</tspan>
<tspan dx="10" font-style="italic">italic</tspan>
<tspan x="10" dy="30">New line via dy</tspan>
<tspan dx="10" font-size="14">smaller</tspan>
</text>
<!-- dx/dy: relative offset from previous position -->
<!-- x/y: absolute position (useful for line breaks) -->
</svg>Texte sur un chemin
<textPath> rend du texte le long de n'importe quel élément path. Référencez le chemin par id via href (moderne) ou xlink:href (legacy). startOffset (une longueur ou pourcentage) positionne le texte le long du chemin. C'est la technique standard des étiquettes courbées sur arcs, cercles ou formes custom.
<svg width="300" height="150" viewBox="0 0 300 150">
<!-- Define a path (can be invisible) -->
<defs>
<path id="curve" d="M 20 100 Q 150 0, 280 100" fill="none"/>
</defs>
<!-- Text follows the path via xlink:href / href -->
<text font-size="20" fill="purple">
<textPath href="#curve">Text along a curved path!</textPath>
</text>
<!-- startOffset shifts where the text begins on the path -->
<text font-size="14" fill="gray">
<textPath href="#curve" startOffset="50%" text-anchor="middle">
Centered on path
</textPath>
</text>
</svg>Mode d'écriture et direction
writing-mode='tb' fait couler le texte de haut en bas (courant en typographie est-asiatique). direction='rtl' inverse l'ordre des caractères pour les scripts de droite à gauche. Pour une rotation arbitraire, utilisez l'attribut transform — rotate(angle, cx, cy) pivote autour du point (cx, cy).
<svg width="200" height="200" viewBox="0 0 200 200">
<!-- Vertical text (top-to-bottom) -->
<text x="50" y="20" writing-mode="tb" font-size="20">Vertical</text>
<!-- Right-to-left text -->
<text x="190" y="100" direction="rtl" font-size="20"
text-anchor="end">RTL text</text>
<!-- Rotated text (via transform) -->
<text x="100" y="100" font-size="20"
transform="rotate(45, 100, 100)">Rotated 45°</text>
</svg>Accessibilité du texte
Le texte SVG est sélectionnable et accessible par défaut, mais un SVG décoratif devrait porter <title> et <desc>. Pour du SVG en ligne utilisé comme élément d'UI, ajoutez role='img' et aria-label pour que les lecteurs d'écran annoncent le sens. Évitez de mettre l'information essentielle uniquement dans du texte SVG — le texte HTML est plus accessible.
<svg width="200" height="80" viewBox="0 0 200 80">
<title>Error Icon</title>
<desc>A red circle with a white exclamation mark</desc>
<!-- role and aria-label for screen readers -->
<text role="img" aria-label="Error: 3 items need attention"
x="100" y="45" text-anchor="middle"
font-size="24" fill="red">! Error</text>
</svg>Dégradés
Dégradé linéaire
linearGradient transitionne des couleurs le long d'une ligne. x1/y1 vers x2/y2 définissent la direction (0% 0% vers 100% 0% est gauche-droite). Les éléments <stop> définissent les points de couleur ; offset va de 0 à 100 % ou 0 à 1. Référencez le dégradé avec fill='url(#id)'. Les dégradés doivent vivre dans <defs>.
<svg width="200" height="100" viewBox="0 0 200 100">
<defs>
<linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="0%">
<stop offset="0%" stop-color="red"/>
<stop offset="50%" stop-color="yellow"/>
<stop offset="100%" stop-color="green"/>
</linearGradient>
</defs>
<rect x="10" y="10" width="180" height="80" fill="url(#grad1)"/>
</svg>Dégradé radial
radialGradient rayonne depuis un point central. cx/cy est le centre, r le rayon. fx/fy est le foyer (où commence la couleur à 0 %) — le décaler crée un effet de lumière directionnelle. Défauts : cx/cy à 50 %, r à 50 %, fx/fy en miroir de cx/cy.
<svg width="200" height="200" viewBox="0 0 200 200">
<defs>
<radialGradient id="grad2" cx="50%" cy="50%" r="50%" fx="50%" fy="50%">
<stop offset="0%" stop-color="white"/>
<stop offset="50%" stop-color="orange"/>
<stop offset="100%" stop-color="darkred"/>
</radialGradient>
</defs>
<circle cx="100" cy="100" r="90" fill="url(#grad2)"/>
</svg>Unités et propagation du dégradé
gradientUnits='objectBoundingBox' (défaut) rend les coordonnées relatives à chaque forme (0-1), donc le même dégradé s'adapte à tout élément. 'userSpaceOnUse' utilise les coordonnées SVG absolues, donc le dégradé se positionne dans le document — utile pour aligner des dégradés à travers plusieurs formes.
<svg width="300" height="100" viewBox="0 0 300 100">
<defs>
<!-- objectBoundingBox (default): coords are 0-1 relative to the shape -->
<linearGradient id="g1" x1="0" y1="0" x2="1" y2="0">
<stop offset="0" stop-color="blue"/>
<stop offset="1" stop-color="cyan"/>
</linearGradient>
<!-- userSpaceOnUse: coords are in the SVG's user units -->
<linearGradient id="g2" x1="0" y1="0" x2="200" y2="0"
gradientUnits="userSpaceOnUse">
<stop offset="0" stop-color="red"/>
<stop offset="1" stop-color="yellow"/>
</linearGradient>
<!-- spreadMethod: pad (default), reflect, repeat -->
<linearGradient id="g3" x1="0" y1="0" x2="0.3" y2="0"
spreadMethod="repeat">
<stop offset="0" stop-color="green"/>
<stop offset="1" stop-color="lime"/>
</linearGradient>
</defs>
<rect width="100" height="100" x="0" fill="url(#g1)"/>
<rect width="100" height="100" x="100" fill="url(#g2)"/>
<rect width="100" height="100" x="200" fill="url(#g3)"/>
</svg>Opacité des stops et stops multiples
Chaque stop peut porter stop-opacity (0-1) pour des transitions de transparence. Combinez beaucoup de stops pour des rampes de couleurs complexes. Ce dégradé de coucher de soleil passe du bleu transparent en haut au rouge sombre opaque en bas — une technique courante pour les fonds atmosphériques.
<svg width="200" height="200" viewBox="0 0 200 200">
<defs>
<linearGradient id="sunset" x1="0" y1="0" x2="0" y2="1">
<stop offset="0%" stop-color="deepskyblue" stop-opacity="0"/>
<stop offset="40%" stop-color="orange" stop-opacity="0.8"/>
<stop offset="70%" stop-color="orangered"/>
<stop offset="100%" stop-color="darkred"/>
</linearGradient>
</defs>
<rect width="200" height="200" fill="url(#sunset)"/>
</svg>Réutiliser les dégradés
Définissez un dégradé une fois dans <defs> et référencez-le sur autant de formes que voulu via fill='url(#id)'. Utilisez href pour dériver un nouveau dégradé d'un existant en ne surchargeant que certains attributs (comme la direction). Cela garde votre SVG DRY et réduit la taille du fichier.
<svg width="300" height="100" viewBox="0 0 300 100">
<defs>
<!-- A reusable gradient -->
<linearGradient id="metal" x1="0" y1="0" x2="0" y2="1">
<stop offset="0%" stop-color="#eee"/>
<stop offset="50%" stop-color="#999"/>
<stop offset="100%" stop-color="#333"/>
</linearGradient>
<!-- Gradient referencing another via href -->
<linearGradient id="metal-horizontal" href="#metal"
x1="0" y1="0" x2="1" y2="0"/>
</defs>
<!-- Same gradient on multiple shapes -->
<rect x="10" y="10" width="80" height="80" fill="url(#metal)"/>
<circle cx="150" cy="50" r="40" fill="url(#metal)"/>
<rect x="210" y="10" width="80" height="80" fill="url(#metal-horizontal)"/>
</svg>Patterns
Pattern de base
Un <pattern> tuile un graphique répétitif. Les enfants du pattern définissent une tuile ; width/height fixent la taille de la tuile. patternUnits='userSpaceOnUse' (recommandé) signifie que les dimensions de tuile sont en unités utilisateur SVG, indépendantes de la forme remplie. Référencez avec fill='url(#id)'.
<svg width="200" height="200" viewBox="0 0 200 200">
<defs>
<pattern id="dots" x="0" y="0" width="20" height="20"
patternUnits="userSpaceOnUse">
<circle cx="10" cy="10" r="3" fill="steelblue"/>
</pattern>
</defs>
<rect width="200" height="200" fill="url(#dots)"/>
</svg>Unités de pattern
patternUnits='objectBoundingBox' (défaut) dimensionne les tuiles comme fraction de la forme — le pattern s'adapte à chaque forme. 'userSpaceOnUse' utilise des unités absolues, donc le pattern reste cohérent entre formes quelle que soit leur taille. La plupart des patterns réels utilisent userSpaceOnUse.
<svg width="300" height="100" viewBox="0 0 300 100">
<defs>
<!-- objectBoundingBox (default): tile size is relative to shape -->
<!-- 0.1 = 10% of the shape's width/height -->
<pattern id="p1" width="0.1" height="0.1">
<rect width="10" height="10" fill="red" opacity="0.5"/>
</pattern>
<!-- userSpaceOnUse: tile size is in SVG units -->
<pattern id="p2" width="20" height="20"
patternUnits="userSpaceOnUse">
<rect width="10" height="10" fill="blue" opacity="0.5"/>
</pattern>
</defs>
<rect width="150" height="100" fill="url(#p1)"/>
<rect x="150" width="150" height="100" fill="url(#p2)"/>
</svg>Rayures et damier
patternTransform pivote, met à l'échelle ou incline tout le pattern. Pour des rayures, remplissez la moitié de la tuile d'une couleur et l'autre moitié d'une autre, puis pivotez. Le damier utilise quatre rect (ou deux paires en L) par tuile. Ces patterns sont courants dans les diagrammes et textures.
<svg width="200" height="200" viewBox="0 0 200 200">
<defs>
<!-- Diagonal stripes -->
<pattern id="stripes" width="20" height="20"
patternUnits="userSpaceOnUse"
patternTransform="rotate(45)">
<rect width="20" height="10" fill="gold"/>
<rect y="10" width="20" height="10" fill="black"/>
</pattern>
<!-- Checkerboard -->
<pattern id="checker" width="40" height="40"
patternUnits="userSpaceOnUse">
<rect width="40" height="40" fill="white"/>
<rect width="20" height="20" fill="black"/>
<rect x="20" y="20" width="20" height="20" fill="black"/>
</pattern>
</defs>
<rect width="100" height="200" fill="url(#stripes)"/>
<rect x="100" width="100" height="200" fill="url(#checker)"/>
</svg>patternContentUnits
patternContentUnits contrôle le système de coordonnées des éléments enfants du pattern (pas la taille de tuile). 'objectBoundingBox' rend les coordonnées des enfants des fractions de la forme — utile quand on veut que le détail du pattern s'adapte proportionnellement à chaque forme. Rare mais puissant.
<svg width="200" height="200" viewBox="0 0 200 200">
<defs>
<!-- patternContentUnits: how the pattern's children are measured -->
<!-- userSpaceOnUse (default): children use SVG units -->
<!-- objectBoundingBox: children are relative to the shape -->
<pattern id="pb" width="0.25" height="0.25"
patternContentUnits="objectBoundingBox">
<circle cx="0.125" cy="0.125" r="0.05" fill="green"/>
</pattern>
</defs>
<!-- The dots scale with each shape's bounding box -->
<rect width="100" height="100" fill="url(#pb)"/>
<rect x="100" width="100" height="200" fill="url(#pb)"/>
</svg>Patterns imbriqués
Les patterns peuvent contenir des dégradés, d'autres patterns, ou n'importe quel contenu SVG. Ce pattern de grille remplit chaque cellule d'un dégradé subtil et trace les lignes de grille par-dessus. L'imbrication permet de bâtir des textures complexes. Gardez des tailles de tuile raisonnables pour éviter des problèmes de performance avec de très petites tuiles.
<svg width="200" height="200" viewBox="0 0 200 200">
<defs>
<!-- A pattern can reference another pattern or gradient -->
<pattern id="grid" width="40" height="40"
patternUnits="userSpaceOnUse">
<rect width="40" height="40" fill="url(#cellGrad)"/>
<path d="M 40 0 L 0 0 0 40" fill="none" stroke="#ccc"/>
</pattern>
<linearGradient id="cellGrad">
<stop offset="0" stop-color="#f0f8ff"/>
<stop offset="1" stop-color="#e0e0ff"/>
</linearGradient>
</defs>
<rect width="200" height="200" fill="url(#grid)"/>
</svg>Transform
Translate
translate(tx, ty) déplace un élément de tx, ty. Si ty est omis, il passe à 0. Le transform s'applique au système de coordonnées de l'élément, donc les attributs x/y sont relatifs à l'origine translatée. Les transforms CSS (via style) marchent sur le SVG en ligne dans les navigateurs modernes et s'animent avec des transitions CSS.
<svg width="200" height="100" viewBox="0 0 200 100">
<!-- Original -->
<rect x="10" y="10" width="40" height="40" fill="red"/>
<!-- Translated 80px right -->
<rect x="10" y="10" width="40" height="40" fill="blue"
transform="translate(80, 0)"/>
<!-- translate with one arg moves only horizontally -->
<rect x="10" y="10" width="40" height="40" fill="green"
transform="translate(0, 50)"/>
<!-- Equivalent in CSS (for inline SVG in HTML) -->
<rect x="10" y="10" width="40" height="40" fill="orange"
style="transform: translate(150px, 0);"/>
</svg>Rotate
rotate(angle, cx, cy) pivote de angle degrés autour du point (cx, cy). Sans cx/cy, il pivote autour de l'origine (0,0), souvent pas ce qu'on veut. Les angles sont horaires (positifs) ou antihoraires (négatifs). Spécifiez toujours le centre pour pivoter un élément sur place.
<svg width="200" height="200" viewBox="0 0 200 200">
<rect x="50" y="50" width="100" height="20" fill="red"/>
<!-- rotate(angle) around origin (0,0) -->
<rect x="50" y="50" width="100" height="20" fill="blue"
transform="rotate(45)"/>
<!-- rotate(angle, cx, cy) around point (cx, cy) -->
<rect x="50" y="50" width="100" height="20" fill="green"
transform="rotate(45, 100, 60)"/>
<!-- Negative angles rotate counterclockwise -->
<rect x="50" y="50" width="100" height="20" fill="orange"
transform="rotate(-30, 100, 60)"/>
</svg>Scale et skew
scale(sx, sy) multiplie les dimensions ; un argument met à l'échelle les deux également. La mise à l'échelle affecte aussi stroke-width et les positions. skewX/skewY inclinent l'élément le long d'un axe selon un angle. Tous les transforms sont relatifs à l'origine (0,0), donc mettre à l'échelle une forme à x=100 la déplace aussi.
<svg width="200" height="200" viewBox="0 0 200 200">
<!-- Original square -->
<rect x="10" y="10" width="50" height="50" fill="red"/>
<!-- scale(2): 2x in both dimensions -->
<rect x="10" y="10" width="50" height="50" fill="blue"
transform="scale(2)"/>
<!-- scale(sx, sy): different x and y scaling -->
<rect x="10" y="10" width="50" height="50" fill="green"
transform="scale(1, 2)"/>
<!-- skewX / skewY: shear the shape -->
<rect x="10" y="10" width="50" height="50" fill="orange"
transform="skewX(30)"/>
</svg>Transform matrice
La matrice(a,b,c,d,e,f) est la forme sous-jacente de tous les transforms. a,d mettent à l'échelle ; b,c inclinent ; e,f translatent. La plupart des développeurs utilisent les transforms nommés (translate, rotate, etc.) pour la lisibilité, mais la matrice est ce que les outils sortent et sert à combiner des transforms ou parser.
<svg width="200" height="200" viewBox="0 0 200 200">
<!-- transform="matrix(a, b, c, d, e, f)" -->
<!-- Represents: [a c e] [b d f] [0 0 1] -->
<!-- New x = a*x + c*y + e -->
<!-- New y = b*x + d*y + f -->
<!-- Identity (no change) -->
<rect width="50" height="50" fill="red" transform="matrix(1,0,0,1,0,0)"/>
<!-- Translate (100, 50) -->
<rect width="50" height="50" fill="blue" transform="matrix(1,0,0,1,100,50)"/>
<!-- Scale 2x and translate -->
<rect width="50" height="50" fill="green" transform="matrix(2,0,0,2,50,0)"/>
</svg>Combiner des transforms
Plusieurs transforms dans l'attribut s'appliquent de droite à gauche (le plus à droite d'abord). Cela signifie que 'translate(100,100) rotate(45)' pivote d'abord la forme autour de sa propre origine, puis la déplace — généralement ce qu'on veut. Les transforms CSS avec transform-origin sont souvent plus intuitifs pour le SVG en ligne.
<svg width="200" height="200" viewBox="0 0 200 200">
<!-- Multiple transforms apply right-to-left -->
<rect x="0" y="0" width="40" height="40" fill="red"
transform="translate(100, 100) rotate(45) scale(2)"/>
<!-- This means: scale, then rotate, then translate -->
<!-- Order matters! rotate then translate != translate then rotate -->
<!-- transform-origin via CSS (for inline SVG) -->
<rect x="80" y="80" width="40" height="40" fill="blue"
style="transform: rotate(45deg); transform-origin: center;"/>
<!-- transform-origin: center, 50% 50%, or explicit coords -->
</svg>transform-origin (CSS)
En animant du SVG avec du CSS, réglez explicitement transform-origin (en unités utilisateur SVG) et transform-box (fill-box pour la boîte englobante de l'élément, view-box pour le canevas SVG). Sans eux, la rotation se centre sur l'origine du SVG, pas de l'élément. Les animations et transitions CSS marchent sur le SVG en ligne.
<svg width="200" height="200" viewBox="0 0 200 200">
<style>
.gear {
transform-origin: 100px 100px; /* SVG user units */
transform-box: fill-box; /* or view-box */
animation: spin 4s linear infinite;
}
@keyframes spin {
to { transform: rotate(360deg); }
}
</style>
<circle class="gear" cx="100" cy="100" r="50" fill="orange"/>
<circle cx="100" cy="100" r="10" fill="black"/>
</svg>Groupe (g)
Groupement de base
<g> groupe des éléments pour qu'ils partagent des attributs (fill, stroke, transform, etc.) et se manipulent comme une unité. Les enfants héritent des attributs de présentation du groupe. Les groupes sont essentiels pour organiser des SVG complexes et appliquer des transforms à plusieurs formes d'un coup.
<svg width="200" height="200" viewBox="0 0 200 200">
<g fill="steelblue" stroke="navy" stroke-width="2">
<!-- Children inherit the group's attributes -->
<circle cx="60" cy="60" r="30"/>
<rect x="100" y="30" width="60" height="60" rx="5"/>
<path d="M 30 150 L 100 110 L 170 150 Z"/>
</g>
<!-- Without g, you'd repeat fill/stroke on each element -->
</svg>Transforms de groupe
Un transform sur <g> crée un nouveau système de coordonnées pour ses enfants. C'est la clé des composants réutilisables : concevez autour de (0,0), puis positionnez tout le groupe avec translate. Les coordonnées des enfants sont relatives à l'origine transformée du groupe.
<svg width="200" height="200" viewBox="0 0 200 200">
<!-- A transform on a group applies to all children -->
<g transform="translate(100, 100) rotate(45)">
<rect x="-30" y="-30" width="60" height="60" fill="red"/>
<circle cx="0" cy="0" r="15" fill="white"/>
</g>
<!-- The group defines its own coordinate system -->
<!-- Children use coords relative to the group's origin -->
<g transform="translate(50, 150)">
<text x="0" y="0">Origin here</text>
<circle cx="0" cy="-20" r="5"/>
</g>
</svg>Groupes imbriqués
Les groupes peuvent s'imbriquer arbitrairement profondément. Chaque transform imbriqué se compose — l'élément le plus interne est affecté par tous les transforms d'ancêtres dans l'ordre. C'est ainsi qu'on bâtit des scènes hiérarchiques (ex. un personnage aux membres pivotants, chaque membre avec des mains mobiles). Gardez une imbrication raisonnable pour la performance.
<svg width="200" height="200" viewBox="0 0 200 200">
<g transform="translate(100, 100)"> <!-- outer group -->
<g transform="scale(0.5)"> <!-- inner group -->
<circle r="80" fill="blue"/>
<g transform="translate(40, 0)"> <!-- innermost -->
<circle r="20" fill="white"/>
</g>
</g>
</g>
<!-- Transforms compound: the innermost circle is -->
<!-- translated, scaled, and translated again -->
</svg>IDs de groupe et références
Donnez un id à un groupe et référencez-le avec <use href='#id'> pour le dupliquer. C'est la base des sprites SVG et des composants réutilisables. Le groupe peut vivre dans <defs> (non rendu directement) et s'instancier plusieurs fois avec des transforms différents. La surcharge d'attributs sur <use> est limitée.
<svg width="200" height="100" viewBox="0 0 200 100">
<defs>
<g id="star">
<polygon points="50,5 61,38 95,38 67,58 78,90 50,70 22,90 33,58 5,38 39,38"
fill="gold" stroke="orange"/>
</g>
</defs>
<!-- Reference the group with <use> -->
<use href="#star" transform="translate(0, 0) scale(0.5)"/>
<use href="#star" transform="translate(100, 0) scale(0.5)"/>
<use href="#star" transform="translate(0, 50) scale(0.3)"/>
</svg>Groupes conditionnels
Les groupes avec ids sont des points d'accroche parfaits pour le CSS (hover, états actifs) et la gestion d'événements JavaScript. Traitez un <g> comme un composant : regroupez ses formes, donnez-lui un id, et interagissez avec lui comme une unité. Les listeners d'événements sur un groupe attrapent les événements de tous ses enfants.
<svg width="200" height="100" viewBox="0 0 200 100">
<!-- <g> can have ids for CSS targeting and JS selection -->
<g id="button" class="interactive" data-action="save">
<rect width="80" height="30" rx="5" fill="steelblue"/>
<text x="40" y="20" text-anchor="middle" fill="white">Save</text>
</g>
<style>
#button:hover rect { fill: royalblue; }
#button { cursor: pointer; }
</style>
<script>
document.getElementById("button").addEventListener("click", save);
</script>
</svg>Group vs Symbol
<symbol> est conçu pour les icônes réutilisables : jamais rendu directement et doté de son propre viewBox, donc <use> peut le dimensionner indépendamment. <g> dans <defs> marche aussi mais manque de la fonctionnalité viewBox. Pour les systèmes d'icônes, préférez <symbol> — il gère automatiquement mise à l'échelle et ratio d'aspect.
<svg width="0" height="0" viewBox="0 0 0 0">
<!-- <g> in <defs>: original is hidden, use can instantiate -->
<defs>
<g id="icon-g">
<rect width="20" height="20" fill="red"/>
</g>
</defs>
<!-- <symbol> is like <g> but supports viewBox and is never rendered -->
<symbol id="icon-s" viewBox="0 0 20 20">
<rect width="20" height="20" fill="blue"/>
</symbol>
<!-- Use with explicit size (symbol scales to fit) -->
<use href="#icon-g" x="0" y="0"/>
<use href="#icon-s" x="40" y="0" width="40" height="40"/>
</svg>Use / Symbol / Defs
Élément defs
<defs> héberge des définitions réutilisables non dessinées tant qu'elles ne sont pas référencées : dégradés, patterns, filtres, chemins de clip, masques, symbols et groupes. Les mettre dans defs garde la sortie rendue propre et signale l'intention. Tout ce qui est hors defs se rend immédiatement.
<svg width="200" height="100" viewBox="0 0 200 100">
<defs>
<!-- Anything in defs is defined but NOT rendered -->
<linearGradient id="myGrad">
<stop offset="0" stop-color="red"/>
<stop offset="1" stop-color="blue"/>
</linearGradient>
<pattern id="myPattern" width="20" height="20">
<circle cx="10" cy="10" r="5" fill="url(#myGrad)"/>
</pattern>
<g id="myShape">
<rect width="40" height="40" rx="5"/>
</g>
</defs>
<!-- Reference and render them -->
<rect width="100" height="100" fill="url(#myPattern)"/>
<use href="#myShape" x="120" y="30" fill="green"/>
</svg>Élément use
<use> clone et rend un élément défini (g, symbol ou toute forme). x/y positionnent l'instance. fill/stroke sur <use> ne surchargent l'original que s'il ne les avait pas spécifiés (héritage CSS). transform s'applique à l'instance. C'est ainsi que fonctionnent les sprites SVG.
<svg width="300" height="100" viewBox="0 0 300 100">
<defs>
<g id="cloud">
<circle cx="30" cy="50" r="20" fill="white"/>
<circle cx="50" cy="45" r="25" fill="white"/>
<circle cx="75" cy="50" r="20" fill="white"/>
</g>
</defs>
<!-- Basic use -->
<use href="#cloud"/>
<!-- Positioned and styled -->
<use href="#cloud" x="120" y="0" fill="lightgray"/>
<use href="#cloud" x="200" y="10" transform="scale(0.5)" fill="silver"/>
</svg>Élément symbol
<symbol> définit un graphique réutilisable avec son propre viewBox. Contrairement à <g>, jamais rendu directement et s'adapte aux dimensions de l'élément <use>. fill='currentColor' laisse le consommateur régler la couleur via CSS color. C'est le pattern standard des systèmes d'icônes SVG.
<!-- In a hidden sprite file or <defs> -->
<svg width="0" height="0" style="position:absolute">
<symbol id="heart" viewBox="0 0 32 32">
<path d="M16 28 C 4 18, 4 8, 12 8 C 14 8, 16 10, 16 12
C 16 10, 18 8, 20 8 C 28 8, 28 18, 16 28 Z"
fill="currentColor"/>
</symbol>
<symbol id="star" viewBox="0 0 32 32">
<polygon points="16,2 20,12 31,12 22,19 25,30 16,23 7,30 10,19 1,12 12,12"
fill="currentColor"/>
</symbol>
</svg>
<!-- Usage: size with width/height, color with CSS -->
<svg width="24" height="24"><use href="#heart"/></svg>
<svg width="48" height="48"><use href="#star" style="color: gold"/></svg>Références SVG externes
<use> peut référencer des symbols dans des fichiers SVG externes via href='fichier.svg#id'. Mais le support navigateur est incohérent (pas d'IE, restrictions CORS), et ça casse avec file://. L'approche fiable : inlinez un sprite SVG caché en haut de votre HTML et référencez les symbols dans le même document.
<!-- Reference a symbol in an external .svg file -->
<svg width="24" height="24">
<use href="icons.svg#heart"/>
</svg>
<!-- The external file (icons.svg) would contain: -->
<!-- <svg xmlns="http://www.w3.org/2000/svg" style="display:none"> -->
<!-- <symbol id="heart" viewBox="0 0 32 32">...</symbol> -->
<!-- </svg> -->
<!-- Note: external references have limited browser support -->
<!-- and don't work with file:// protocol. Inline is more reliable. -->
<!-- For production, inline the sprite at the top of your HTML body. -->Surcharger les attributs de use
Quand la forme d'origine omet un attribut de présentation (comme fill), <use> peut le régler — l'instance hérite de la valeur. Si l'original spécifie fill, le fill du use est ignoré (les attributs de présentation battent l'héritage CSS). Pour des symbols personnalisables, omettez les attributs que vous voulez surcharger.
<svg width="300" height="100" viewBox="0 0 300 100">
<defs>
<!-- Shape without explicit fill — inherits from use -->
<circle id="ball" cx="20" cy="20" r="15"/>
</defs>
<!-- Each use can set its own fill -->
<use href="#ball" fill="red"/>
<use href="#ball" x="50" fill="green"/>
<use href="#ball" x="100" fill="blue" stroke="black" stroke-width="2"/>
</svg>Imbrication de symbols et sprite
C'est le pattern de production des icônes SVG : un sprite SVG caché en haut du document contenant toutes les icônes comme <symbol>s, puis <use> pour les rendre n'importe où. currentColor fait hériter aux icônes la couleur du texte. Le CSS contrôle la taille. Le sprite se cache après le premier chargement, rapide sur chaque page.
<!-- A complete inline SVG sprite system -->
<svg style="display:none" aria-hidden="true">
<symbol id="icon-home" viewBox="0 0 24 24">
<path d="M12 3 L2 12 H5 V21 H10 V14 H14 V21 H19 V12 H22 Z"/>
</symbol>
<symbol id="icon-search" viewBox="0 0 24 24">
<circle cx="11" cy="11" r="7" fill="none" stroke="currentColor" stroke-width="2"/>
<line x1="16" y1="16" x2="21" y2="21" stroke="currentColor" stroke-width="2"/>
</symbol>
</svg>
<!-- Reference anywhere in HTML -->
<svg class="icon"><use href="#icon-home"/></svg>
<svg class="icon"><use href="#icon-search"/></svg>
<style>
.icon { width: 24px; height: 24px; fill: currentColor; }
</style>Filtres
Bases des filtres
Un <filter> contient une ou plusieurs primitives de filtre (éléments fe*) qui traitent le graphique. in='SourceGraphic' prend le rendu propre de l'élément. Appliquez avec filter='url(#id)'. Les filtres peuvent être coûteux — avec parcimonie sur de petits éléments, pas de grands fonds.
<svg width="200" height="120" viewBox="0 0 200 120">
<defs>
<filter id="blur1">
<!-- feGaussianBlur: stdDeviation is the blur radius -->
<feGaussianBlur in="SourceGraphic" stdDeviation="3"/>
</filter>
</defs>
<!-- Without filter -->
<text x="10" y="30" font-size="24" fill="red">Sharp</text>
<!-- With filter -->
<text x="10" y="70" font-size="24" fill="red"
filter="url(#blur1)">Blurred</text>
</svg>Ombre portée
Une ombre portée combine feOffset (déplacer), feGaussianBlur (adoucir), feFlood (couleur), feComposite (appliquer la couleur à l'ombre) et feMerge (superposer l'ombre sous l'original). Le x/y/width/height du filtre (défaut -10 % à 110 %) doit être agrandi ou l'ombre se rogne.
<svg width="200" height="120" viewBox="0 0 200 120">
<defs>
<filter id="shadow" x="-20%" y="-20%" width="140%" height="140%">
<!-- Offset the source -->
<feOffset in="SourceAlpha" dx="4" dy="4" result="offset"/>
<!-- Blur the offset copy -->
<feGaussianBlur in="offset" stdDeviation="3" result="blur"/>
<!-- Color the shadow -->
<feFlood flood-color="black" flood-opacity="0.5" result="color"/>
<feComposite in="color" in2="blur" operator="in" result="shadow"/>
<!-- Put shadow under the original -->
<feMerge>
<feMergeNode in="shadow"/>
<feMergeNode in="SourceGraphic"/>
</feMerge>
</filter>
</defs>
<rect x="20" y="20" width="80" height="60" fill="white"
filter="url(#shadow)"/>
</svg>Ombre simple (CSS)
Pour des ombres simples sur du SVG en ligne, le filter: drop-shadow() CSS est bien plus simple que bâtir un filtre SVG. Il respecte le contour réel de la forme (pas juste la boîte englobante comme box-shadow). Réservez les filtres SVG aux effets complexes multi-étapes que le CSS ne peut pas exprimer.
<!-- Modern browsers: use CSS filter instead of SVG filter -->
<svg width="200" height="100" viewBox="0 0 200 100">
<rect x="50" y="20" width="100" height="60" fill="white"
style="filter: drop-shadow(4px 4px 4px rgba(0,0,0,0.5));"/>
</svg>
<!-- In CSS -->
<style>
.shadowed { filter: drop-shadow(0 0 10px rgba(0,0,0,0.3)); }
</style>
<!-- CSS drop-shadow follows the shape's alpha, unlike box-shadow -->
<!-- which only shadows the bounding box -->Matrice de couleurs
feColorMatrix transforme les couleurs via une matrice 5x4 (RGBA entrée, RGBA sortie). type='saturate' avec valeurs 0-1 désature ; type='hueRotate' pivote la teinte en degrés ; type='luminanceToAlpha' convertit la luminosité en alpha. Utile pour gris, sépia et ajustements de couleurs sur du contenu SVG.
<svg width="200" height="100" viewBox="0 0 200 100">
<defs>
<!-- Convert to grayscale -->
<filter id="grayscale">
<feColorMatrix type="matrix"
values="0.33 0.33 0.33 0 0
0.33 0.33 0.33 0 0
0.33 0.33 0.33 0 0
0 0 0 1 0"/>
</filter>
<!-- Built-in saturation -->
<filter id="desaturate">
<feColorMatrix type="saturate" values="0"/>
</filter>
</defs>
<image href="photo.jpg" width="100" height="100" filter="url(#grayscale)"/>
<image href="photo.jpg" x="100" width="100" height="100" filter="url(#desaturate)"/>
</svg>Effets d'éclairage
feSpecularLighting et feDiffuseLighting simulent un éclairage 3D sur la carte de hauteur d'une forme 2D (dérivée de l'alpha). surfaceScale contrôle la profondeur ; l'élément de lumière (fePointLight, feDistantLight, feSpotLight) règle la direction. Combinés à feComposite, on obtient des effets de gaufrage, chanfrein et texte 3D.
<svg width="200" height="120" viewBox="0 0 200 120">
<defs>
<filter id="emboss">
<!-- Create a height map from the alpha -->
<feGaussianBlur in="SourceAlpha" stdDeviation="2" result="blur"/>
<!-- Lighting from upper-left -->
<feSpecularLighting in="blur" surfaceScale="5"
specularConstant="0.8" specularExponent="20"
lighting-color="white" result="spec">
<fePointLight x="-50" y="-50" z="200"/>
</feSpecularLighting>
<feComposite in="spec" in2="SourceGraphic"
operator="in" result="lit"/>
<feComposite in="SourceGraphic" in2="lit" operator="arithmetic"
k1="0" k2="1" k3="1" k4="0"/>
</filter>
</defs>
<text x="10" y="70" font-size="48" font-weight="bold"
fill="gray" filter="url(#emboss)">3D</text>
</svg>Turbulence (texture)
feTurbulence génère du bruit procédural (type fractal ou turbulence) — utile pour des textures comme le statique, les nuages, l'eau ou le grain de papier. baseFrequency contrôle l'échelle (0.5 = fin, 0.05 = nuageux). numOctaves ajoute du détail au prix de la vitesse. Combinez avec feColorMatrix ou feDisplacementMap pour des effets.
<svg width="200" height="200" viewBox="0 0 200 200">
<defs>
<!-- feTurbulence generates Perlin noise -->
<filter id="noise" x="0" y="0" width="100%" height="100%">
<feTurbulence type="fractalNoise" baseFrequency="0.65"
numOctaves="3" stitchTiles="stitch"/>
<feColorMatrix type="matrix"
values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.1 0"/>
</filter>
</defs>
<rect width="200" height="200" fill="steelblue"/>
<rect width="200" height="200" filter="url(#noise)"/>
<!-- type: "fractalNoise" or "turbulence" -->
<!-- baseFrequency: lower = larger blobs, higher = finer grain -->
<!-- numOctaves: more = more detail (slower) -->
</svg>Clipping et masquage
Clip path
clipPath définit une frontière à bords durs — les pixels à l'intérieur sont visibles, à l'extérieur cachés. La forme de clip elle-même ne se dessine pas. clip-path la référence via url(#id). Le clipping est binaire (dedans ou dehors) ; pour des transitions douces, utilisez des masques. Le texte comme clip path crée l'effet classique « image dans le texte ».
<svg width="200" height="200" viewBox="0 0 200 200">
<defs>
<!-- A clip path: only the inside is visible -->
<clipPath id="circleClip">
<circle cx="100" cy="100" r="80"/>
</clipPath>
</defs>
<!-- The image is clipped to the circle -->
<rect width="200" height="200" fill="steelblue"
clip-path="url(#circleClip)"/>
<!-- Any shape can be a clip path -->
<clipPath id="textClip">
<text x="100" y="120" font-size="80" text-anchor="middle"
font-weight="bold">SVG</text>
</clipPath>
<rect width="200" height="200" fill="gold" clip-path="url(#textClip)"/>
</svg>Mask
Contrairement à clip-path (binaire), les masques supportent l'alpha — les zones blanches sont pleinement visibles, les noires cachées, les grises partiellement transparentes. Utilisez un dégradé comme contenu de masque pour des fondus doux. Les masques sont plus lourds que les clip paths mais essentiels aux transitions douces et effets photo.
<svg width="200" height="200" viewBox="0 0 200 200">
<defs>
<!-- A mask: white = visible, black = hidden, gray = partial -->
<mask id="fadeMask">
<linearGradient id="fadeGrad" x1="0" y1="0" x2="0" y2="1">
<stop offset="0" stop-color="white"/>
<stop offset="1" stop-color="black"/>
</linearGradient>
<rect width="200" height="200" fill="url(#fadeGrad)"/>
</mask>
</defs>
<!-- The image fades from top to bottom -->
<rect width="200" height="200" fill="red" mask="url(#fadeMask)"/>
</svg>Unités du clip path
clipPathUnits='objectBoundingBox' fait s'adapter le clip path à la boîte englobante de chaque élément (coordonnées 0-1), donc un clip path sert à des formes de tailles différentes. 'userSpaceOnUse' (défaut) utilise les coordonnées SVG absolues. La plupart des clips réutilisables utilisent objectBoundingBox.
<svg width="300" height="100" viewBox="0 0 300 100">
<defs>
<!-- userSpaceOnUse (default): clip coords in SVG units -->
<clipPath id="clip1" clipPathUnits="userSpaceOnUse">
<rect x="10" y="10" width="50" height="50"/>
</clipPath>
<!-- objectBoundingBox: coords are 0-1 relative to the element -->
<clipPath id="clip2" clipPathUnits="objectBoundingBox">
<rect x="0.1" y="0.1" width="0.8" height="0.8"/>
</clipPath>
</defs>
<rect width="100" height="100" fill="red" clip-path="url(#clip1)"/>
<rect x="100" width="100" height="80" fill="blue" clip-path="url(#clip2)"/>
<rect x="200" width="100" height="60" fill="green" clip-path="url(#clip2)"/>
</svg>CSS clip-path
Le CSS clip-path supporte directement les formes de base (circle, ellipse, polygon, inset) sans SVG, et peut référencer des éléments clipPath SVG via url(#id). Ça marche aussi sur les éléments HTML, pas seulement le SVG. Le masquage CSS est aussi supporté dans les navigateurs modernes via mask-image.
<style>
/* CSS clip-path works on SVG and HTML elements */
.circle {
clip-path: circle(50% at 50% 50%);
}
.triangle {
clip-path: polygon(50% 0%, 100% 100%, 0% 100%);
}
/* Reference an SVG clipPath */
.svg-clip {
clip-path: url(#myClip);
}
</style>
<svg width="200" height="100">
<defs>
<clipPath id="myClip">
<circle cx="50" cy="50" r="40"/>
</clipPath>
</defs>
<rect class="svg-clip" width="200" height="100" fill="purple"/>
</svg>Pratique : image dans le texte
Clipper un dégradé ou une image au texte est une technique de design populaire. Le clipPath contient un élément <text> ; le rect clippé se remplit du dégradé, visible seulement dans les lettres. Ça marche avec <image> aussi — mettez une photo dans le texte pour des en-têtes façon magazine.
<svg width="400" height="120" viewBox="0 0 400 120">
<defs>
<clipPath id="textShape">
<text x="200" y="90" font-size="80" font-weight="900"
text-anchor="middle" font-family="Arial">SUMMER</text>
</clipPath>
</defs>
<!-- Background (visible only through the text) -->
<rect width="400" height="120" fill="black"/>
<!-- Image clipped to the text shape -->
<rect width="400" height="120" fill="url(#sunsetGrad)"
clip-path="url(#textShape)"/>
<linearGradient id="sunsetGrad" x1="0" y1="0" x2="0" y2="1">
<stop offset="0" stop-color="#ff6b6b"/>
<stop offset="0.5" stop-color="#feca57"/>
<stop offset="1" stop-color="#ff9ff3"/>
</linearGradient>
</svg>Animation (SMIL)
animate (base)
<animate> transitionne un attribut dans le temps. attributeName est la cible ; from/to définissent la plage ; dur la durée ; repeatCount='indefinite' boucle indéfiniment. Les animations SMIL sont déclaratives (pas de JS requis) et marchent dans la plupart des navigateurs sauf IE. L'animation vit comme enfant de l'élément cible.
<svg width="200" height="100" viewBox="0 0 200 100">
<rect x="0" y="40" width="20" height="20" fill="red">
<animate attributeName="x"
from="0" to="180"
dur="2s"
repeatCount="indefinite"/>
</rect>
<!-- The rect moves from x=0 to x=180 over 2 seconds, forever -->
</svg>animateTransform
<animateTransform> anime l'attribut transform. type choisit l'opération (rotate, scale, translate, skewX, skewY). Pour rotate, from/to sont 'angle cx cy' (point central). C'est ainsi qu'on fait tourner des éléments sans JavaScript. Un seul animateTransform par élément sauf utilisation d'additive='sum'.
<svg width="200" height="200" viewBox="0 0 200 200">
<rect x="80" y="80" width="40" height="40" fill="blue">
<animateTransform attributeName="transform"
type="rotate"
from="0 100 100" to="360 100 100"
dur="3s"
repeatCount="indefinite"/>
</rect>
<!-- type can be: rotate, scale, translate, skewX, skewY -->
<!-- For rotate, the values are "angle cx cy" -->
</svg>animateMotion
<animateMotion> déplace un élément le long d'un chemin. Référencez le chemin avec <mpath href='#id'> ou définissez path directement. rotate='auto' oriente l'élément face à la direction de déplacement — essentiel pour flèches, voitures ou personnages. C'est la façon SVG de faire de l'animation par chemin sans JS.
<svg width="200" height="150" viewBox="0 0 200 150">
<defs>
<path id="motionPath" d="M 10 75 Q 100 0, 190 75" fill="none"/>
</defs>
<!-- A circle follows the path -->
<circle r="10" fill="red">
<animateMotion dur="3s" repeatCount="indefinite">
<mpath href="#motionPath"/>
</animateMotion>
</circle>
<!-- Show the path for reference -->
<use href="#motionPath" stroke="gray" stroke-width="1"/>
<!-- rotate="auto" makes the element face the direction of motion -->
<circle r="5" fill="blue">
<animateMotion dur="3s" repeatCount="indefinite" rotate="auto">
<mpath href="#motionPath"/>
</animateMotion>
</circle>
</svg>Keyframes et easing
Pour des animations multi-étapes, utilisez values (séparées par points-virgules), keyTimes (fractions 0-1) et keySplines (easing bezier par segment). calcMode='spline' active l'easing ; 'linear' est le défaut. Cela rappelle l'animation par keyframes CSS mais en pur SVG. Le rect rebondit d'avant en arrière avec un easing doux.
<svg width="200" height="100" viewBox="0 0 200 100">
<rect x="0" y="40" width="20" height="20" fill="green">
<animate attributeName="x"
values="0; 80; 180; 80; 0"
keyTimes="0; 0.25; 0.5; 0.75; 1"
keySplines="0.5 0 0.5 1; 0 0 1 1; 0.5 0 0.5 1; 0 0 1 1"
calcMode="spline"
dur="4s"
repeatCount="indefinite"/>
</rect>
<!-- values: the animated values at each keyTime -->
<!-- keyTimes: 0-1 fractions of dur (semicolon-separated) -->
<!-- keySplines: cubic-bezier easing between each pair -->
<!-- calcMode: "discrete", "linear", "paced", or "spline" -->
</svg>begin, end et déclencheurs
begin peut être un offset temporel (2s), un événement (click, mouseenter), ou une référence à l'événement d'une autre animation (anim1.end, anim1.begin+1s). fill='freeze' retient la valeur finale après la fin de l'animation (sinon elle saute en arrière). Cela permet des animations déclenchées au clic et chaînées sans JavaScript.
<svg width="200" height="100" viewBox="0 0 200 100">
<!-- begin: when to start (time or event) -->
<rect x="10" y="10" width="30" height="30" fill="red">
<animate attributeName="width" from="30" to="100"
dur="1s" begin="2s" fill="freeze"/>
</rect>
<!-- begin on a click event -->
<rect x="10" y="60" width="30" height="30" fill="blue" id="trigger">
<animate attributeName="x" from="10" to="150"
dur="1s" begin="click" fill="freeze"/>
</rect>
<!-- begin when another animation ends -->
<rect x="10" y="80" width="30" height="10" fill="green">
<animate attributeName="x" from="10" to="150"
dur="1s" begin="trigger.click+1s" fill="freeze"/>
</rect>
</svg>Alternative d'animation CSS
Pour du SVG en ligne dans des pages web, les animations CSS sont souvent plus simples que SMIL et mieux outillées. Utilisez transform-box: fill-box pour que transform-origin: center désigne l'élément, pas le canevas SVG. SMIL reste utile pour les fichiers SVG autonomes (pas de CSS disponible) et le mouvement par chemin.
<svg width="200" height="100" viewBox="0 0 200 100">
<style>
.pulse {
animation: pulse 1.5s ease-in-out infinite;
transform-origin: center;
transform-box: fill-box;
}
@keyframes pulse {
0%, 100% { transform: scale(1); opacity: 1; }
50% { transform: scale(1.2); opacity: 0.7; }
}
</style>
<circle class="pulse" cx="100" cy="50" r="20" fill="red"/>
</svg>
<!-- CSS animations are more maintainable for web pages -->
<!-- SMIL is better for standalone .svg files -->Événements
Événements souris
Les éléments SVG supportent les événements DOM standard : click, mouseenter, mouseleave, mousemove, mousedown, mouseup, dblclick. Utilisez addEventListener comme sur les éléments HTML. 'this' dans un handler désigne l'élément SVG. Utilisez setAttribute pour changer les propriétés réactivement.
<svg width="200" height="100" viewBox="0 0 200 100">
<rect id="box" x="10" y="10" width="80" height="80" fill="steelblue"/>
<script>
var box = document.getElementById("box");
box.addEventListener("click", function (e) {
alert("Clicked at " + e.clientX + "," + e.clientY);
});
box.addEventListener("mouseenter", function () {
this.setAttribute("fill", "tomato");
});
box.addEventListener("mouseleave", function () {
this.setAttribute("fill", "steelblue");
});
</script>
</svg>Événements tactiles
SVG supporte touchstart, touchmove, touchend. Convertissez les coordonnées d'écran en coordonnées SVG via createSVGPoint et getScreenCTM().inverse() — essentiel quand le SVG est mis à l'échelle ou responsive. preventDefault() sur touchstart prévient l'interférence des gestes comme le défilement.
<svg width="200" height="200" viewBox="0 0 200 200">
<circle id="touch" cx="100" cy="100" r="30" fill="purple"/>
<script>
var circle = document.getElementById("touch");
circle.addEventListener("touchstart", function (e) {
e.preventDefault(); // prevent scrolling
this.setAttribute("fill", "orange");
});
circle.addEventListener("touchend", function () {
this.setAttribute("fill", "purple");
});
// touchmove for dragging
circle.addEventListener("touchmove", function (e) {
var touch = e.touches[0];
var pt = svg.createSVGPoint();
pt.x = touch.clientX; pt.y = touch.clientY;
var svgP = pt.matrixTransform(svg.getScreenCTM().inverse());
this.setAttribute("cx", svgP.x);
this.setAttribute("cy", svgP.y);
});
</script>
</svg>Conversion de coordonnées
Quand un SVG a un viewBox différent de sa taille en pixels, les coordonnées d'écran ne se mappent pas 1:1 aux coordonnées SVG. createSVGPoint + getScreenCTM().inverse() convertit correctement, en tenant compte du viewBox, du scaling CSS et même des transforms sur les éléments ancêtres. Essentiel pour une détection de clic précise.
<svg width="500" height="300" viewBox="0 0 1000 600" id="mysvg">
<rect width="1000" height="600" fill="lightblue"/>
<script>
var svg = document.getElementById("mysvg");
svg.addEventListener("click", function (e) {
// Convert screen (clientX/Y) to SVG user coordinates
var pt = svg.createSVGPoint();
pt.x = e.clientX;
pt.y = e.clientY;
// getScreenCTM maps SVG coords to screen; inverse maps back
var svgPoint = pt.matrixTransform(
svg.getScreenCTM().inverse()
);
console.log("SVG coords:", svgPoint.x, svgPoint.y);
// This accounts for viewBox scaling and CSS sizing
});
</script>
</svg>Délégation d'événements
La délégation d'événements — un listener sur un groupe parent au lieu de beaucoup sur les enfants — est plus efficace et gère automatiquement les formes ajoutées dynamiquement. e.target est la forme cliquée ; e.currentTarget l'élément portant le listener. Utilisez des attributs data-* pour stocker les métadonnées par forme.
<svg width="300" height="100" viewBox="0 0 300 100">
<g id="shapes">
<circle cx="50" cy="50" r="30" fill="red" data-name="circle1"/>
<rect x="100" y="20" width="60" height="60" fill="blue" data-name="rect1"/>
<polygon points="220,20 280,20 250,80" fill="green" data-name="tri1"/>
</g>
<script>
// One listener on the parent group handles all children
document.getElementById("shapes").addEventListener("click", function (e) {
var target = e.target;
var name = target.getAttribute("data-name");
console.log("Clicked:", name, target.tagName);
// e.target is the actual shape; e.currentTarget is the group
});
</script>
</svg>Interaction de drag
Voici le motif classique de drag SVG : mousedown pose un flag, mouseupdate met à jour la position de l'élément (avec des coordonnées SVG converties), mouseup lève le flag. Attachez mousemove/mouseup au SVG (pas à l'élément) pour que le drag continue même quand le curseur quitte la forme. C'est le socle des éditeurs basés SVG.
<svg width="400" height="300" viewBox="0 0 400 300" id="canvas">
<circle id="draggable" cx="200" cy="150" r="30" fill="orange" cursor="grab"/>
<script>
var circle = document.getElementById("draggable");
var svg = document.getElementById("canvas");
var dragging = false;
function getSVGPoint(e) {
var pt = svg.createSVGPoint();
pt.x = e.clientX; pt.y = e.clientY;
return pt.matrixTransform(svg.getScreenCTM().inverse());
}
circle.addEventListener("mousedown", function () {
dragging = true;
this.setAttribute("cursor", "grabbing");
});
svg.addEventListener("mousemove", function (e) {
if (!dragging) return;
var p = getSVGPoint(e);
circle.setAttribute("cx", p.x);
circle.setAttribute("cy", p.y);
});
svg.addEventListener("mouseup", function () {
dragging = false;
circle.setAttribute("cursor", "grab");
});
</script>
</svg>DOM JavaScript
Créer des éléments
Les éléments SVG doivent se créer avec document.createElementNS(namespace, tagName) — createElement ne marche pas pour le SVG (il crée des éléments HTML inconnus). Le namespace SVG est 'http://www.w3.org/2000/svg'. Utilisez setAttribute pour les propriétés. C'est le socle de la génération dynamique de SVG.
<svg id="canvas" width="200" height="200" viewBox="0 0 200 200">
<script>
var svg = document.getElementById("canvas");
var NS = "http://www.w3.org/2000/svg";
// createElementNS is required for SVG elements
var circle = document.createElementNS(NS, "circle");
circle.setAttribute("cx", "100");
circle.setAttribute("cy", "100");
circle.setAttribute("r", "50");
circle.setAttribute("fill", "red");
svg.appendChild(circle);
// Create a path
var path = document.createElementNS(NS, "path");
path.setAttribute("d", "M 10 10 L 100 100");
path.setAttribute("stroke", "black");
svg.appendChild(path);
</script>
</svg>Modifier des éléments
Utilisez setAttribute/getAttribute pour les attributs de présentation SVG (fill, stroke, width, etc.). classList marche de façon fiable entre navigateurs. Régler style.fill marche car il mappe vers la propriété CSS. Évitez innerHTML pour le SVG (incohérent entre navigateurs) ; bâtissez le DOM avec createElementNS.
<svg width="200" height="100" viewBox="0 0 200 100">
<rect id="r" x="10" y="10" width="50" height="50" fill="blue"/>
<script>
var r = document.getElementById("r");
// Change attributes
r.setAttribute("fill", "red");
r.setAttribute("width", "80");
// Get attribute values
var w = r.getAttribute("width"); // "80"
// Remove attributes
r.removeAttribute("fill");
// Class manipulation (use classList, not className for SVG in some browsers)
r.classList.add("highlight");
r.classList.toggle("active");
// Style (use setAttribute for presentation attributes)
r.style.fill = "green"; // works via CSS
</script>
</svg>Lire la géométrie
getBBox() retourne la boîte englobante en unités utilisateur SVG (en ignorant les transforms). getBoundingClientRect() retourne les coordonnées d'écran (après tous les transforms et le CSS). getTotalLength() donne la longueur du path/line ; getPointAtLength(d) le point à la distance d — essentiel pour les animations par chemin et le hit testing.
<svg width="200" height="100" viewBox="0 0 200 100">
<rect id="r" x="10" y="10" width="80" height="50" fill="blue"/>
<script>
var r = document.getElementById("r");
// Get bounding box in SVG user units
var bbox = r.getBBox();
console.log(bbox.x, bbox.y, bbox.width, bbox.height);
// Get bounding box in screen coordinates (after transforms)
var cbox = r.getBoundingClientRect();
console.log(cbox.left, cbox.top, cbox.width, cbox.height);
// Total length of a path or line
var path = document.querySelector("path");
var len = path.getTotalLength();
var point = path.getPointAtLength(len / 2); // midpoint
</script>
</svg>Dataset et attributs data
Les éléments SVG supportent les attributs data-* et la propriété dataset comme le HTML. C'est la façon propre d'associer des données aux formes pour les apps interactives — stockez IDs de nœuds, labels ou état sans polluer les attributs visuels. Lisez avec element.dataset.clé, réglez de même.
<svg width="200" height="100" viewBox="0 0 200 100">
<circle cx="50" cy="50" r="20" fill="red"
data-id="123" data-label="node"/>
<script>
var circle = document.querySelector("circle");
// dataset reads data-* attributes
console.log(circle.dataset.id); // "123"
console.log(circle.dataset.label); // "node"
// Set data attributes
circle.dataset.selected = "true"; // adds data-selected="true"
// Use for storing state
circle.dataset.visits = "0";
circle.dataset.visits = String(+circle.dataset.visits + 1);
</script>
</svg>Génération dynamique de chemins
Générer du SVG dynamiquement est le socle des graphiques custom. Bâtissez l'attribut d du path en concaténant des commandes M/L depuis vos données, puis créez l'élément avec createElementNS. Cette approche donne un contrôle total sans bibliothèque de graphiques. Pour des visualisations complexes, considérez D3.js, qui enveloppe élégamment ce pattern.
<svg width="300" height="150" viewBox="0 0 300 150" id="chart">
<script>
var NS = "http://www.w3.org/2000/svg";
var svg = document.getElementById("chart");
var data = [10, 50, 30, 80, 45, 90, 25];
// Build a path string from data points
var d = "M 0 " + (150 - data[0]);
for (var i = 1; i < data.length; i++) {
d += " L " + (i * 40) + " " + (150 - data[i]);
}
var path = document.createElementNS(NS, "path");
path.setAttribute("d", d);
path.setAttribute("fill", "none");
path.setAttribute("stroke", "steelblue");
path.setAttribute("stroke-width", "2");
svg.appendChild(path);
// Add dots at each point
data.forEach(function (val, i) {
var c = document.createElementNS(NS, "circle");
c.setAttribute("cx", i * 40);
c.setAttribute("cy", 150 - val);
c.setAttribute("r", 3);
c.setAttribute("fill", "red");
svg.appendChild(c);
});
</script>
</svg>Conseils de performance
Pour la performance : batchez les insertions DOM avec DocumentFragment (un seul reflow), utilisez requestAnimationFrame pour les animations JS (synchronisé au rafraîchissement d'affichage), et évitez d'interroger les attributs dans des boucles serrées (mettez en cache). SVG excelle jusqu'à quelques centaines d'éléments ; pour des milliers (particules, tracés denses), Canvas ou WebGL est plus rapide.
<script>
// Batch DOM operations with document fragments
var fragment = document.createDocumentFragment();
for (var i = 0; i < 1000; i++) {
var c = document.createElementNS(NS, "circle");
c.setAttribute("cx", i);
c.setAttribute("cy", 50);
c.setAttribute("r", 2);
fragment.appendChild(c);
}
svg.appendChild(fragment); // one reflow, not 1000
// Use requestAnimationFrame for animations
function animate() {
element.setAttribute("cx", +element.getAttribute("cx") + 1);
requestAnimationFrame(animate);
}
animate();
// For many elements, consider <canvas> instead (faster)
// SVG slows down with thousands of nodes due to DOM overhead
</script>SVG responsive (viewBox)
Bases de viewBox
viewBox='minX minY width height' définit le système de coordonnées interne. Les deux premières valeurs panorent la vue ; les deux dernières zooment. Le SVG met cette région à l'échelle pour remplir sa width/height. Cela découple vos coordonnées de dessin de la taille rendue — dessinez une fois à n'importe quelle échelle, dans une boîte 100x100 ou 1920x1080.
<!-- viewBox="minX minY width height" -->
<svg viewBox="0 0 100 100" width="200" height="200">
<!-- A circle at center of a 100x100 coordinate system -->
<circle cx="50" cy="50" r="50" fill="blue"/>
</svg>
<!-- viewBox shifts the visible area -->
<svg viewBox="50 50 50 50" width="200" height="200">
<!-- Now showing only the bottom-right quadrant -->
<!-- The same circle, but zoomed in 2x on that corner -->
<circle cx="50" cy="50" r="50" fill="blue"/>
</svg>preserveAspectRatio
preserveAspectRatio contrôle comment le viewBox s'adapte à l'élément quand les ratios diffèrent. 'meet' (défaut) s'adapte entièrement en letterboxant l'excédent. 'slice' remplit entièrement en rognant le débordement. 'none' étire en déformant. La partie xMidYMid contrôle l'alignement : Min/Mid/Max pour les deux axes.
<!-- Default: preserve aspect ratio, center, letterbox -->
<svg viewBox="0 0 100 50" width="200" height="200"
preserveAspectRatio="xMidYMid meet">
<rect width="100" height="50" fill="blue"/>
</svg>
<!-- "slice": fill entirely, crop overflow -->
<svg viewBox="0 0 100 50" width="200" height="200"
preserveAspectRatio="xMidYMid slice">
<rect width="100" height="50" fill="red"/>
</svg>
<!-- "none": stretch to fill (distorts) -->
<svg viewBox="0 0 100 50" width="200" height="200"
preserveAspectRatio="none">
<rect width="100" height="50" fill="green"/>
</svg>SVG pleinement responsive
Pour un SVG responsive : omettez les attributs width/height, réglez viewBox, et contrôlez la taille avec le CSS (width: 100%, height: auto). Le SVG s'adapte à son conteneur en préservant le ratio. display: block supprime le trou de ligne de base du SVG en ligne. C'est le pattern standard du SVG fluide dans les mises en page responsives.
<!-- Omit width/height, set viewBox, use CSS to size -->
<svg viewBox="0 0 100 100" style="width: 100%; height: auto; display: block;">
<circle cx="50" cy="50" r="50" fill="orange"/>
</svg>
<!-- In a container with max-width -->
<div style="max-width: 500px; margin: auto;">
<svg viewBox="0 0 400 300" style="width: 100%; height: auto;">
<rect width="400" height="300" fill="steelblue"/>
</svg>
</div>SVG imbriqué et overflow
Les éléments <svg> imbriqués créent des viewports indépendants avec leur propre viewBox et preserveAspectRatio. Puissant pour des graphiques à panneaux à ratio fixe ou des composants d'UI. overflow='visible' laisse le contenu dessiner hors du viewport imbriqué (défaut caché). Chaque svg imbriqué peut mettre son contenu à l'échelle indépendamment.
<svg width="300" height="200" viewBox="0 0 300 200">
<!-- Nested SVG creates a new viewport -->
<svg x="10" y="10" width="100" height="100" viewBox="0 0 50 50">
<circle cx="25" cy="25" r="25" fill="red"/>
</svg>
<!-- overflow="hidden" (default) clips content outside -->
<svg x="120" y="10" width="100" height="100" viewBox="0 0 50 50"
overflow="visible">
<circle cx="25" cy="25" r="30" fill="blue"/>
</svg>
<!-- Each nested svg can have its own preserveAspectRatio -->
<svg x="230" y="10" width="60" height="100" viewBox="0 0 50 50"
preserveAspectRatio="xMidYMid slice">
<circle cx="25" cy="25" r="25" fill="green"/>
</svg>
</svg>Taille de texte fluide
Les tailles de police dans un SVG avec viewBox s'adaptent au SVG — une police de 20px dans un viewBox de 400 de large affiché à 800px de large se rend à 40px. Pour rendre le texte responsive au viewport du navigateur (pas du SVG), utilisez les unités de viewport CSS (vw, vh) dans un attribut style. C'est ainsi que les titres SVG s'adaptent de façon fluide.
<svg viewBox="0 0 400 100" style="width:100%;height:auto;">
<style>
/* Use viewBox units for font-size — scales with the SVG */
text { font-size: 20px; }
/* Note: 'px' here means SVG user units, not CSS px */
</style>
<text x="200" y="50" text-anchor="middle">Scales with SVG</text>
</svg>
<!-- For truly responsive text relative to viewport, use CSS: -->
<svg viewBox="0 0 400 100" style="width:100%;height:auto;">
<text x="200" y="50" text-anchor="middle"
style="font-size: 5vw;">5% of viewport width</text>
</svg>
<!-- Or use container queries / media queries on the SVG element -->Contrôle du ratio d'aspect
Combinez le CSS aspect-ratio sur le conteneur avec width/height 100 % sur le SVG pour un comportement responsive prévisible. Cela prévient le décalage de mise en page (CLS) en réservant l'espace avant le chargement du SVG. Le viewBox matche le ratio pour que le contenu ne se déforme pas. C'est la meilleure pratique moderne des embeds SVG responsifs.
<!-- Use CSS aspect-ratio for consistent sizing -->
<div style="width: 100%; max-width: 600px; aspect-ratio: 16/9;">
<svg viewBox="0 0 1600 900" style="width:100%;height:100%;">
<rect width="1600" height="900" fill="black"/>
<text x="800" y="450" text-anchor="middle" dominant-baseline="middle"
fill="white" font-size="48">16:9 Container</text>
</svg>
</div>
<!-- aspect-ratio ensures the container keeps proportions -->
<!-- even before the SVG loads, preventing layout shift -->SVG vs Canvas
Modèle de rendu
SVG est en mode retenu : chaque forme est un élément DOM inspectable, stylisable et ré-animable plus tard. Canvas est en mode immédiat : on émet des commandes de dessin qui peignent des pixels, et les formes ne persistent pas comme objets. SVG est meilleur pour l'UI interactive ; Canvas pour des milliers de pixels dynamiques.
<!-- SVG: retained mode (DOM-based) -->
<svg width="200" height="100">
<circle cx="50" cy="50" r="30" fill="red"/>
<!-- Each element is a DOM node, accessible via JS -->
</svg>
<!-- Canvas: immediate mode (pixel-based) -->
<canvas id="c" width="200" height="100"></canvas>
<script>
var ctx = document.getElementById("c").getContext("2d");
ctx.beginPath();
ctx.arc(50, 50, 30, 0, Math.PI * 2);
ctx.fillStyle = "red";
ctx.fill();
// Pixels are drawn; the circle isn't an object anymore
</script>Quand utiliser SVG
Choisissez SVG pour : graphiques indépendants de la résolution (icônes, logos), accessibilité (les lecteurs d'écran parcourent le DOM), interactivité (événements par forme), SEO (le texte est sélectionnable) et comptes d'éléments modérés (jusqu'à quelques centaines). Les fichiers SVG sont du texte (bien gzipables) et éditables dans les outils de design.
<!-- SVG is ideal for:
- Icons and logos (crisp at any size)
- Charts with few elements (D3.js)
- Interactive diagrams (clickable shapes)
- Illustrations with editable layers
- Accessibility-required graphics
-->
<svg viewBox="0 0 24 24" width="48" height="48">
<path d="M12 2 L2 22 H22 Z" fill="triangle"/>
</svg>
<!-- Stays sharp whether displayed at 16px or 1024px -->
<!-- Each part can have its own click handler -->
<!-- Screen readers can access <title> and <desc> -->Quand utiliser Canvas
Choisissez Canvas pour : comptes d'éléments élevés (milliers de formes), redessins par frame (jeux, particules), manipulation de pixels (filtres, effets) et quand l'accessibilité DOM n'est pas nécessaire. Canvas est plus rapide pour le pur débit de pixels mais plus dur à rendre accessible ou interactif au niveau des formes individuelles.
<!-- Canvas is ideal for:
- Games (hundreds of sprites per frame)
- Particle systems
- Real-time image processing
- Heatmaps with thousands of cells
- Physics simulations
-->
<canvas id="particles" width="800" height="600"></canvas>
<script>
var ctx = document.getElementById("particles").getContext("2d");
var particles = [];
for (var i = 0; i < 5000; i++) {
particles.push({ x: Math.random()*800, y: Math.random()*600 });
}
function draw() {
ctx.clearRect(0, 0, 800, 600);
particles.forEach(function (p) {
ctx.fillRect(p.x, p.y, 2, 2);
});
requestAnimationFrame(draw);
}
draw();
</script>Comparaison de performance
La performance SVG se dégrade avec le compte d'éléments car chaque forme est un nœud DOM avec gestion d'événements, style et mise en page. Canvas a un overhead constant par frame quel que soit le compte de formes. Le croisement se situe vers 500 à 2000 éléments selon la complexité. Pour du graphique statique ou peu animé, SVG suffit ; pour des scènes denses temps réel, Canvas.
<!-- SVG DOM overhead grows with element count -->
<!-- 100 circles: SVG ~0.1ms, Canvas ~0.1ms (both fine) -->
<!-- 1000 circles: SVG ~10ms, Canvas ~1ms (Canvas pulls ahead) -->
<!-- 10000 circles: SVG ~500ms+, Canvas ~10ms (SVG struggles) -->
<!-- SVG advantages:
- No redraw needed for CSS changes (browser handles it)
- Hardware-accelerated transforms
- Only changed elements re-render (incremental)
-->
<!-- Canvas advantages:
- Constant redraw cost regardless of history
- No DOM memory overhead per shape
- Direct pixel access (getImageData, putImageData)
-->Approche hybride
Combinez les deux : Canvas pour la couche dense fréquemment redessinée (heatmap, particules) et SVG superposé pour l'UI interactive (info-bulles, poignées de sélection, labels). La couche SVG reste nette et accessible pendant que Canvas gère le gros du pixel. Ce pattern est utilisé par des bibliothèques de cartes comme Leaflet et des outils de graphiques comme ECharts.
<!-- SVG for UI chrome, Canvas for dense content -->
<div style="position:relative; width:800px; height:600px;">
<!-- Canvas renders the heatmap (fast for thousands of cells) -->
<canvas width="800" height="600" style="position:absolute; top:0; left:0;">
</canvas>
<!-- SVG overlay for interactive tooltips and selection -->
<svg width="800" height="600" viewBox="0 0 800 600"
style="position:absolute; top:0; left:0;">
<g id="overlay"></g>
</svg>
</div>
<script>
// Draw heatmap on canvas (performant)
// Add hover tooltips as SVG elements (accessible, styled)
</script>Comparaison d'accessibilité
SVG est intrinsèquement plus accessible : le DOM est parcourable, le texte sélectionnable et cherchable, et <title>/<desc> fournissent des descriptions. Canvas exige du travail supplémentaire — il faut ajouter role/aria-label et fournir du contenu texte de repli dans le tag <canvas>. Pour les graphiques et visualisations de données, l'accessibilité de SVG est un atout majeur.
<!-- SVG: screen readers traverse the DOM -->
<svg role="img" aria-label="Sales chart showing 20% growth">
<title>Sales Chart</title>
<desc>Bar chart with 5 quarters, Q3 highest at $2M</desc>
<rect .../> <!-- each bar is a DOM element -->
</svg>
<!-- Text in SVG is selectable and searchable -->
<!-- Canvas: just pixels to a screen reader -->
<canvas role="img" aria-label="Sales chart showing 20% growth">
<!-- Must provide text fallback inside the canvas tag -->
Sales chart: Q1 $1M, Q2 $1.3M, Q3 $2M, Q4 $1.8M
</canvas>
<!-- No DOM, no selectable text, harder to make accessible -->Sprite SVG
Mise en place du sprite en ligne
Définissez toutes les icônes comme éléments <symbol> dans un SVG caché en haut de la page. Chaque symbol a son propre viewBox et id. Le sprite se charge une fois et se cache pour la session. Utiliser currentColor pour fill/stroke laisse chaque usage hériter de la couleur du texte environnant, rendant le theming trivial.
<!-- Place this hidden SVG at the top of your HTML body -->
<svg xmlns="http://www.w3.org/2000/svg" style="display:none" aria-hidden="true">
<symbol id="icon-home" viewBox="0 0 24 24">
<path d="M12 3 L2 12 H5 V21 H10 V14 H14 V21 H19 V12 H22 Z"/>
</symbol>
<symbol id="icon-user" viewBox="0 0 24 24">
<circle cx="12" cy="8" r="4"/>
<path d="M4 21 C 4 16, 8 14, 12 14 C 16 14, 20 16, 20 21 Z"/>
</symbol>
<symbol id="icon-search" viewBox="0 0 24 24">
<circle cx="11" cy="11" r="7" fill="none" stroke="currentColor" stroke-width="2"/>
<line x1="16" y1="16" x2="21" y2="21" stroke="currentColor" stroke-width="2"/>
</symbol>
</svg>Utiliser les icônes du sprite
Chaque <use> instancie une icône. La classe CSS .icon fixe une taille par défaut ; les sous-classes surchargent pour les variantes. Comme les symbols utilisent fill='currentColor', la couleur de l'icône suit la propriété CSS color — réglez color sur un bouton et son icône matche. C'est ainsi que fonctionnent les grands systèmes d'icônes (GitHub, Bootstrap).
<!-- Reference any icon with <use> -->
<svg class="icon"><use href="#icon-home"/></svg>
<svg class="icon"><use href="#icon-user"/></svg>
<svg class="icon icon-large"><use href="#icon-search"/></svg>
<style>
.icon {
width: 24px;
height: 24px;
fill: currentColor; /* inherits text color */
display: inline-block;
vertical-align: middle;
}
.icon-large { width: 48px; height: 48px; }
</style>
<!-- Color via CSS color (because fill="currentColor") -->
<button style="color: red;">
<svg class="icon"><use href="#icon-home"/></svg> Home
</button>Sprite depuis un fichier externe
Les références de sprite externes (href='fichier.svg#id') ont un support navigateur inégal et des problèmes CORS. L'approche robuste : fetchez le fichier sprite et injectez-le en HTML en ligne en haut du body. Cela se cache via HTTP et marche partout. Beaucoup d'outils de build (svg-sprite-loader, gulp-svg-sprite) automatisent cela.
<!-- icons.svg (a separate file) -->
<svg xmlns="http://www.w3.org/2000/svg" style="display:none">
<symbol id="icon-home" viewBox="0 0 24 24">...</symbol>
</svg>
<!-- Reference external symbols (limited browser support) -->
<svg class="icon"><use href="icons.svg#icon-home"/></svg>
<!-- More reliable: fetch and inject the sprite -->
<script>
fetch("icons.svg")
.then(r => r.text())
.then(text => {
var div = document.createElement("div");
div.style.display = "none";
div.innerHTML = text;
document.body.insertBefore(div, document.body.firstChild);
});
</script>Génération de sprite au build
Les outils de build automatisent la création de sprites : déposez des fichiers .svg individuels dans un dossier, et l'outil les concatène en un sprite avec les bons wrappers <symbol>. svg-sprite-loader (webpack), gulp-svg-sprite et vite-plugin-svg sont populaires. Cela garde les icônes en fichiers séparés en développement mais les bundle en production.
<!-- Using svg-sprite-loader (webpack) -->
// import all icons in a folder
const req = require.context("./icons", true, /\.svg$/);
req.keys().forEach(req);
// In your component:
<svg class="icon"><use href="#icon-home"/></svg>
<!-- Using gulp-svg-sprite -->
// gulpfile.js
const svgSprite = require("gulp-svg-sprite");
gulp.task("sprite", () =>
gulp.src("icons/*.svg")
.pipe(svgSprite({ mode: { symbol: { dest: "." } } }))
.pipe(gulp.dest("dist"))
);
// Outputs dist/symbol/svg/sprite.symbol.svgAccessibilité des icônes de sprite
Pour l'accessibilité : si une icône est purement décorative (à côté de texte), marquez-la aria-hidden='true'. Si elle porte seule un sens, ajoutez role='img' et aria-label sur le <svg>. Pour les boutons à icône seule, mettez l'aria-label sur le <button>, pas sur le SVG. Ne comptez jamais sur l'icône seule sans nom accessible.
<!-- Decorative icon (hidden from screen readers) -->
<svg class="icon" aria-hidden="true">
<use href="#icon-decoration"/>
</svg>
<!-- Meaningful icon (with label) -->
<svg class="icon" role="img" aria-label="Home">
<use href="#icon-home"/>
</svg>
<!-- Icon button with visible text (icon is decorative) -->
<button>
<svg class="icon" aria-hidden="true"><use href="#icon-home"/></svg>
<span>Home</span>
</button>
<!-- Icon-only button (needs aria-label on the button) -->
<button aria-label="Search">
<svg class="icon" aria-hidden="true"><use href="#icon-search"/></svg>
</button>Icônes bicolores et multicolores
Les icônes multicolores sont délicates avec les sprites car les clones <use> sont limités en surcharge. Pour les icônes bicolores, utilisez currentColor pour la principale et une couleur fixe pour la secondaire. Les custom properties CSS (variables) dans le symbol laissent les consommateurs surcharger des parties précises — une technique moderne pour un theming flexible.
<svg style="display:none">
<!-- Icon with two fill regions -->
<symbol id="icon-mail" viewBox="0 0 24 24">
<rect x="2" y="4" width="20" height="16" rx="2" fill="currentColor"/>
<path d="M2 6 L12 13 L22 6" fill="white"/>
</symbol>
</svg>
<!-- Override individual parts via CSS (limited: works if the
symbol uses currentColor and CSS variables) -->
<svg class="icon" style="color: steelblue;">
<use href="#icon-mail"/>
</svg>
<!-- For full multi-color control, use CSS custom properties -->
<symbol id="icon-alert" viewBox="0 0 24 24">
<path fill="var(--icon-bg, currentColor)" d="M12 2 L2 22 H22 Z"/>
<text x="12" y="18" text-anchor="middle" fill="var(--icon-fg, white)">!</text>
</symbol>
<svg class="icon" style="--icon-bg: red; --icon-fg: yellow;">
<use href="#icon-alert"/>
</svg>Optimisation SVG
CLI SVGO
SVGO est l'optimiseur SVG standard. Il retire métadonnées, commentaires, déchets d'éditeur (namespaces Inkscape/Illustrator), defs inutilisés et attributs redondants, souvent en coupant 30 à 60 % de la taille du fichier. Lancez-le sur tous les SVG de production. Utilisez --show-plugins pour voir ce qu'il sait faire, et un fichier de config pour activer/désactiver des optimisations précises.
# Install SVGO globally
npm install -g svgo
# Optimize a single file (overwrites)
svgo icon.svg
# Optimize to a new file
svgo icon.svg -o icon.min.svg
# Optimize a folder
svgo -f icons/ -o icons/min/
# Show available plugins
svgo --show-plugins
# Use a specific config
svgo --config=svgo.config.js icon.svgOptimisations courantes
SVGO retire : déclarations XML, commentaires et namespaces d'éditeur (Adobe, Inkscape), métadonnées, xlink inutilisé, enable-background, xml:space, fill-rule='nonzero' redondant (c'est le défaut). Il raccourcit les valeurs de couleurs (#FF0000 → red), compacte les espaces et fusionne les chemins. Le résultat est sémantiquement identique mais bien plus petit.
<!-- Before optimization (from Illustrator) -->
<?xml version="1.0" encoding="utf-8"?>
<!-- Generator: Adobe Illustrator 25.0 -->
<svg xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns:a="http://ns.adobe.com/AdobeSVGViewerExtensions/3.0/"
width="100px" height="100px" viewBox="0 0 100 100"
enable-background="new 0 0 100 100" xml:space="preserve">
<metadata>...</metadata>
<path d="..." fill="#FF0000" fill-rule="nonzero"/>
</svg>
<!-- After SVGO -->
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
<path d="..." fill="red"/>
</svg>Optimisation des chemins
SVGO convertit les coordonnées absolues en relatives quand plus court, utilise H/V au lieu de L pour les lignes horizontales/verticales, retire les décimales inutiles et peut fusionner les chemins de formes identiques. Ces optimisations de chemin divisent souvent par deux la longueur des chaînes de path. Le plugin 'convertPath' s'en charge ; actif par défaut.
<!-- SVGO can merge and simplify paths -->
<!-- Before: multiple paths with redundant points -->
<g>
<path d="M 10 10 L 20 10 L 20 20 L 10 20 Z" fill="red"/>
<path d="M 10 10 L 20 10 L 20 20 L 10 20 Z" fill="none" stroke="black"/>
</g>
<!-- After: merged into one path with combined commands -->
<path d="M10 10h10v10H10z" fill="red" stroke="black"/>
<!-- Path command shortcuts:
L 20 10 -> h 10 (relative horizontal)
L 10 20 -> v 10 (relative vertical)
Z closes the path
-->Groupement et héritage
Déplacez les attributs partagés (fill, stroke, font) vers un <g> parent pour que les enfants les héritent. Cela réduit la taille du fichier et facilite les changements de style en masse. Les plugins 'mergePaths' et 'moveElemsAttrsToGroup' de SVGO automatisent cela. En écrivant du SVG à la main, groupez dès le départ — plus propre et maintenable.
<!-- Before: repeated attributes on each element -->
<svg viewBox="0 0 100 100">
<rect x="10" y="10" width="20" height="20" fill="red" stroke="black" stroke-width="2"/>
<rect x="40" y="10" width="20" height="20" fill="red" stroke="black" stroke-width="2"/>
<rect x="70" y="10" width="20" height="20" fill="red" stroke="black" stroke-width="2"/>
</svg>
<!-- After: group with shared attributes -->
<svg viewBox="0 0 100 100">
<g fill="red" stroke="black" stroke-width="2">
<rect x="10" y="10" width="20" height="20"/>
<rect x="40" y="10" width="20" height="20"/>
<rect x="70" y="10" width="20" height="20"/>
</g>
</svg>Gzip et livraison
Le SVG se gzippe à 70-90 % car c'est du texte XML répétitif. Assurez-vous que votre serveur web compresse image/svg+xml en gzip ou brotli. Pour la livraison : inlinez le SVG critique (au-dessus de la ligne de flottaison) pour éviter une requête bloquante au rendu ; utilisez <img loading='lazy'> pour les illustrations en dessous. Cachez le SVG agressivement — il change rarement.
<!-- SVG is text, so it gzips very well (70-90% reduction) -->
<!-- Ensure your server sends SVG with gzip/brotli compression: -->
<!-- Apache .htaccess -->
AddType image/svg+xml .svg
<IfModule mod_deflate.c>
AddOutputFilterByType DEFLATE image/svg+xml
</IfModule>
<!-- Nginx -->
# gzip_types image/svg+xml;
<!-- HTML: use the right loading strategy -->
<img src="hero.svg" loading="lazy" decoding="async">
<!-- For above-the-fold critical SVG, inline it to avoid a request -->
<!-- For below-the-fold, use <img loading="lazy"> to defer -->Fichier de config SVGO
Un fichier de config personnalise SVGO. Réglages courants : garder le viewBox (removeViewBox est actif par défaut — désactivez-le pour que le responsive marche), retirer width/height pour les SVG fluides (removeDimensions), et activer cleanupIDs pour les sprites (raccourcit les noms d'id). multipass exécute les optimisations jusqu'à stabilité pour la plus petite sortie.
// svgo.config.js (SVGO 2+)
module.exports = {
multipass: true, // run multiple passes for best result
js2svg: {
indent: 2,
pretty: true, // readable output (false for minified)
},
plugins: [
{ name: "preset-default" }, // sensible defaults
{ name: "removeDimensions", active: true }, // remove width/height (use viewBox)
{ name: "removeViewBox", active: false }, // KEEP viewBox (opposite of default)
{ name: "removeXMLNS", active: false }, // keep xmlns for standalone files
{ name: "cleanupIDs", active: true }, // minify id names
{ name: "mergePaths", active: true },
],
};Bonnes pratiques
Essentiels d'accessibilité
Pour un SVG accessible : ajoutez <title> et <desc>, référencez-les via aria-labelledby, réglez role='img' pour que les lecteurs d'écran annoncent le SVG comme une image, et ajoutez focusable='false' pour prévenir les problèmes d'arrêt de tabulation IE/Edge. Les SVG décoratifs devraient être aria-hidden='true'. Ces pratiques rendent le SVG utilisable avec les technologies d'assistance.
<!-- 1. Always include <title> and <desc> for meaningful SVGs -->
<svg role="img" aria-labelledby="title-id desc-id">
<title id="title-id">Annual Revenue Chart</title>
<desc id="desc-id">A bar chart showing revenue from 2019 to 2023,
rising from $1M to $5M.</desc>
<!-- chart content -->
</svg>
<!-- 2. Decorative SVG: hide from screen readers -->
<svg aria-hidden="true" focusable="false">
<!-- purely visual flourish -->
</svg>
<!-- 3. focusable="false" prevents IE/Edge from making SVG focusable -->
<!-- 4. Use role="img" so screen readers treat SVG as a single image -->Utiliser viewBox, pas width/height
Incluez toujours viewBox — il définit le système de coordonnées interne et permet la mise à l'échelle. Pour les icônes, réglez width/height via CSS (pas en attributs) pour que le même SVG marche à toute taille. Pour les graphiques responsifs, omettez entièrement width/height et utilisez width:100 % ; height:auto en CSS. Le plugin removeDimensions de SVGO l'impose.
<!-- GOOD: viewBox makes the SVG scalable -->
<svg viewBox="0 0 24 24" style="width: 24px; height: 24px;">
<path d="..."/>
</svg>
<!-- BAD: fixed width/height limits scalability -->
<svg width="24" height="24">
<path d="..."/>
</svg>
<!-- For responsive: omit width/height, size with CSS -->
<svg viewBox="0 0 100 100" style="width:100%;height:auto;">
<circle cx="50" cy="50" r="50"/>
</svg>currentColor pour le theming
Utilisez fill='currentColor' (ou stroke) pour que les icônes héritent de la couleur du texte environnant. Cela rend le theming trivial — réglez color sur un parent et toutes les icônes matchent. Cela permet aussi des états hover/actif via des transitions CSS de couleur. Évitez de coder des couleurs en dur dans des symbols réutilisables sauf si intentionnellement fixes (comme un logo de marque).
<!-- GOOD: use currentColor so the icon inherits text color -->
<symbol id="icon" viewBox="0 0 24 24">
<path fill="currentColor" d="..."/>
</symbol>
<!-- Usage: color via CSS -->
<button style="color: tomato;">
<svg class="icon"><use href="#icon"/></svg> Themed
</button>
<button style="color: steelblue;">
<svg class="icon"><use href="#icon"/></svg> Also themed
</button>
<!-- BAD: hardcoded colors can't be themed -->
<symbol id="icon">
<path fill="#333333" d="..."/> <!-- always gray -->
</symbol>Groupement sémantique
Groupez les éléments par leur rôle logique (fond, axes, données, labels) avec des ids significatifs, pas juste par type de forme. Cela rend le SVG plus facile à maintenir, styliser et scripter — on peut montrer/cacher ou restyliser des groupes entiers. Cela aide aussi l'accessibilité (aria-labelledby sur les groupes) et le débogage.
<svg viewBox="0 0 200 200">
<!-- Group by logical component, not just by shape type -->
<g id="background">
<rect width="200" height="200" fill="#f0f0f0"/>
</g>
<g id="chart-axis">
<line x1="20" y1="180" x2="180" y2="180" stroke="black"/>
<line x1="20" y1="20" x2="20" y2="180" stroke="black"/>
</g>
<g id="chart-data" fill="steelblue">
<rect x="30" y="100" width="20" height="80"/>
<rect x="60" y="60" width="20" height="120"/>
<rect x="90" y="80" width="20" height="100"/>
</g>
<g id="labels" font-size="10" fill="black">
<text x="40" y="195" text-anchor="middle">Q1</text>
<text x="70" y="195" text-anchor="middle">Q2</text>
</g>
</svg>Éviter l'overdraw et la complexité
L'overdraw (dessiner des formes entièrement couvertes) gaspille le temps de rendu — retirez les éléments cachés. Simplifiez les chemins : utilisez des courbes C/Q au lieu de centaines de petits segments de ligne ; réduisez la précision décimale (10.499999 → 10.5). Pour des illustrations complexes, considérez si une image raster serait plus petite et plus rapide. Profilez avec le paint profiler du navigateur.
<!-- BAD: layered shapes that cover each other (overdraw) -->
<g>
<rect width="100" height="100" fill="red"/>
<rect width="100" height="100" fill="blue"/> <!-- covers red -->
<rect width="100" height="100" fill="green"/> <!-- covers blue -->
</g>
<!-- The red and blue are never visible but still rendered -->
<!-- GOOD: only draw what's visible -->
<rect width="100" height="100" fill="green"/>
<!-- BAD: path with 10,000 points for a simple shape -->
<path d="..."/> <!-- over-tessellated -->
<!-- GOOD: simplify paths; use curves instead of many line segments -->
<path d="M 10 50 Q 50 10, 90 50"/> <!-- one curve vs 100 lines -->Tests et validation
Testez les SVG comme tout code : validez le XML, vérifiez le rendu inter-navigateurs (Safari a des caprices avec certains filtres), testez à diverses tailles (icônes 16px vs héros 500px), vérifiez la sortie des lecteurs d'écran et contrôlez la taille de fichier (les icônes devraient rester sous 2 Ko). Lancez SVGO en CI pour empêcher les SVG non optimisés de partir en production. Un peu de test prévient les surprises.
<!-- 1. Validate SVG XML -->
<!-- Use the W3C validator: https://validator.w3.org/ -->
<!-- 2. Test in multiple browsers -->
<!-- Chrome, Firefox, Safari, Edge, (IE if required) -->
<!-- 3. Test at different sizes -->
<div style="width: 16px;"><svg>...</svg></div> <!-- icon -->
<div style="width: 500px;"><svg>...</svg></div> <!-- hero -->
<!-- 4. Test with screen readers (VoiceOver, NVDA) -->
<!-- 5. Check file size after optimization -->
ls -la icon.svg # should be under 2KB for simple icons
<!-- 6. Verify currentColor theming works -->
<!-- 7. Ensure no hardcoded dimensions block responsiveness -->Snippets SVG associés
Copy-paste ready code for common tasks.
Basic Shapes
Rect, circle, ellipse, line, polygon, polyline.
Paths
Draw arbitrary curves via the d attribute.
Gradients
Linear and radial color blends.
Transforms
Translate, rotate, scale, and skew groups.
Text
Styled text and tspans.
Filters
Blur, shadow, and other effects.
Animation
SMIL animate, transform, and opacity.
Patterns
Tileable fills defined in defs.
Was this helpful?