Sélecteurs
Sélecteurs d'attribut et pseudo-classes
CSS3 a introduit de puissants sélecteurs d'attribut et pseudo-classes. ^= matche un préfixe, $= un suffixe, *= une sous-chaîne. nth-child permet le zébrage sans JavaScript.
/* attribute selectors */
input[type="text"] { border: 1px solid blue; }
a[href^="https"] { color: green; }
a[href$=".pdf"] { color: red; }
a[href*="example"] { font-weight: bold; }
/* pseudo-classes */
a:visited { color: purple; }
li:first-child { font-weight: bold; }
li:nth-child(odd) { background: #f0f0f0; }
input:focus { outline: 2px solid blue; }Pseudo-classes structurelles
Les pseudo-classes structurelles sélectionnent les éléments selon leur position dans le DOM. :first-child / :last-child visent les extrémités. nth-child(an+b) accepte des formules : 2n est pair, 2n+1 impair, 3n un élément sur trois. :nth-of-type ne compte que les frères du même type d'élément. :empty matche les éléments sans enfant.
/* positional pseudo-classes */
li:first-child { color: green; }
li:last-child { color: red; }
li:only-child { font-weight: bold; }
/* nth variants */
li:nth-child(3) { color: blue; }
li:nth-child(2n+1) { background: #eee; } /* odd */
li:nth-last-child(2) { color: orange; }
/* type-based */
p:first-of-type { font-size: 1.2em; }
p:nth-of-type(even) { color: gray; }
div:empty { display: none; }:is, :where et :has
:is() et :where() regroupent des sélecteurs par concision. La différence : :is() prend la spécificité la plus haute de ses arguments, tandis que :where() a toujours une spécificité nulle — idéal pour des styles de base faciles à surcharger. :has() est l'attendu sélecteur parent/relationnel, permettant de styler un élément selon ses descendants.
/* :is() - matches any selector in the list */
:is(h1, h2, h3) { color: navy; }
:is(.btn, .link):hover { opacity: 0.8; }
/* :where() - same as :is but zero specificity */
:where(article, section) p { line-height: 1.6; }
/* :has() - parent selector (selects element that has a match) */
div:has(> img) { padding: 0; }
card:has(.badge) { border-color: gold; }
form:has(input:invalid) button { opacity: 0.5; }Négation et pseudo-classes de formulaire
:not() nie un sélecteur et accepte désormais une liste. Les pseudo-classes de formulaire (:required, :valid, :invalid, :checked, :placeholder-shown, :in-range) permettent de styler selon l'état de saisie sans JavaScript — parfait pour le retour de validation en ligne et le style personnalisé des checkboxes/radios.
/* :not() excludes matching elements */
input:not([type="checkbox"]) { display: block; }
li:not(:last-child) { border-bottom: 1px solid #ddd; }
/* form state pseudo-classes */
input:required { border-color: red; }
input:optional { border-color: #ccc; }
input:valid { border-color: green; }
input:invalid { border-color: red; }
input:in-range { color: black; }
input:out-of-range { color: red; }
input:placeholder-shown { background: #fafafa; }
input:checked + label { font-weight: bold; }Spécificité et cascade
La spécificité décide quelle règle s'applique quand des sélecteurs entrent en conflit. Comptez IDs, classes et éléments comme (a,b,c). !important outrepasse la cascade mais casse la maintenabilité — évitez-le. À spécificité égale, la règle la plus tardive dans l'ordre source gagne. DevTools montre la cascade calculée.
/* specificity ranking: inline > ID > class/attr/pseudo > type/element */
#nav .item { color: red; } /* 1,1,0 */
.menu .item { color: blue; } /* 0,2,0 */
li.item { color: green; } /* 0,1,1 */
/* !important overrides normal declarations */
.btn { color: white !important; }
/* source order wins on equal specificity */
.late { color: purple; } /* wins over .early */Modèle de boîte
box-sizing
box-sizing: border-box inclut padding et bordure dans la largeur/hauteur déclarée, rendant le dimensionnement prévisible. content-box (défaut) les ajoute par-dessus. Appliquer border-box globalement est le reset CSS le plus important — il élimine les casse-têtes de calcul de mise en page les plus courants.
/* default: width = content only */
.box-content { box-sizing: content-box; width: 200px; padding: 20px; } /* total 240px */
/* padding & border inside width */
.box-border { box-sizing: border-box; width: 200px; padding: 20px; border: 2px solid; } /* total 200px */
/* universal reset - apply everywhere */
*, *::before, *::after {
box-sizing: border-box;
}Margin et padding
Le padding est à l'intérieur de la bordure (hérite du fond) ; la marge à l'extérieur (transparente). Les marges verticales entre éléments bloc adjacents se réduisent à la plus grande — les marges horizontales ne se réduisent jamais. margin: 0 auto centre un élément bloc de largeur définie. Les marges négatives peuvent tirer le contenu mais à employer avec parcimonie.
.box {
/* top right bottom left (clockwise) */
margin: 10px 20px 15px 25px;
/* 2 values: vertical horizontal */
padding: 10px 20px;
/* single value: all sides */
margin: 0 auto; /* horizontal centering for fixed-width block */
}
/* margin collapse (vertical only) */
.a { margin-bottom: 30px; }
.b { margin-top: 20px; }
/* gap between .a and .b = 30px, not 50px (collapsed to larger) */
/* negative margins pull elements together */
.pull-left { margin-left: -10px; }box-shadow
Syntaxe de box-shadow : décalage-x décalage-y rayon-flou rayon-diffusion couleur. Les décalages positifs poussent l'ombre à droite/en bas. inset crée une ombre intérieure. Plusieurs ombres se superposent, la première au-dessus. Employez rgba pour des ombres translucides et naturelles. Les ombres dures (flou nul) créent une esthétique plate et affirmée.
/* offset-x offset-y blur spread color */
.card { box-shadow: 0 4px 6px rgba(0,0,0,0.1); }
/* inset shadow (inside the box) */
.inset { box-shadow: inset 0 2px 4px rgba(0,0,0,0.2); }
/* multiple shadows (first = top layer) */
.layered { box-shadow: 0 1px 2px #000, 0 8px 24px rgba(0,0,0,0.15); }
/* no blur, hard shadow (neo-brutalism) */
.hard { box-shadow: 6px 6px 0 #000; }
/* glow effect */
.glow { box-shadow: 0 0 20px rgba(0,150,255,0.6); }Types de display
display: none retire l'élément de la mise en page (aucun espace réservé). Les éléments block prennent toute la largeur et s'empilent verticalement ; les inline s'écoulent avec le texte et ignorent width/height. inline-block combine le flux inline et le dimensionnement block. flow-root nettoie les floats sans hacks clearfix. contents fait disparaître la boîte en gardant les enfants dans la mise en page.
/* block: full width, new line */
div, p { display: block; }
/* inline: flows with text, ignores width/height */
span, a { display: inline; }
/* inline-block: flows inline but accepts width/height */
.tag { display: inline-block; width: 100px; }
/* none: removed from layout entirely */
.hidden { display: none; }
/* modern display values */
.flow { display: flow-root; } /* new block formatting context */
.contents { display: contents; } /* element's box disappears, children participate */Overflow
overflow contrôle le traitement du contenu dépassant la boîte. visible (défaut) le laisse déborder ; hidden le coupe ; auto ajoute des barres de défilement au besoin ; scroll les montre toujours. clip (plus récent) ressemble à hidden mais empêche tout défilement, même via JS. Employez overflow-y/x pour contrôler les axes indépendamment. Régler overflow à autre chose que visible crée un nouveau contexte de formatage.
.scrollable {
overflow: auto; /* scrollbars when needed */
overflow-y: scroll; /* always show vertical scrollbar */
overflow-x: hidden; /* hide horizontal overflow */
}
/* visible (default) - content spills out */
.spill { overflow: visible; }
/* clip - like hidden but no programmatic scroll */
.clipped { overflow: clip; }
/* clip to a shape */
.custom-clip {
overflow: clip;
overflow-clip-margin: 20px;
}
/* longhand for both axes */
.both { overflow-x: hidden; overflow-y: auto; }Flexbox
Conteneur flex
display: flex transforme un élément en conteneur flex. justify-content aligne les items le long de l'axe principal (horizontal en row) ; align-items le long de l'axe transversal. flex-wrap laisse les items passer à de nouvelles lignes. gap remplace l'astuce d'espacement par marges. Flexbox excelle dans les mises en page unidimensionnelles (lignes ou colonnes).
.container {
display: flex;
flex-direction: row; /* row | row-reverse | column | column-reverse */
justify-content: center; /* main axis: flex-start | center | space-between | space-around | space-evenly */
align-items: center; /* cross axis: stretch | flex-start | center | baseline */
flex-wrap: wrap; /* nowrap | wrap | wrap-reverse */
gap: 16px; /* spacing between items */
align-content: space-between; /* multi-line spacing */
}Items flex
flex-grow contrôle comment un item s'étend pour remplir l'espace supplémentaire (1 = part égale). flex-shrink contrôle le rétrécissement. flex-basis est la taille initiale. Le raccourci flex: 1 signifie une croissance égale depuis une base nulle — parfait pour des colonnes égales. align-self outrepasse align-items du conteneur pour un item unique. order réordonne visuellement sans changer l'ordre DOM.
.item {
flex-grow: 1; /* grow to fill extra space (0 = don't grow) */
flex-shrink: 1; /* shrink when space is tight (0 = don't shrink) */
flex-basis: 200px; /* initial size before growing/shrinking */
/* shorthand: flex: grow shrink basis */
flex: 1 1 200px; /* flexible from 200px */
flex: 1; /* = 1 1 0% - equal distribution */
flex: 0 0 250px; /* fixed width, no grow/shrink */
align-self: flex-end; /* override align-items for this item */
order: 2; /* visual reordering (default 0) */
}Patterns d'alignement flex
Flexbox rend le centrage trivial : justify-content: center + align-items: center. Un footer épinglé emploie un body flex en colonne avec min-height: 100vh et le contenu principal à flex: 1. Pour les barres de navigation, space-between pousse le premier et le dernier item vers les bords opposés. Les marges auto (margin-left: auto) sont une alternative flexible à justify-content pour pousser des items.
/* perfect centering */
.center {
display: flex;
justify-content: center;
align-items: center;
min-height: 100vh;
}
/* sticky footer: body is flex column */
body { display: flex; flex-direction: column; min-height: 100vh; }
main { flex: 1; } /* grows to fill, pushing footer down */
/* navbar: space between */
.nav { display: flex; justify-content: space-between; }
/* auto margins absorb space */
.push-right { margin-left: auto; }Flex wrap et grille responsif
flex-wrap: wrap laisse les items passer à de nouvelles lignes quand l'espace manque. flex: 1 1 280px crée des cartes qui démarrent à 280px et grandissent pour remplir la rangée. Cela fait une grille de cartes responsif sans media queries. Attention : les items de la dernière rangée s'étirent pour remplir, ce qui peut sembler inégal — pour des grilles de cartes cohérentes, CSS Grid est souvent un meilleur choix.
.cards {
display: flex;
flex-wrap: wrap;
gap: 20px;
}
.card {
/* start at 280px, grow & shrink fluidly */
flex: 1 1 280px;
/* prevent stretching beyond readable width */
max-width: 100%;
}
/* OR fixed-width cards that wrap */
.card-fixed {
flex: 0 0 300px;
}
/* last row items stretch to fill - to avoid, use grid instead */
/* gap wraps with items automatically */Flex direction et axes
flex-direction détermine l'axe principal. En row (défaut), justify-content contrôle l'alignement horizontal ; en column, il contrôle l'alignement vertical — les axes s'échangent. Demandez-vous toujours « lequel est l'axe principal ? » quand vous alignez. row-reverse et column-reverse renversent l'ordre des items, affectant aussi la distribution de l'espace par justify-content.
/* row: main axis = horizontal */
.row { display: flex; flex-direction: row; justify-content: center; }
/* column: main axis = vertical (axes swap!) */
.col { display: flex; flex-direction: column; align-items: center; }
/* reverse order */
.reverse { display: flex; flex-direction: row-reverse; }
/* centering in column: justify-content centers vertically */
.col-center {
display: flex;
flex-direction: column;
justify-content: center; /* vertical center */
align-items: center; /* horizontal center */
}Grid Layout
Conteneur grid
display: grid crée une mise en page bidimensionnelle. grid-template-columns définit les pistes de colonnes ; l'unité fr distribue l'espace libre proportionnellement. repeat(auto-fit, minmax(200px, 1fr)) est la recette magique des grilles responsives — les colonnes se créent et se redimensionnent sans media queries. gap ajoute proprement de l'espace entre les pistes.
.grid {
display: grid;
/* fixed columns */
grid-template-columns: 200px 1fr 200px;
/* responsive auto columns */
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
grid-template-rows: auto 1fr auto;
gap: 20px; /* row + column gap */
row-gap: 20px; /* gap between rows */
column-gap: 16px; /* gap between columns */
}Grid template areas
grid-template-areas permet de dessiner la mise en page visuellement avec des régions nommées — extrêmement lisible. Chaque chaîne citée est une rangée ; les noms placent les items, un point marque une cellule vide. Un item avec grid-area: name remplit cette région. C'est la façon la plus claire de bâtir des mises en page de niveau page comme les coquilles d'app.
.layout {
display: grid;
grid-template-columns: 200px 1fr;
grid-template-rows: auto 1fr auto;
grid-template-areas:
"header header"
"sidebar main"
"footer footer";
min-height: 100vh;
}
.header { grid-area: header; }
.sidebar { grid-area: sidebar; }
.main { grid-area: main; }
.footer { grid-area: footer; }
/* empty cell with a dot */
grid-template-areas: "header header" "sidebar .";Placement des items grid
Les items grid peuvent se placer explicitement par numéros de lignes. grid-column: 1 / 3 s'étend de la ligne 1 à la ligne 3 (couvrant 2 colonnes). Le mot-clé span dimensionne par nombre de pistes. Les lignes peuvent aussi se nommer dans grid-template-columns pour la lisibilité. Sans placement explicite, les items s'écoulent automatiquement dans les cellules disponibles.
.item {
/* place by line numbers: row-start / col-start / row-end / col-end */
grid-column: 1 / 3; /* span columns 1 to 3 */
grid-row: 1 / 2;
/* span keyword */
grid-column: span 2; /* span 2 columns */
grid-row: 2 / span 3;
/* shorthand: grid-area: row-start / col-start / row-end / col-end */
grid-area: 1 / 1 / 3 / 4;
/* name a line and reference it */
grid-column-start: content-start;
}Alignement grid
L'alignement grid fonctionne à deux niveaux. justify-content/align-content positionnent toute la grille dans le conteneur quand il reste de l'espace. justify-items/align-items alignent les items dans leurs cellules (stretch par défaut). justify-self/align-self surchargent l'alignement par item. 'justify' = axe inline/principal, 'align' = axe bloc/transversal.
.grid {
display: grid;
grid-template-columns: repeat(3, 100px);
/* align tracks within container */
justify-content: center; /* center the grid horizontally */
align-content: center; /* center vertically (needs fixed height) */
/* align items within their cells */
justify-items: stretch; /* fill cell width (default) */
align-items: center; /* center within cell height */
}
.item {
justify-self: start; /* override justify-items for one item */
align-self: end;
}auto-fit vs auto-fill
Tous deux créent autant de pistes que possible, mais se comportent différemment avec peu d'items. auto-fit referme les pistes inutilisées et étire les items existants pour remplir la rangée. auto-fill garde les pistes vides, les items gardent donc leur taille minimale. Employez auto-fit pour que les items grandissent et remplissent ; auto-fill pour une taille d'item fixe et cohérente.
/* auto-fit: empty tracks collapse, items stretch to fill */
.autofit {
grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
}
/* auto-fill: empty tracks remain, items keep their size */
.autofill {
grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
}
/* with few items:
auto-fit -> items stretch to fill the row
auto-fill -> items stay small, leaving empty columns */Positionnement
Valeurs de position
static est le défaut. relative décale un élément de sa position de flux normale (l'espace est préservé). absolute le retire du flux et le positionne relativement à l'ancêtre positionné le plus proche (ou la fenêtre). fixed est relatif à la fenêtre du navigateur. sticky bascule entre relative et fixed selon la position de défilement — idéal pour les en-têtes épinglés.
/* static - default, flows normally */
.static { position: static; }
/* relative - offset from its normal position */
.relative { position: relative; top: 10px; left: 20px; }
/* absolute - positioned relative to nearest positioned ancestor */
.absolute { position: absolute; top: 0; right: 0; }
/* fixed - positioned relative to viewport (stays on scroll) */
.fixed { position: fixed; bottom: 0; left: 0; }
/* sticky - relative until scroll threshold, then fixed */
.sticky { position: sticky; top: 0; }Centrage absolu
Plusieurs façons de centrer absolument. L'astuce translate(-50%, -50%) fonctionne sur des éléments de toute taille. La technique inset: 0 + margin: auto exige des dimensions explicites. L'approche moderne est display: grid avec place-items: center (raccourci de align-items + justify-items) — aucun calcul de positionnement, la méthode la plus simple.
/* classic: position absolute + transform */
.center {
position: absolute;
top: 50%; left: 50%;
transform: translate(-50%, -50%);
}
/* inset: 0 + margin: auto (needs width/height) */
.center-auto {
position: absolute;
inset: 0; /* top/right/bottom/left: 0 */
margin: auto;
width: 300px;
height: 200px;
}
/* modern: no positioning needed */
.center-grid { display: grid; place-items: center; }Positionnement sticky
position: sticky garde un élément dans le flux normal jusqu'à un seuil (ex. top: 0), puis il se colle comme fixed. Parfait pour des en-têtes épinglés ou des sommaires latéraux. Piège : tout ancêtre avec overflow: hidden/auto/scroll (dans le sens de défilement) devient le bloc contenant et casse le comportement attendu. Réglez toujours un fond et un z-index sur les éléments sticky.
.header {
position: sticky;
top: 0; /* sticks when header hits top of viewport */
z-index: 100;
background: white;
}
/* sticky sidebar that scrolls with content until threshold */
.sidebar {
position: sticky;
top: 60px; /* offset below the fixed header */
max-height: calc(100vh - 60px);
overflow-y: auto;
}
/* NOTE: a parent with overflow: hidden breaks sticky */z-index et contextes d'empilement
z-index ne fonctionne que sur les éléments positionnés (non static). Un contexte d'empilement est créé par position + z-index, mais aussi par opacity < 1, transform, filter, will-change et isolation: isolate. Dans un contexte d'empilement, les z-index enfants sont isolés — un enfant ne peut jamais se rendre au-dessus d'un frère d'un ancêtre. Comprendre cela prévient les guerres d'escalade de z-index.
.modal { position: fixed; z-index: 1000; }
.overlay { position: fixed; z-index: 999; }
.card { position: relative; z-index: 1; }
/* creating a stacking context (isolates z-index) */
.context {
position: relative;
z-index: 0; /* children's z-index only matters within this */
}
/* other properties that create stacking contexts:
opacity < 1, transform, filter, will-change, isolation: isolate */
.isolated { isolation: isolate; }Raccourci inset
inset est le raccourci logique de top, right, bottom et left — comme margin/padding il accepte 1, 2 ou 4 valeurs. inset: 0 étire un élément positionné en absolu pour remplir son bloc contenant. Plus propre que de déclarer quatre propriétés séparées et s'accorde bien à margin: auto pour centrer.
/* inset sets top right bottom left (like margin) */
.popup {
position: absolute;
inset: 0; /* all sides = 0 (stretches to fill parent) */
}
/* two values: vertical horizontal */
.pill {
position: absolute;
inset: 10px 20px; /* top/bottom 10px, left/right 20px */
}
/* four values: top right bottom left */
.box {
position: absolute;
inset: 10px 20px 30px 40px;
}
/* longhand equivalents */
.inset-longhand {
position: absolute;
top: 0; right: 0; bottom: 0; left: 0;
}Style du texte
Propriétés de police
font-family devrait toujours se terminer par une famille générique (serif, sans-serif, monospace) comme repli de dernier recours. font-weight va de 100 à 900 ; courants : 400 normal, 700 bold. line-height se règle mieux sans unité (1.5) pour qu'il suive la taille de police. Le raccourci font exige taille et famille ; l'ordre est style graisse taille/hauteur-de-ligne famille.
body {
font-family: "Helvetica Neue", Arial, sans-serif; /* fallback chain */
font-size: 16px;
font-weight: 400; /* 100-900; 400=normal, 700=bold */
font-style: italic; /* normal | italic | oblique */
line-height: 1.5; /* unitless = multiplier of font-size */
letter-spacing: 0.5px;
word-spacing: 2px;
font-variant: small-caps;
}
/* shorthand: style weight size/line-height family (order matters) */
p { font: italic 700 16px/1.5 "Georgia", serif; }Formatage du texte
text-align: justify peut créer des rivières d'espaces ; associez hyphens: auto pour des blocs plus propres. text-decoration accepte désormais line, style et color dans un seul raccourci. text-transform: capitalize met une majuscule à chaque mot. white-space: nowrap empêche le retour à la ligne. text-shadow prend décalage-x décalage-y flou couleur.
.text {
text-align: justify; /* left | right | center | justify */
text-decoration: underline wavy red; /* line style color */
text-decoration: line-through;
text-transform: uppercase; /* lowercase | capitalize */
text-indent: 2em; /* first-line indent */
white-space: nowrap; /* prevent wrapping */
word-break: break-word; /* break long words */
hyphens: auto; /* auto-hyphenate (needs lang attr) */
text-shadow: 2px 2px 4px rgba(0,0,0,0.5);
}Débordement de texte et ellipse
La troncature sur une ligne exige trois propriétés : white-space: nowrap, overflow: hidden, text-overflow: ellipsis. Pour la troncature multi-lignes, employez -webkit-line-clamp avec display: -webkit-box (le préfixe -webkit- est encore requis mais fonctionne dans tous les navigateurs modernes). Une max-width ou width est nécessaire pour que la troncature se déclenche.
.truncate {
/* three properties required for ellipsis */
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis; /* clip | ellipsis */
max-width: 200px;
}
/* multi-line clamp (line-clamp) */
.clamp {
display: -webkit-box;
-webkit-line-clamp: 3; /* limit to 3 lines */
-webkit-box-orient: vertical;
overflow: hidden;
}
/* custom fade effect */
.fade {
-webkit-mask-image: linear-gradient(to bottom, black 70%, transparent);
}text-shadow et effets
text-shadow prend décalage-x décalage-y rayon-flou couleur. Plusieurs ombres se superposent, la première au-dessus — utile pour des halos néon ou des contours de texte (une ombre à 4 directions imite un contour). Contrairement à -webkit-text-stroke, text-shadow est universellement géré. Les ombres dures (sans flou) créent une esthétique rétro, façon autocollant.
/* x-offset y-offset blur color */
.shadow { text-shadow: 2px 2px 4px rgba(0,0,0,0.3); }
/* multiple shadows (first = top) */
.neon { text-shadow: 0 0 10px #fff, 0 0 20px #fff, 0 0 30px #0ff; }
/* 3D letterpress effect */
.letterpress { text-shadow: 0 1px 0 rgba(255,255,255,0.5); }
/* outline text (no blur, light color) */
.outline { text-shadow: -1px -1px 0 #000, 1px -1px 0 #000, -1px 1px 0 #000, 1px 1px 0 #000; }
/* hard shadow retro effect */
.retro { text-shadow: 4px 4px 0 #ff6b6b; }Modes d'écriture et direction
writing-mode contrôle la direction du texte : horizontal-tb (défaut), vertical-rl (ex. chinois/japonais traditionnel), ou vertical-lr. direction: rtl traite les langues de droite à gauche comme l'arabe. Les propriétés logiques (margin-inline-start, padding-block, inset-inline-end) s'adaptent automatiquement au mode d'écriture et à la direction — essentiel pour des mises en page vraiment internationales et agnostiques de direction.
/* horizontal (default) */
.horizontal { writing-mode: horizontal-tb; }
/* vertical, top to bottom */
.vertical-rl { writing-mode: vertical-rl; }
.vertical-lr { writing-mode: vertical-lr; }
/* text direction */
.rtl { direction: rtl; unicode-bidi: bidi-override; }
/* logical properties adapt to writing mode */
.box {
margin-inline-start: 10px; /* logical left in LTR */
padding-block: 20px; /* logical top/bottom */
inset-inline-end: 0; /* logical right in LTR */
}Fonds et dégradés
Raccourci background
Le raccourci background accepte toutes les propriétés de fond. En combinant position et size, séparez-les d'un slash (center/cover). Plusieurs fonds se superposent séparés par des virgules, premier déclaré = au-dessus. Une couleur pleine devrait toujours venir en dernier comme repli. Employez cover pour remplir la boîte et contain pour caser toute l'image.
.box {
/* longhand */
background-color: #fff;
background-image: url("bg.png");
background-repeat: no-repeat;
background-position: center;
background-size: cover;
background-attachment: fixed;
/* shorthand (color image position/size repeat attachment) */
background: #fff url("bg.png") center/cover no-repeat fixed;
}
/* multiple backgrounds (first = top layer) */
.multi {
background: url("top.png") top left/contain no-repeat,
url("bottom.png") bottom right/cover no-repeat #eee;
}Dégradés linéaires
linear-gradient(direction, arrêts-de-couleur) crée une transition douce. La direction peut être un mot-clé (to right) ou un angle (45deg). Les arrêts peuvent porter des positions en pourcentage — placer deux arrêts à la même position crée un bord dur (parfait pour des rayures). Les dégradés sont des images, ils vont donc sur background-image et s'emploient partout où des images sont acceptées.
/* direction or angle, then color stops */
.gradient { background: linear-gradient(to right, red, blue); }
.gradient-45 { background: linear-gradient(45deg, red, blue); }
/* multiple color stops */
.rainbow { background: linear-gradient(to right, red, orange, yellow, green, blue); }
/* color stops with positions */
.hard-stop { background: linear-gradient(to right, red 0%, red 50%, blue 50%, blue 100%); }
/* transparent stops for fade effects */
.fade { background: linear-gradient(to bottom, rgba(0,0,0,0.5), transparent); }Dégradés radiaux et coniques
radial-gradient irradie depuis un point central — utile pour les projecteurs et boutons. On peut positionner le centre (at top left) et contrôler forme/taille (circle, closest-side). conic-gradient fait tourner les couleurs autour d'un point — parfait pour les camemberts et roues de couleurs. Les arrêts durs dans les dégradés coniques créent des parts de camembert nettes.
/* radial: radiates from a center point */
.radial { background: radial-gradient(circle, red, blue); }
.radial-c { background: radial-gradient(circle at top left, #fff, #000); }
.radial-size { background: radial-gradient(closest-side, red, blue); }
/* conic: rotates around a center point */
.pie { background: conic-gradient(red 0% 30%, blue 30% 70%, green 70% 100%); }
/* conic with angle start */
.spin { background: conic-gradient(from 45deg, red, yellow, green, red); }background-clip et origin
background-clip contrôle jusqu'où le fond s'étend : border-box (défaut, sous la bordure), padding-box (à l'intérieur de la bordure), ou content-box (à l'intérieur du padding). L'astuce des titres : background-clip: text avec color: transparent remplit le texte d'un dégradé ou d'une image. Incluez toujours la version préfixée -webkit- pour Safari. background-origin fixe la zone de positionnement.
/* clip: where the background paints */
.border-box { background-clip: border-box; } /* default - under border */
.padding-box { background-clip: padding-box; } /* inside border */
.content-box { background-clip: content-box; } /* inside padding */
/* text clip: gradient-filled text */
.gradient-text {
background: linear-gradient(to right, red, blue);
-webkit-background-clip: text;
background-clip: text;
color: transparent;
-webkit-text-fill-color: transparent;
}
/* origin: where positioning starts */
.origin { background-origin: content-box; }Attachment du fond et parallaxe
background-attachment: fixed crée un effet de parallaxe — le fond reste fixe tandis que le contenu défile par-dessus. scroll (défaut) bouge avec l'élément ; local défile avec le contenu de l'élément (utile pour les boîtes défilables). L'attachement fixed est saccadé et mal géré sur mobile ; pour une parallaxe de production, employez plutôt transform: translate3d selon la position de scroll.
/* fixed: background stays put during scroll (parallax) */
.parallax {
background-image: url("hero.jpg");
background-attachment: fixed;
background-size: cover;
height: 100vh;
}
/* scroll: scrolls with element (default) */
.scroll { background-attachment: scroll; }
/* local: scrolls with element's content */
.local {
background-attachment: local; /* scrolls with inner content */
}
/* NOTE: background-attachment: fixed has poor mobile support
prefer transform-based parallax for mobile */Bordures et coins arrondis
border-radius
border-radius arrondit les coins, avec 1 à 4 valeurs (dans le sens horaire depuis le haut-gauche). Un slash sépare les rayons horizontal/vertical pour des coins elliptiques. border-radius: 50% sur un carré crée un cercle parfait ; sur un rectangle, une ellipse. Les propriétés longues (border-top-left-radius) contrôlent les coins individuels. Les coins arrondis coupent fonds, bordures et (avec overflow: hidden) le contenu enfant.
.box { border-radius: 10px; } /* all corners */
.box-2 { border-radius: 10px 20px; } /* top-left/bottom-right top-right/bottom-left */
.box-4 { border-radius: 10px 20px 30px 40px; } /* TL TR BR BL (clockwise) */
/* per-corner longhand */
.card {
border-top-left-radius: 10px;
border-top-right-radius: 20px;
border-bottom-right-radius: 30px;
border-bottom-left-radius: 40px;
}
/* elliptical corners (horizontal / vertical) */
.ellipse { border-radius: 50px / 25px; }
/* perfect circle (square element) */
.circle { border-radius: 50%; }border-image
border-image découpe une image en 9 régions et applique coins/bords à une bordure. border-image-slice divise l'image source ; repeat contrôle le pavage des bords. Une astuce moderne : employer border-image avec un linear-gradient et slice 1 pour créer des bordures en dégradé. Note : border-image remplace border-style, réglez donc border-width d'abord.
.frame {
border: 20px solid transparent;
border-image-source: url("frame.png");
border-image-slice: 30; /* slice image into 9 regions */
border-image-width: 20px;
border-image-outset: 0;
border-image-repeat: stretch; /* stretch | repeat | round | space */
}
/* shorthand */
.frame-shorthand {
border: 20px solid transparent;
border-image: url("frame.png") 30 stretch;
}
/* gradient border (using border-image) */
.grad-border {
border: 4px solid;
border-image: linear-gradient(to right, red, blue) 1;
}Bordures multiples
CSS ne peut empiler plusieurs propriétés border, mais il y a des parades. box-shadow à décalage et diffusion nuls crée des bordures extérieures nettes (fonctionne avec border-radius). outline trace une seconde bordure à l'extérieur, mais ignore border-radius. Un pseudo-élément donne un contrôle total, rayon compris. Chaque technique a ses compromis — choisissez selon le besoin de coins arrondis.
/* technique 1: box-shadow (no rounded issue) */
.multi-shadow {
box-shadow: 0 0 0 5px red, 0 0 0 10px blue;
}
/* technique 2: outline (outside border, no radius) */
.outline-border {
border: 5px solid red;
outline: 5px solid blue;
outline-offset: 0;
}
/* technique 3: pseudo-element (full control) */
.pseudo-border {
position: relative;
border: 5px solid red;
}
.pseudo-border::after {
content: "";
position: absolute;
inset: -10px;
border: 5px solid blue;
border-radius: inherit;
}Bordures en dégradé
Les bordures en dégradé sont délicates car border-image ne gère pas border-radius. La solution robuste : superposer deux fonds — une couleur pleine coupée à padding-box et un dégradé coupé à border-box, avec une bordure transparente. Cela respecte border-radius et fonctionne partout. La méthode border-image plus simple convient quand les coins arrondis ne sont pas nécessaires.
/* method 1: border-image (works but no border-radius) */
.grad-1 {
border: 4px solid;
border-image: linear-gradient(to right, red, blue) 1;
}
/* method 2: background-clip trick (works with radius) */
.grad-2 {
border: 4px solid transparent;
border-radius: 12px;
background:
linear-gradient(white, white) padding-box,
linear-gradient(to right, red, blue) border-box;
}
/* method 3: mask + pseudo (advanced, supports radius + animation) */Outline et styles de focus
outline se trace à l'extérieur de la bordure et n'affecte pas la mise en page, l'idéal pour les indicateurs de focus. outline-offset ajoute un écart. Règle d'accessibilité critique : ne réglez jamais outline: none sans alternative visible. :focus-visible ne montre l'outline que pour la navigation clavier (pas les clics souris) — l'approche moderne et sympathique du style de focus.
/* outline: doesn't affect layout, draws outside border */
.focusable:focus {
outline: 2px solid blue;
outline-offset: 2px; /* gap between element and outline */
}
/* never use outline: none without a replacement */
button:focus { outline: none; box-shadow: 0 0 0 3px rgba(0,150,255,0.5); }
/* :focus-visible: only shows outline for keyboard users */
button:focus-visible { outline: 2px solid blue; outline-offset: 2px; }
button:focus:not(:focus-visible) { outline: none; }
/* outline shorthand */
.box { outline: 2px dashed red; }Transforms
Transforms 2D
Les transforms 2D — translate, rotate, scale, skew — déplacent et déforment les éléments sans affecter la mise en page (les frères ne se reforment pas). Les transforms combinés s'appliquent de droite à gauche, l'ordre compte donc : rotate avant translate déplace le long de l'axe tourné. Comme les transforms ne déclenchent pas de reflow, ils sont idéals pour les animations et accélérés GPU.
.box { transform: translate(50px, 20px); } /* move right 50, down 20 */
.box-x { transform: translateX(50px); }
.box-scale { transform: scale(1.5); } /* grow 1.5x */
.box-scale-2 { transform: scale(1, 2); } /* x 1, y 2 */
.box-rotate { transform: rotate(45deg); } /* clockwise */
.box-skew { transform: skew(20deg, 10deg); } /* skew x, y */
/* combine transforms (order matters!) */
.combo { transform: translate(20px, 0) rotate(45deg) scale(1.2); }
/* transform does NOT affect layout (no reflow) */transform-origin
transform-origin fixe le pivot des transforms — le défaut est le centre de l'élément. Il accepte mots-clés (top left), pixels ou pourcentages. Changer l'origine altère fortement rotation et mise à l'échelle : une carte qui se retourne par son bord supérieur exige transform-origin: top. Pour les transforms 3D, une troisième valeur d'axe z peut se préciser.
.box { transform: rotate(45deg); }
/* default origin: center center (50% 50%) */
.center { transform-origin: center center; }
/* rotate around top-left corner */
.tl { transform-origin: top left; transform: rotate(45deg); }
/* custom point (x y) */
.custom { transform-origin: 20px 50px; transform: rotate(45deg); }
/* 3-value form (x y z) */
.three-d { transform-origin: 0 0 100px; }
/* percentage-based */
.pct { transform-origin: 100% 0; } /* top-right corner */Transforms 3D
Les transforms 3D ajoutent rotateX, rotateY, rotateZ, translateZ et scaleZ. perspective(n) doit s'appliquer comme première fonction de transform (ou sur le parent) pour activer la profondeur — des valeurs plus petites exagèrent l'effet 3D. translate3d et scale3d sont accélérés GPU et performent mieux dans les animations que leurs homologues 2D.
.card { transform: perspective(1000px) rotateY(45deg); }
/* rotateX/Y/Z - rotate around 3D axes */
.flip { transform: rotateX(180deg); } /* flip horizontally */
.turn { transform: rotateY(180deg); } /* flip like a page */
.spin { transform: rotateZ(90deg); } /* same as rotate() */
/* translate3d (GPU-accelerated) */
.move { transform: translate3d(50px, 20px, 100px); }
/* scale3d */
.grow { transform: scale3d(1.5, 1.5, 1.5); }
/* combined 3D */
.combo-3d { transform: perspective(800px) rotateX(15deg) rotateY(-20deg) translateZ(-50px); }Perspective et espace 3D
perspective définit la distance du spectateur — plus petite = 3D plus dramatique. Placez-la sur le parent pour que tous les enfants partagent le même point de fuite. transform-style: preserve-3d laisse les éléments imbriqués vivre dans un espace 3D partagé (essentiel pour construire des cubes). backface-visibility: hidden masque le dos d'un élément — clé pour les effets de carte qui se retourne.
/* perspective on parent: applies to all children uniformly */
.scene { perspective: 1000px; }
.cube { transform: rotateY(45deg); }
/* perspective() in transform: only affects that element */
.solo { transform: perspective(1000px) rotateY(45deg); }
/* perspective-origin: vanishing point */
.scene { perspective: 1000px; perspective-origin: top left; }
/* transform-style: preserve-3d lets children share 3D space */
.cube {
transform-style: preserve-3d;
transform: rotateY(30deg);
}
.cube .face { position: absolute; transform: translateZ(50px); }
/* backface-visibility: hide back of flipped element */
.card { backface-visibility: hidden; }Animer les transforms (performance)
Animez toujours transform et opacity — accélérés GPU, ils ne déclenchent ni mise en page (reflow) ni peinture. Animer top/left/width/margin force le navigateur à recalculer la mise en page à chaque frame, causant des à-coups. will-change: transform suggère au navigateur de préparer une couche de compositeur à l'avance, mais l'abus gaspille la mémoire. Appliquez-le juste avant une animation et retirez-le après.
/* GOOD: animate transform & opacity (GPU-accelerated) */
.smooth {
transition: transform 0.3s ease;
}
.smooth:hover { transform: translateY(-5px); }
/* BAD: animating top/left triggers reflow */
.janky { transition: top 0.3s; }
.janky:hover { top: -5px; }
/* will-change: hint the browser to optimize */
.prepared {
will-change: transform; /* prepare for upcoming transform changes */
}
/* force GPU layer (use sparingly) */
.gpu { transform: translateZ(0); }Transitions
Raccourci transition
transition : propriété durée fonction-de-timing délai. Le défaut est all 0s ease 0s — écrire simplement transition: 0.3s anime toutes les propriétés changées. Pour la performance et le contrôle, listez les propriétés précises. Plusieurs transitions se séparent par des virgules. La transition se pose sur l'état par défaut de l'élément (pas :hover), pour que l'animation inverse se joue aussi.
.btn {
background: blue;
/* shorthand: property duration timing-function delay */
transition: background 0.3s ease 0s;
/* common usage */
transition: all 0.3s ease;
/* multiple properties (comma-separated) */
transition: background 0.3s, transform 0.2s ease-out;
/* list the same duration on many properties */
transition: 0.3s;
}
.btn:hover {
background: darkblue;
transform: scale(1.05);
}Fonctions de timing
Les fonctions de timing contrôlent l'accélération. ease (défaut) est douce. ease-out paraît la plus réactive pour l'UI (départ rapide, arrivée lente). linear paraît peu naturelle pour la plupart des mouvements. cubic-bezier(x1,y1,x2,y2) permet de façonner des courbes personnalisées — des valeurs hors 0-1 sur l'axe y créent dépassement/rebond. steps(n) crée des sauts discrets, utile pour les animations en planches de sprites.
.ease { transition: all 0.3s ease; } /* default, smooth start/end */
.linear { transition: all 0.3s linear; } /* constant speed */
.ease-in { transition: all 0.3s ease-in; } /* slow start */
.ease-out { transition: all 0.3s ease-out; } /* slow end (feels responsive) */
.ease-in-out { transition: all 0.3s ease-in-out; }/* slow both ends */
/* cubic-bezier: custom curve (P1x P1y P2x P2y) */
.custom { transition: all 0.3s cubic-bezier(0.68, -0.55, 0.27, 1.55); } /* overshoot */
/* steps: jump in increments */
.steps { transition: all 0.3s steps(4, end); }Transitions multiples et décalées
Des propriétés différentes peuvent avoir durées et délais différents — utile pour des effets chorégraphiés où une propriété finit avant que l'autre démarre. transition-delay crée des entrées décalées pour les listes ; combinez avec nth-child pour retarder chaque item progressivement. Les délais marchent aussi pour les sorties, mais attention : si l'utilisateur quitte le survol en plein délai, l'entrée peut se coller brusquement.
.card {
/* different durations per property */
transition: transform 0.2s ease-out, box-shadow 0.4s ease;
/* delay creates staggered effect */
transition: background 0.3s, color 0.3s 0.1s; /* color starts after 0.1s */
}
.card:hover {
transform: translateY(-4px);
box-shadow: 0 10px 30px rgba(0,0,0,0.2);
background: #f5f5f5;
}
/* stagger multiple elements via transition-delay */
.item:nth-child(1) { transition-delay: 0s; }
.item:nth-child(2) { transition-delay: 0.1s; }
.item:nth-child(3) { transition-delay: 0.2s; }Propriétés transitionnables
Certaines propriétés transitent en douceur ; d'autres causent des à-coups. Les vedettes accélérées GPU sont transform, opacity et filter. Les couleurs et box-shadow conviennent (elles déclenchent la peinture, pas la mise en page). Évitez de faire transiter width, height, margin, top, left — ils forcent un recalcul de mise en page à chaque frame. Pour animer un changement de taille, employez plutôt transform: scale().
/* WELL-SUPPORTED & performant */
.good {
transition: transform 0.3s, opacity 0.3s, filter 0.3s;
}
/* OK but may trigger paint */
.okay {
transition: background-color 0.3s, color 0.3s, border-color 0.3s;
transition: box-shadow 0.3s;
}
/* AVOID: triggers layout (reflow) - janky */
.bad {
transition: width 0.3s, height 0.3s, margin 0.3s, top 0.3s, left 0.3s;
}
/* if you must animate size, use transform: scale() instead */
.smooth-resize { transition: transform 0.3s; }Déclencheurs de transition
Les transitions se déclenchent sur tout changement de propriété : états de pseudo-classes (:hover, :focus, :checked), changements de classes (ajoutées/retirées par JS) et changements de media queries. Elles interpolent en douceur entre anciennes et nouvelles valeurs. Les transitions ne tournent qu'à l'approche du nouvel état — les deux sens (entrée/sortie) s'animent. Pour un mouvement plus complexe, en boucle ou multi-étapes, employez les animations @keyframes.
/* hover trigger */
.btn { transition: all 0.3s; }
.btn:hover { transform: scale(1.1); }
/* focus trigger (accessibility-friendly) */
.input { transition: border-color 0.2s; }
.input:focus { border-color: blue; }
/* class change via JavaScript */
.modal { transition: opacity 0.3s; opacity: 0; }
.modal.open { opacity: 1; }
/* media query trigger */
.box { transition: width 0.3s; width: 100%; }
@media (min-width: 768px) { .box { width: 50%; } }
/* CSS state triggers (:checked) */
.toggle:checked + .menu { transition: max-height 0.3s; max-height: 500px; }Animations
@keyframes
@keyframes définit la séquence d'une animation. Les arrêts peuvent être des pourcentages (0%, 50%, 100%) ou from/to (équivalents à 0%/100%). Les propriétés absentes d'un arrêt interpolent entre les arrêts définis. Seules les propriétés animables (transform, opacity, couleurs) marchent — display, position, etc. non. Définissez @keyframes une fois et réutilisez sur beaucoup d'éléments.
@keyframes bounce {
0% { transform: translateY(0); }
50% { transform: translateY(-30px); }
100% { transform: translateY(0); }
}
/* from/to shorthand (2-stop) */
@keyframes fadeIn {
from { opacity: 0; }
to { opacity: 1; }
}
/* multiple properties at each stop */
@keyframes pulse {
0% { opacity: 1; transform: scale(1); }
50% { opacity: 0.5; transform: scale(1.1); }
100% { opacity: 1; transform: scale(1); }
}Raccourci animation
Le raccourci animation entasse 8 propriétés dans cet ordre : nom durée fonction-de-timing délai nombre-d'itérations direction fill-mode play-state. Au minimum, il faut nom et durée. Note : une valeur de temps sans unité est ambiguë — le premier temps est la durée, le second le délai. Pour la lisibilité en production, préférez les formes longues ou un raccourci partiel.
.bouncing {
/* longhand */
animation-name: bounce;
animation-duration: 1s;
animation-timing-function: ease-in-out;
animation-delay: 0s;
animation-iteration-count: infinite;
animation-direction: alternate;
animation-fill-mode: both;
animation-play-state: running;
/* shorthand: name duration timing delay count direction fill-mode play-state */
animation: bounce 1s ease-in-out 0s infinite alternate both running;
/* minimal: name + duration */
animation: bounce 1s;
}Itération et direction
animation-iteration-count contrôle la répétition — infinite boucle sans fin, les valeurs fractionnaires jouent des cycles partiels. animation-direction: alternate joue l'animation en avant puis en arrière à l'itération suivante, créant un rebond sans couture. reverse joue en arrière, et alternate-reverse démarre en arrière. Alternate est essentiel pour les mouvements de ping-pong comme les effets de pulsation ou de respiration.
/* iteration-count: how many times to play */
.once { animation-iteration-count: 1; } /* default */
.thrice { animation-iteration-count: 3; }
.forever { animation-iteration-count: infinite; }
.fractional { animation-iteration-count: 0.5; } /* half a play */
/* direction */
.normal { animation-direction: normal; } /* 0% -> 100% */
.reverse { animation-direction: reverse; } /* 100% -> 0% */
.alternate { animation-direction: alternate; } /* forward, then backward */
.alternate-rev { animation-direction: alternate-reverse; }Fill mode d'animation
animation-fill-mode contrôle les styles avant et après l'animation. none (défaut) revient aux styles normaux de l'élément. forwards retient l'état final du keyframe après la fin — essentiel pour les animations d'entrée pour que les éléments ne se re-collent pas. backwards applique le premier keyframe pendant le délai. both couvre les deux cas. Employez forwards ou both pour des entrées ponctuelles.
@keyframes slideIn {
from { transform: translateX(-100%); }
to { transform: translateX(0); }
}
/* none (default): reverts to original styles before/after */
.none { animation: slideIn 1s; }
/* forwards: holds the final (to) state after finishing */
.forwards { animation: slideIn 1s forwards; }
/* backwards: applies the (from) state during delay */
.backwards { animation: slideIn 1s 0.5s backwards; }
/* both: applies from during delay AND holds to after */
.both { animation: slideIn 1s 0.5s both; }Play state et pause
animation-play-state: paused gèle une animation à sa frame courante ; running la reprend. C'est la façon la plus propre de mettre en pause au survol ou via une classe basculée en JS — l'animation se souvient de sa position au lieu de redémarrer. Pour la performance, mettez en pause les animations des éléments qui sortent de la vue avec IntersectionObserver. Combinez avec les media queries reduced-motion pour l'accessibilité.
.anim { animation: spin 2s linear infinite; }
/* pause on hover */
.anim:hover { animation-play-state: paused; }
/* pause via class (JS toggle) */
.anim.paused { animation-play-state: paused; }
/* useful for performance: pause off-screen animations */
.offscreen { animation-play-state: paused; }
/* resume */
.resumed { animation-play-state: running; }Media queries
Syntaxe de base
Les media queries appliquent des styles conditionnellement. (min-width: 768px) est mobile-first — s'applique aux écrans de 768px et plus. Combinez avec and (les deux doivent matcher), les virgules (OU) et not (nier). L'approche mobile-first (min-width) est préférée : écrivez les styles de base pour petits écrans, puis améliorez pour les plus grands. Cela garde le CSS mobile léger.
/* apply styles when viewport is at least 768px wide */
@media (min-width: 768px) {
.grid { grid-template-columns: repeat(2, 1fr); }
}
/* combine conditions with and */
@media (min-width: 768px) and (max-width: 1024px) {
.box { padding: 20px; }
}
/* list of queries (OR) */
@media (max-width: 600px), (min-width: 1200px) {
.text { font-size: 14px; }
}
/* negate with not */
@media not print {
.screen-only { display: block; }
}Breakpoints min/max width
Les breakpoints devraient reposer sur le contenu, pas sur des appareils précis, mais les plages courantes marchent bien : 640px (tablette), 1024px (desktop), 1280px (grand). Mobile-first signifie employer min-width et écrire les styles mobiles comme base. La syntaxe de plage plus récente (width >= 768px) est plus lisible et gérée par tous les navigateurs modernes, remplaçant les combinaisons min/max verbeuses.
/* common breakpoints (mobile-first) */
/* base styles (mobile) */
.container { padding: 16px; }
@media (min-width: 640px) { /* small tablets */
.container { padding: 24px; }
}
@media (min-width: 1024px) { /* desktops */
.container { padding: 32px; max-width: 1200px; margin: 0 auto; }
}
@media (min-width: 1280px) { /* large screens */
.container { max-width: 1400px; }
}
/* range syntax (newer, cleaner) */
@media (width >= 768px) and (width <= 1024px) {
.box { padding: 20px; }
}Orientation et aspect ratio
Au-delà de la largeur, les media queries peuvent viser l'orientation (portrait/landscape), l'aspect-ratio, la capacité hover et le type de pointeur. @media (hover: hover) garantit que les styles de survol ne s'appliquent qu'aux appareils à vrai pointeur (évitant le survol collant au tactile). (pointer: coarse) vise les appareils tactiles — parfait pour agrandir les cibles de tap. Ces fonctionnalités permettent des interfaces vraiment adaptées à l'appareil.
/* portrait vs landscape */
@media (orientation: portrait) {
.grid { grid-template-columns: 1fr; }
}
@media (orientation: landscape) {
.grid { grid-template-columns: 1fr 1fr; }
}
/* aspect ratio */
@media (min-aspect-ratio: 16/9) {
.video { width: 100%; height: auto; }
}
/* hover capability: devices that support hover */
@media (hover: hover) {
.btn:hover { background: darkblue; }
}
/* pointer: fine (mouse) vs coarse (touch) */
@media (pointer: coarse) {
.btn { padding: 16px 32px; } /* bigger tap targets */
}Styles d'impression
Les media queries print stylent l'apparence des pages à l'impression. Masquez navigation, pubs et éléments interactifs ; étendez le contenu à pleine largeur ; forcez le noir sur blanc pour économiser l'encre. break-inside: avoid empêche les éléments de se scinder entre pages, et break-before: page force des sauts de page. L'astuce ::after sur les liens révèle les URLs à l'impression — inestimable pour les articles imprimables.
@media print {
/* hide non-essential UI */
.nav, .sidebar, .ads, .comments { display: none; }
/* expand main content */
.main { width: 100%; margin: 0; }
/* force black text on white */
body { color: black; background: white; }
/* avoid breaking inside elements */
h1, h2, img, table { break-inside: avoid; }
/* page breaks before sections */
h1 { break-before: page; }
/* show URLs after links */
a[href]::after { content: " (" attr(href) ")"; }
}prefers-reduced-motion et color-scheme
prefers-reduced-motion est une fonctionnalité d'accessibilité critique — les utilisateurs de troubles vestibulaires ont besoin de mouvement minimal. Fournissez toujours un repli reduced-motion qui désactive ou raccourcit les animations. prefers-color-scheme permet de s'adapter automatiquement au thème OS de l'utilisateur. Pour le mode sombre, pensez aussi au contraste, aux images et aux ombres qui fonctionnent sur fond sombre.
/* respect users who prefer less motion */
@media (prefers-reduced-motion: reduce) {
*, *::before, *::after {
animation-duration: 0.01ms !important;
animation-iteration-count: 1 !important;
transition-duration: 0.01ms !important;
scroll-behavior: auto !important;
}
}
/* light/dark mode */
@media (prefers-color-scheme: dark) {
body { background: #1a1a1a; color: #eee; }
.card { background: #2a2a2a; }
}
@media (prefers-color-scheme: light) {
body { background: white; color: #333; }
}Design responsif
Typographie fluide avec clamp()
clamp(min, préféré, max) crée des valeurs qui montent en fluide entre bornes — parfait pour une typographie et un espacement qui s'adaptent sans media queries. La valeur préférée est généralement une expression basée vw. Cela élimine beaucoup de breakpoints. Associez rem pour l'accessibilité (les utilisateurs peuvent toujours redimensionner la taille de police racine). La typographie fluide améliore la performance perçue et la lisibilité sur tous les appareils.
/* clamp(min, preferred, max) - fluid between bounds */
h1 {
/* scales from 1.5rem to 3rem as viewport grows */
font-size: clamp(1.5rem, 5vw, 3rem);
}
p {
/* readable body text on any screen */
font-size: clamp(1rem, 2.5vw, 1.25rem);
}
/* fluid spacing */
.section {
padding: clamp(1rem, 4vw, 3rem);
}
/* fluid container width */
.container {
width: clamp(280px, 90vw, 1200px);
margin: 0 auto;
}Approche mobile-first
Mobile-first signifie écrire les styles petits écrans comme base, puis employer des media queries min-width pour améliorer vers les grands écrans. Cela produit un CSS plus l éger (le mobile ne télécharge que le nécessaire) et force un état d'esprit priorisant le contenu. Desktop-first (max-width) force les appareils mobiles à télécharger puis surcharger les styles desktop — plus lent et plus dur à maintenir.
/* base = mobile styles (no media query) */
.card {
width: 100%;
padding: 12px;
font-size: 14px;
}
/* progressively enhance for larger screens */
@media (min-width: 640px) {
.card { width: 50%; padding: 16px; }
}
@media (min-width: 1024px) {
.card { width: 33.33%; padding: 24px; font-size: 16px; }
}
/* AVOID desktop-first (forces mobile to override) */
/* @media (max-width: 640px) { ... } */Container queries
Les container queries changent la donne : elles laissent les composants réagir à la taille de leur parent plutôt qu'à la fenêtre. Une carte peut adapter sa disposition qu'elle soit dans une barre latérale étroite ou une zone principale large — un vrai responsif au niveau composant. container-type: inline-size interroge la largeur (le plus performant). Nommez les conteneurs pour les viser précisément, ou employez des requêtes sans nom pour l'ancêtre le plus proche.
/* make an element a query container */
.sidebar {
container-type: inline-size;
container-name: sidebar;
}
/* styles based on the container's size, not the viewport */
@container sidebar (min-width: 400px) {
.card {
grid-template-columns: 1fr 1fr;
}
}
/* inline-size = width only (most common, performant) */
/* size = both dimensions (more expensive) */
/* unnamed container query (uses nearest ancestor) */
.card-wrap { container-type: inline-size; }
@container (min-width: 500px) {
.card { flex-direction: row; }
}Unités de viewport
vh/vw sont des pourcentages de la fenêtre d'affichage. Le problème : 100vh sur mobile change à mesure que la barre d'adresse apparaît/disparaît, causant des à-coups. Les unités plus récentes svh/lvh/dvh corrigent cela — dvh se met à jour dynamiquement, svh emploie la plus petite valeur stable. vmin/vmax sont la dimension de viewport la plus petite/grande — parfait pour des éléments carrés qui s'adaptent. Associez toujours les tailles de police en vw à un plancher rem/px via calc ou clamp.
.hero {
height: 100vh; /* full viewport height */
/* small viewport units: account for mobile browser chrome */
height: 100svh; /* smallest possible viewport (stable) */
height: 100lvh; /* largest possible viewport */
height: 100dvh; /* dynamic - updates as chrome shows/hides */
}
.full-width { width: 100vw; }
.responsive-font { font-size: 5vw; }
/* vmin/vmax: smaller/larger of width or height */
.square { width: 50vmin; height: 50vmin; }
.banner { height: 30vmax; }
/* combining with calc for safety */
.hero-text { font-size: calc(16px + 2vw); }aspect-ratio
aspect-ratio maintient automatiquement un ratio largeur:hauteur — finis les hacks padding-top pour la vidéo responsif. La hauteur de l'élément se dérive de sa largeur (ou inversement). Combiné à object-fit: cover sur les images, cela prévient le décalage de mise en page au chargement des images. C'est la façon la plus propre de réserver de l'espace aux médias et d'éviter le Cumulative Layout Shift (CLS) — un Core Web Vital.
/* maintain a 16:9 ratio regardless of width */
.video {
aspect-ratio: 16 / 9;
width: 100%;
}
/* square avatar */
.avatar {
aspect-ratio: 1;
width: 80px;
border-radius: 50%;
}
/* golden ratio card */
.card {
aspect-ratio: 1.618;
}
/* combined with object-fit for responsive images */
.thumb {
aspect-ratio: 4 / 3;
width: 100%;
object-fit: cover;
}Propriétés personnalisées (variables)
Définir et employer des variables
Les propriétés personnalisées CSS (variables) se déclarent avec --name et s'emploient avec var(--name). Définissez-les sur :root pour un accès global, ou bornez-les à tout élément. Contrairement aux variables de préprocesseur, elles sont vivantes : changer une variable met à jour tous ses usages en temps réel, et elles se cascaded et héritent. var() accepte un repli en second argument, employé quand la variable est indéfinie.
:root {
--primary: #3490dc;
--spacing: 16px;
--max-width: 1200px;
}
.button {
background: var(--primary);
padding: var(--spacing);
/* with fallback value (used if --primary undefined) */
color: var(--text-color, #333);
}
/* override in a specific scope */
.dark-theme {
--primary: #5a9fee;
}Thèmes et mode sombre
Les propriétés personnalisées rendent le theming trivial : définissez des variables sémantiques (--bg, --text, --primary), puis surchargez-les dans un sélecteur [data-theme]. Basculer l'attribut data-theme sur <html> échange instantanément tout le thème — sans feuilles de style dupliquées. Combinez avec prefers-color-scheme pour un mode sombre automatique qui respecte la surcharge manuelle de l'utilisateur. C'est la façon moderne et performante de thèmer.
:root {
--bg: #ffffff;
--text: #1a1a1a;
--primary: #3490dc;
}
[data-theme="dark"] {
--bg: #1a1a1a;
--text: #ffffff;
--primary: #5a9fee;
}
body {
background: var(--bg);
color: var(--text);
}
/* auto dark mode via media query */
@media (prefers-color-scheme: dark) {
:root:not([data-theme="light"]) {
--bg: #1a1a1a;
--text: #ffffff;
}
}Cascade et héritage
Les propriétés personnalisées se cascaded et héritent comme le CSS normal. Une variable définie sur .card est disponible pour .card et tous ses descendants — mais pas pour ses frères. Chaque élément lit la valeur calculée de la variable dans sa propre portée. @property (plus récent) permet de déclarer des variables typées avec syntaxe, valeur initiale et flag d'héritage — activant des transitions et animations fluides des propriétés personnalisées.
:root { --color: blue; } /* global */
.card { --color: green; } /* scoped to .card */
.card .inner { color: var(--color); } /* green - inherits from .card */
/* variables inherit like other properties */
.parent { --size: 20px; }
.child { font-size: var(--size); } /* 20px via inheritance */
/* but: each element reads its own computed value */
.a { --x: 10px; }
.b { /* --x is NOT defined here, even if .a is sibling */ }
/* @property: typed variables with initial value */
@property --angle {
syntax: "<angle>";
inherits: false;
initial-value: 0deg;
}Interaction avec JavaScript
Les variables CSS sont entièrement accessibles depuis JavaScript. Lisez avec getComputedStyle(el).getPropertyValue('--name') (renvoie une chaîne, souvent avec un espace initial — trimmez-le). Réglez avec el.style.setProperty('--name', value). Cela fait des propriétés personnalisées un pont puissant JS-vers-CSS : changez une variable en JS et le CSS réagit instantanément — parfait pour les effets pilotés par le scroll, le theming et les mises en page dynamiques.
/* read a variable */
const styles = getComputedStyle(document.documentElement);
const primary = styles.getPropertyValue("--primary"); /* "#3490dc" */
/* set a variable globally */
document.documentElement.style.setProperty("--primary", "#ff0000");
/* set on a specific element */
el.style.setProperty("--spacing", "24px");
/* inline style with variable */
<div style="--rotate: 45deg"></div>
/* useful pattern: expose JS values to CSS */
.root { --scroll: 0; }
.box { transform: rotate(calc(var(--scroll) * 1deg)); }Replis et chaînage
var() accepte un repli en second argument, employé seulement quand la variable est indéfinie (pas quand elle est invalide — une valeur invalide fait retomber toute la propriété à son défaut). Les replis peuvent se chaîner : var(--a, var(--b, #default)). Utile pour l'amélioration progressive et l'intégration de composants tiers. Employez @supports (--x: 0) pour détecter le support, bien que tous les navigateurs modernes gèrent les propriétés personnalisées.
.box {
/* single fallback */
color: var(--undefined, #333);
/* chained: try --primary, fall back to --blue, then #00f */
color: var(--primary, var(--blue, #0000ff));
/* fallback in calc() */
width: calc(100% - var(--sidebar, 250px));
/* invalid values fall back to inherited/default */
/* var() itself doesn't fail — the property does */
}
/* feature detection for custom property support */
@supports (--custom: property) {
:root { --modern: true; }
}Filtres
Fonctions de filtre
filter applique des effets visuels à un élément. brightness/contrast/saturate prennent des multiplicateurs (1 = normal) ou pourcentages. hue-rotate décale toutes les teintes d'un angle. Plusieurs filtres se chaînent de gauche à droite. Usages courants : images en niveaux de gris au survol, effets photo vintage, ou fonds estompés. Les filtres touchent l'élément, son fond, ses bordures et ses enfants.
.blur { filter: blur(4px); } /* gaussian blur in px */
.bright { filter: brightness(1.5); } /* 1 = normal, >1 brighter */
.contrast { filter: contrast(200%); } /* 100% = normal */
.gray { filter: grayscale(100%); } /* 0-100% */
.sepia { filter: sepia(80%); }
.hue { filter: hue-rotate(90deg); } /* rotate hue */
.invert { filter: invert(100%); } /* invert colors */
.saturate { filter: saturate(2); } /* 1 = normal */
.opacity { filter: opacity(50%); }
/* combine multiple filters (left-to-right) */
.vintage { filter: sepia(60%) contrast(110%) brightness(90%) saturate(1.2); }drop-shadow
drop-shadow est l'équivalent filtre de box-shadow — mais il suit la forme alpha réelle de l'élément, pas sa boîte. Les ombres épousent donc les découpes PNG/SVG et les formes irrégulières. Employez-le pour les ombres d'icônes, logos lumineux ou tout élément non rectangulaire. Plusieurs drop-shadows peuvent se superposer. Note : il peut être plus coûteux que box-shadow, employez-le à bon escient.
/* drop-shadow follows the alpha shape (unlike box-shadow) */
.cutout {
filter: drop-shadow(4px 4px 8px rgba(0,0,0,0.4));
}
/* shadows on PNG with transparency - hugs the shape */
.logo {
filter: drop-shadow(0 4px 6px rgba(0,0,0,0.3));
}
/* glow effect on text or SVG */
.icon {
filter: drop-shadow(0 0 8px rgba(0, 150, 255, 0.8));
}
/* multiple drop-shadows layer */
.deep {
filter: drop-shadow(0 1px 1px rgba(0,0,0,0.5))
drop-shadow(0 2px 4px rgba(0,0,0,0.3));
}backdrop-filter
backdrop-filter applique un filtre à tout ce qui est derrière un élément — la signature du glassmorphism. Un fond semi-transparent plus backdrop-filter: blur() crée le look verre dépoli. Incluez toujours le préfixe -webkit- pour Safari. L'élément doit présenter une certaine transparence dans son fond pour que l'effet se voie. Combinez avec saturate() pour des résultats vibrants, et ajoutez une bordure subtile pour simuler la réflexion du bord.
/* frosted glass effect */
.glass {
background: rgba(255, 255, 255, 0.2);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px); /* Safari */
border: 1px solid rgba(255, 255, 255, 0.3);
}
/* saturate + blur for vivid glass */
.vivid-glass {
backdrop-filter: blur(16px) saturate(180%);
}
/* dark glass for dark mode */
.dark-glass {
background: rgba(0, 0, 0, 0.3);
backdrop-filter: blur(12px);
}Combiner les filtres
Plusieurs filtres s'appliquent de gauche à droite, l'ordre affecte donc le résultat (grayscale avant hue-rotate n'a rien à tourner, par exemple). Les filtres sont animables et accélérés GPU — parfaits pour les effets de survol. Associez filter à mix-blend-mode pour fondre un élément avec son fond. Pour un contrôle dynamique, stockez la chaîne de filtres dans une propriété personnalisée et mettez-la à jour via JS.
/* order matters: each filter feeds the next */
.artsy {
filter: grayscale(100%) contrast(150%) brightness(110%);
}
/* animate filters smoothly */
img { transition: filter 0.3s; }
img:hover { filter: grayscale(0%) saturate(1.4); }
/* use CSS variables for dynamic filters */
.dynamic { filter: var(--photo-filter, none); }
/* layer with other effects */
.complex {
filter: blur(1px) brightness(1.1);
mix-blend-mode: multiply;
opacity: 0.9;
}Performance des filtres
Les filtres sont accélérés GPU mais pas gratuits. De grands flous sur des éléments plein écran causent de lourdes repeintures et des à-coups, surtout sur mobile. Gardez des rayons de flou petits, limitez la zone filtrée, et appliquez will-change: filter avant de déclencher les animations. backdrop-filter est particulièrement coûteux — employez-le sur de petits éléments d'UI, pas des sections entières. contain: paint isole la zone de repeinture pour de meilleures performances.
/* AVOID: large blur on full-screen elements */
.janky { filter: blur(20px); } /* causes repaints */
/* BETTER: pre-blurred image, or limit blur area */
.smooth {
filter: blur(2px); /* small radius is cheaper */
}
/* backdrop-filter is expensive - use sparingly */
/* contain: paint can limit repaint area */
.contained {
contain: paint;
backdrop-filter: blur(10px);
}
/* will-change prepares the GPU layer */
.prepared {
will-change: filter;
filter: blur(4px);
}Pseudo-éléments
::before et ::after
::before et ::after insèrent du contenu généré avant/après le contenu réel d'un élément. La propriété content est requise (même chaîne vide pour les éléments décoratifs). Le contenu peut être du texte, de l'Unicode échappé ou des valeurs d'attribut via attr(). Ces pseudo-éléments sont inline par défaut — réglez display: block pour une décoration en boîte. Parfaits pour icônes, lignes décoratives, citations et nettoyage des floats.
.quote::before { content: "\201C"; } /* opening quote */
.quote::after { content: "\201D"; } /* closing quote */
/* icon via Unicode */
.warning::before { content: "\26A0"; margin-right: 6px; }
/* decorative element with content: "" */
.card::after {
content: "";
display: block;
width: 50px; height: 2px;
background: currentColor;
margin-top: 12px;
}
/* content can use attributes */
a[href^="http"]::after {
content: " (" attr(href) ")";
font-size: 0.8em;
}::first-letter et ::first-line
::first-letter style le premier caractère — parfait pour les lettrines d'articles. ::first-line style la première ligne formatée, qui s'ajuste dynamiquement à mesure que la largeur de la fenêtre change. Les deux ne fonctionnent que sur les éléments de niveau bloc. Notez que ::first-letter ne s'applique que si le premier caractère n'est pas précédé d'autre contenu (comme des images). Essentiels typographiques pour les mises en page éditoriales.
article p::first-letter {
font-size: 3em;
font-weight: bold;
float: left;
line-height: 0.8;
margin-right: 8px;
/* drop cap effect */
}
article p::first-line {
text-transform: uppercase;
letter-spacing: 1px;
font-weight: bold;
}
/* only works on block-level elements */
/* affects the first formatted line (reflows with width) */::selection
::selection style la portion de texte que l'utilisateur surligne. Seules quelques propriétés s'appliquent : color, background-color, text-shadow et text-decoration. Employez-le pour marquer la couleur de sélection à l'image de votre site. Appliquez-le globalement avec ::selection ou bornez-le à des éléments précis. Les vieux Firefox exigeaient ::-moz-selection, mais le Firefox moderne gère le ::selection standard.
/* style highlighted/selected text */
::selection {
background: #b3d4fc;
color: black;
text-shadow: none;
}
/* scoped to specific elements */
p::selection { background: yellow; }
.highlight::selection { background: gold; color: #333; }
/* note: only a few properties work:
color, background-color, text-shadow,
text-decoration (and its longhands) */
/* firefox historically used ::-moz-selection */::placeholder et ::marker
::placeholder style le texte d'invite des inputs de formulaire — réglez opacity: 1 car Firefox affiche par défaut une invite translucide. ::marker style les puces ou numéros des items de liste, avec un ensemble limité de propriétés (color, content, font, direction). On peut remplacer les puces par du contenu personnalisé (Unicode, compteurs). Ces pseudo-éléments mettent le style des formulaires et listes entièrement sous contrôle du designer.
/* style input placeholder text */
input::placeholder {
color: #999;
font-style: italic;
opacity: 1; /* Firefox applies opacity < 1 by default */
}
/* style list item markers (bullets/numbers) */
ul li::marker {
color: red;
font-size: 1.2em;
content: "\25CF"; /* custom bullet */
}
ol li::marker {
content: counter(list-item) ". ";
color: blue;
font-weight: bold;
}
/* ::marker supports: color, content, font properties,
direction, unicode-bidi, text-transform, white-space */Contenu généré et compteurs
Le contenu généré via ::before/::after peut inclure des valeurs counter(), des valeurs d'attribut (attr()) ou des littéraux de chaîne — permettant numérotation, icônes et tooltips en CSS seul, sans DOM supplémentaire. counters() produit une numérotation imbriquée comme « 1.2.3 ». Les tooltips construits avec attr(data-tooltip) et une transition de survol sont une alternative légère aux bibliothèques JS. Rappelez-vous : le contenu généré n'est pas dans le DOM et n'est pas lu par certains lecteurs d'écran — n'y placez pas de contenu critique.
/* counter in generated content */
h2::before {
content: "Section " counter(section) ": ";
color: gray;
}
/* attr() reads HTML attributes */
a::after {
content: attr(data-icon);
}
/* counters() for nested numbering */
ol { counter-reset: item; }
li { display: block; }
li::before {
content: counters(item, ".") " ";
counter-increment: item;
}
/* CSS-only tooltip */
.tooltip::after {
content: attr(data-tooltip);
position: absolute;
background: black; color: white;
padding: 4px 8px;
opacity: 0; transition: opacity 0.2s;
}
.tooltip:hover::after { opacity: 1; }Compteurs
counter-reset et counter-increment
Les compteurs CSS permettent de numéroter des éléments sans JavaScript. counter-reset initialise un compteur (défaut 0, mais on peut démarrer ailleurs). counter-increment l'augmente (défaut de 1, mais tout entier fonctionne — même négatif). Affichez la valeur avec counter() dans content. Les compteurs se bornent à l'élément où ils sont réinitialisés et à ses descendants, permettant une numérotation imbriquée.
body { counter-reset: section; } /* initialize to 0 */
h2 {
counter-increment: section; /* +1 each h2 */
}
h2::before {
content: "Section " counter(section) ": ";
}
/* custom increment value */
ol { counter-reset: item; }
li { counter-increment: item 1; } /* +1 (default) */
li.big { counter-increment: item 2; } /* +2 */
/* reset to a custom starting value */
.start-5 { counter-reset: item 4; } /* next increment = 5 */Fonction counter()
counter(name) sort la valeur courante d'un compteur, et counter(name, style) applique un style de liste : decimal (défaut), lower/upper-alpha, lower/upper-roman, disc, square, etc. On peut faire tourner plusieurs compteurs en parallèle et les combiner dans content — parfait pour des figures numérotées par chapitre (Figure 3-2). Les valeurs de compteurs se calculent au rendu, elles se mettent donc à jour automatiquement quand le DOM change.
body { counter-reset: section; }
h2 { counter-increment: section; }
h2::before {
content: "Chapter " counter(section) ". ";
color: navy;
}
/* counter style (decimal, lower-alpha, upper-roman, etc.) */
h2::before {
content: counter(section, upper-roman) ". ";
}
/* multiple counters */
body { counter-reset: section figure; }
h2 { counter-increment: section; }
figcaption { counter-increment: figure; }
figcaption::before {
content: "Figure " counter(section) "-" counter(figure) ": ";
}Compteurs imbriqués avec counters()
counters(name, séparateur) est la fonction de compteurs imbriqués : elle concatène la valeur du compteur à chaque portée d'ancêtre, séparée par la chaîne donnée. Cela produit automatiquement des plans comme « 1.2.3 » — le même nom de compteur se réinitialise à chaque <ol> imbriqué. Sans counters() (pluriel), les listes imbriquées partageraient toutes la même numérotation. Le séparateur peut être toute chaîne, comme '.' ou '-'.
ol { counter-reset: item; list-style: none; }
li::before {
counter-increment: item;
/* counters() concatenates ancestor counters with separator */
content: counters(item, ".") " ";
}
/* produces: 1 / 1.1 / 1.2 / 2 / 2.1 / 2.1.1 ... */
<ol>
<li>Item
<ol>
<li>Sub-item</li>
<li>Sub-item</li>
</ol>
</li>
<li>Item</li>
</ol>
/* custom separator */
li::before { content: counters(item, "-") ": "; }Style des compteurs
Les compteurs gèrent de nombreux styles intégrés : decimal, upper-roman, lower-alpha, lower-greek, cjk-decimal, etc. @counter-style permet de définir des styles personnalisés avec un jeu de symboles, un système (cyclic, additive, extends) et des options comme pad (zéros initiaux), prefix/suffix et range. Parfait pour des listes thémées, des puces emoji ou une numérotation localisée sans JavaScript.
/* built-in styles */
.decimal { content: counter(c, decimal); }
.roman { content: counter(c, upper-roman); } /* I, II, III */
.alpha { content: counter(c, lower-alpha); } /* a, b, c */
.greek { content: counter(c, lower-greek); } /* alpha, beta, gamma */
.cjk { content: counter(c, cjk-decimal); } /* CJK numerals */
/* @counter-style: define a custom style */
@counter-style thumbs {
system: cyclic;
symbols: "\1F44D"; /* thumbs up emoji */
suffix: " ";
}
.like-list { list-style-type: thumbs; }
/* leading zeros via pad */
@counter-style padded {
system: extends decimal;
pad: 3 "0"; /* 001, 002, ... */
}Patterns de compteurs pratiques
Les compteurs brillent pour les indicateurs d'étapes numérotées, sommaires et plans. Stylez le ::before avec un badge circulaire, une couleur et un nombre pour créer des listes d'étapes numérotées sans numérotation manuelle. Éditez le DOM et les nombres se mettent à jour automatiquement. Réserve : les valeurs de compteurs ne se lisent pas facilement en JavaScript — elles ne servent qu'à l'affichage. Pour une logique basée sur les comptes, employez JS ou CSS :nth-child.
/* numbered steps */
.steps { counter-reset: step; }
.steps li { counter-increment: step; }
.steps li::before {
content: counter(step);
display: inline-block;
width: 28px; height: 28px;
border-radius: 50%;
background: var(--primary);
color: white;
text-align: center;
line-height: 28px;
margin-right: 10px;
}
/* "you've completed N sections" via counters (limited -
counters can't be read by JS easily, use them for display) */Mise en page multi-colonnes
column-count et column-width
La mise en page multi-colonnes fait couler le contenu en colonnes façon journal. column-count fixe le nombre ; column-width laisse le navigateur créer autant de colonnes de 250px que possible (responsif sans media queries). Le raccourci columns prend count et/ou width. Le multi-colonnes est idéal pour le texte de lecture longue, mais prudence : un contenu court peut causer des hauteurs de colonnes inégales.
.article {
/* fixed number of columns */
column-count: 3;
/* OR width-based (browser decides count) */
column-width: 250px;
/* shorthand (count width) */
columns: 3 250px;
columns: 3; /* 3 columns */
columns: 250px; /* 250px columns, auto count */
}
/* responsive: width lets columns collapse on small screens */
.fluid { column-width: 200px; } /* 1 column on mobile, more on desktop */column-gap et column-rule
column-gap règle l'espace entre colonnes (aussi employé désormais par flexbox et grid). column-rule trace une ligne de séparation verticale dans l'écart — l'équivalent colonne de border, avec le même raccourci. La ligne ne prend pas de largeur supplémentaire ; elle se place centrée dans l'écart. Employez une couleur subtile pour délimiter les colonnes sans gêner.
.article {
column-count: 3;
column-gap: 30px; /* space between columns */
/* divider line (like border) */
column-rule: 1px solid #ddd; /* shorthand */
column-rule-width: 1px;
column-rule-style: solid;
column-rule-color: #ddd;
}
/* rule sits in the gap, doesn't add width */column-span
column-span: all fait franchir toutes les colonnes à un élément — parfait pour un titre magazine sur toute la largeur avec des colonnes coulant au-dessus et en dessous. column-span: none (défaut) garde le contenu coulant à travers les colonnes. Sachez que cela peut causer un reflow important et a connu un support incohérent ; testez soigneusement. C'est le plus fiable pour des titres entre blocs de colonnes.
.article {
column-count: 3;
}
/* heading spans all columns (like a magazine) */
.article h2 {
column-span: all;
/* resets above the heading, columns resume below */
}
/* default: content flows through columns */
.normal { column-span: none; }
/* note: column-span: all can cause reflow and is
not supported in older Firefox */break-inside et sauts de colonne
Le contenu multi-colonnes peut scinder les éléments entre colonnes de façon maladroite. break-inside: avoid garde un élément (comme une carte ou une figure) intact dans une colonne. break-before/break-after: column force des sauts de colonne. Les anciennes propriétés page-break-* fonctionnent comme alias. Un hack courant était display: inline-block avec width: 100%, mais break-inside: avoid est l'approche moderne correcte.
/* prevent an element from splitting across columns */
.card {
break-inside: avoid; /* modern */
-webkit-column-break-inside: avoid; /* old webkit */
page-break-inside: avoid; /* old */
display: inline-block; /* hack for older browsers */
width: 100%;
}
/* control where columns break */
h2 { break-after: column; } /* force new column after */
h3 { break-before: column; } /* force new column before */
p { break-inside: avoid; } /* keep paragraph together */column-fill et équilibrage
column-fill contrôle la distribution du contenu entre colonnes. balance (défaut) égalise les hauteurs pour que les colonnes se terminent à peu près alignées — visuellement net. auto remplit entièrement la première colonne avant de passer à la suivante, exigeant une hauteur fixe ; cela correspond au comportement d'impression. Les colonnes équilibrées sont plus agréables pour l'usage général ; auto convient mieux quand le contenu doit couler strictement de haut en bas.
.article {
column-count: 3;
/* balance: equalize column heights (default in most browsers) */
column-fill: balance;
/* auto: fill first column fully, then next (needs height) */
column-fill: auto;
height: 500px; /* required for auto */
}
/* balanced columns look neat but can split awkwardly;
auto is more like print, fills top-to-bottom */Interface utilisateur
Outline et accessibilité
Des indicateurs de focus visibles sont une exigence d'accessibilité. :focus-visible ne montre l'outline qu'aux utilisateurs clavier (pas souris), la meilleure pratique du style de focus. Ne réglez jamais outline: none sans remplacement (comme un anneau box-shadow). outline-offset ajoute de l'air entre l'élément et l'outline. Les navigateurs modernes gèrent les outlines arrondis via border-radius affectant la forme de l'outline.
/* visible focus ring for keyboard users */
button:focus-visible {
outline: 2px solid #0066cc;
outline-offset: 2px;
}
/* never outline: none without a replacement */
/* custom focus ring via box-shadow */
button:focus {
outline: none;
box-shadow: 0 0 0 3px rgba(0, 102, 204, 0.5);
}
/* outline shorthand */
.outlined { outline: 2px dashed red; outline-offset: 4px; }
/* thick rounded outline (modern browsers) */
button:focus-visible {
outline: 3px solid blue;
outline-offset: 2px;
border-radius: 4px;
}resize
resize contrôle si l'utilisateur peut redimensionner un élément en glissant. textarea est redimensionnable par défaut ; resize: none le désactive. vertical/horizontal/both contraignent la direction. Pour que resize fonctionne, l'élément doit avoir un overflow autre que visible (réglez overflow: auto ou hidden). Utile pour textareas, éditeurs de code ou tout panneau ajustable par l'utilisateur.
textarea {
/* allow vertical resize only (default for textarea) */
resize: vertical;
/* allow both axes */
resize: both;
/* horizontal only */
resize: horizontal;
/* disable resizing */
.locked { resize: none; }
/* default: inline/block elements can't be resized;
textarea default is both in most browsers */
}
/* note: resize only works on overflow != visible */caret-color et user-select
caret-color règle la couleur du curseur clignotant des éléments éditables — petite mais agréable touche pour des formulaires marqués à votre image. user-select contrôle si le texte peut être sélectionné : none le désactive (pour les contrôles UI), all sélectionne tout l'élément au clic (bien pour les blocs de code ou emails), et contain garde la sélection dans un élément. Évitez user-select: none sur body — cela nuit à l'accessibilité.
/* color of the text cursor in inputs */
input, textarea {
caret-color: #0066cc; /* default: current color */
}
/* custom thick caret (limited support) */
input { caret-color: red; }
/* control text selection by the user */
.no-select { user-select: none; } /* disable selection */
.select-all { user-select: all; } /* select whole element on click */
.select-text { user-select: text; } /* normal text selection */
.select-contain { user-select: contain; } /* selection stays within */
/* email addresses, code blocks often user-select: all */appearance et style des formulaires
appearance: none retire le style natif de l'OS des contrôles de formulaire, permettant de les styler entièrement en CSS — essentiel pour une conception de formulaires cohérente entre navigateurs. Après avoir retiré la flèche native du select, ajoutez une background-image personnalisée. Les checkboxes personnalisées emploient appearance: none plus :checked pour l'état. Préfixez toujours de -webkit-/-moz- pour un support complet. Testez soigneusement entre navigateurs — certains contrôles (date, color) restent difficiles à restyler entièrement.
/* remove native widget styling */
input, select, button {
-webkit-appearance: none;
-moz-appearance: none;
appearance: none;
}
/* custom select arrow (after removing native) */
select {
background-image: url("arrow.svg");
background-repeat: no-repeat;
background-position: right 10px center;
padding-right: 30px;
}
/* style checkbox/radio with appearance: none */
input[type="checkbox"] {
appearance: none;
width: 20px; height: 20px;
border: 2px solid #999;
border-radius: 4px;
}
input[type="checkbox"]:checked {
background: var(--primary);
border-color: var(--primary);
}scroll-behavior et barre de défilement
scroll-behavior: smooth sur <html> fait s'animer les clics de liens d'ancre vers la cible au lieu de sauter — associez prefers-reduced-motion pour désactiver pour les utilisateurs sensibles. Barres de défilement personnalisées : les propriétés standard scrollbar-width/scrollbar-color fonctionnent dans Firefox et Chrome moderne ; les pseudo-éléments ::-webkit-scrollbar donnent un contrôle plus fin en WebKit/Blink. Des barres personnalisées subtiles peaufinent l'UX des zones défilables.
/* smooth scrolling for anchor links */
html { scroll-behavior: smooth; }
/* respect reduced motion */
@media (prefers-reduced-motion: reduce) {
html { scroll-behavior: auto; }
}
/* custom scrollbar (WebKit) */
.scroll-area::-webkit-scrollbar { width: 8px; }
.scroll-area::-webkit-scrollbar-track { background: #f1f1f1; }
.scroll-area::-webkit-scrollbar-thumb { background: #888; border-radius: 4px; }
.scroll-area::-webkit-scrollbar-thumb:hover { background: #555; }
/* standard scrollbar-color (Firefox + spec) */
.scroll-area {
scrollbar-width: thin;
scrollbar-color: #888 #f1f1f1;
}Fonctionnalités avancées et modernes
Scroll Snap
Scroll Snap crée un défilement façon carrousel ou plein écran sans JavaScript. scroll-snap-type: x/y + mandatory/proximity contrôle l'axe et la rigueur. Les enfants avec scroll-snap-align s'accrochent à start/center/end. mandatory force l'accrochage (bien pour des sections plein écran) ; proximity n'accroche que de près (plus doux, pour des galeries d'images). Combinez avec scroll-margin pour décaler les points d'accrochage sous des en-têtes épinglés.
.gallery {
scroll-snap-type: x mandatory; /* snap horizontally, must snap */
overflow-x: auto;
display: flex;
}
.gallery > img {
scroll-snap-align: center; /* start | center | end */
scroll-snap-stop: always; /* can't skip snaps */
flex: 0 0 80%;
}
/* vertical full-page snap */
.pages {
scroll-snap-type: y mandatory;
height: 100vh;
overflow-y: scroll;
}
.page { scroll-snap-align: start; height: 100vh; }
/* proximity: only snaps when close (gentler) */
.soft { scroll-snap-type: y proximity; }object-fit et object-position
object-fit contrôle comment un <img> ou <video> remplit sa boîte — l'équivalent média de background-size. cover remplit la boîte et rogne le débordement ; contain casse tout le média avec possiblement de l'espace vide ; fill étire (déforme). object-position fixe le point focal — utile quand cover rogne des parties importantes d'une image. Cela élimine le besoin de hacks background-image pour les médias responsifs.
/* cover: fill box, crop overflow (like background-size: cover) */
.avatar img {
width: 100px; height: 100px;
object-fit: cover; /* cover | contain | fill | none | scale-down */
object-position: center; /* position the focal point */
border-radius: 50%;
}
/* contain: whole image visible, may letterbox */
.preview img {
width: 300px; height: 200px;
object-fit: contain;
background: #eee;
}
/* object-position shifts the visible area */
.banner img {
width: 100%; height: 300px;
object-fit: cover;
object-position: top; /* show top of image */
}will-change
will-change suggère au navigateur qu'une propriété va bientôt changer, lui permettant de pré-allouer des couches GPU et d'optimiser. Appliquez-le juste avant une animation et retirez-le après — un usage permanent sur beaucoup d'éléments gaspille la mémoire et peut nuire à la performance. Ne listez que les propriétés qui s'animeront réellement (transform, opacity, filter). L'abus déclenche l'effet inverse de celui recherché, employez-le donc avec parcimonie et à dessein.
/* hint that an element will animate transform */
.card { will-change: transform; }
/* remove when not needed (frees GPU memory) */
.card.idle { will-change: auto; }
/* multiple properties */
.complex { will-change: transform, opacity; }
/* AVOID: permanent will-change on many elements */
/* .all { will-change: transform, opacity, top, left; } */ /* bad */
/* apply just before animation, remove after */
.prepare { will-change: transform; }
/* JS: el.classList.add('prepare');
setTimeout(() => el.classList.remove('prepare'), 1000); */contain
contain indique au navigateur qu'un élément est indépendant du reste de la page, activant de majeures optimisations de performance — les changements à l'intérieur d'un élément contenu ne déclenchent pas de recalcul à l'extérieur. layout, paint, style et size sont les types d'isolement. strict (les quatre, size inclus) est le plus fort. Appliquez contain aux widgets répétés, items de liste ou publicités pour limiter le coût de reflow/repeinture. size exige des dimensions explicites.
/* isolate an element's layout/paint/style from the rest */
.widget {
contain: layout paint style; /* or: strict, content */
/* size: the element's size is independent of its children */
contain: size; /* needs explicit dimensions */
}
/* layout: changes inside don't affect outside layout */
/* paint: children don't render outside the box (clipped) */
/* style: counters and quotes are scoped */
/* size: element ignores children for sizing */
/* full isolation */
.isolated { contain: strict; } /* = size layout paint style */
.content-isolated { contain: content; } /* = layout paint style */
/* useful for performance on complex widgets, lists, ads */aspect-ratio et gap universel
aspect-ratio maintient un ratio largeur:hauteur sur tout élément, prévenant le décalage de mise en page au chargement des médias. gap (et ses formes longues row-gap/column-gap) est l'outil d'espacement moderne, fonctionnant en flexbox, grid et multi-colonnes — éliminant les hacks .item + marge + :last-child. Les deux fonctionnalités sont universellement gérées dans les navigateurs modernes et résolvent ensemble deux des plus courants points de douleur CSS : maintenir les ratios des médias et espacer proprement les items.
/* aspect-ratio works on any element */
.video-wrap {
aspect-ratio: 16 / 9;
background: black;
}
/* gap works in flex, grid, and multi-column */
.flex { display: flex; gap: 16px; }
.grid { display: grid; gap: 16px; }
.cols { column-count: 3; column-gap: 16px; }
/* row-gap / column-gap longhands */
.layout {
display: grid;
row-gap: 24px;
column-gap: 16px;
}
/* gap replaced margin-based spacing hacks */
/* (no more .item:last-child { margin-right: 0 }) */Snippets CSS3 associés
Copy-paste ready code for common tasks.
Flexbox Layout
Align and distribute items along one axis with flexbox.
Grid Layout
Build two-dimensional layouts with grid-template-areas.
Animations
Define keyframes and apply reusable animations.
Transitions
Smoothly interpolate properties on state change.
2D & 3D Transforms
Translate, rotate, and scale elements with GPU-friendly transforms.
Media Queries
Apply responsive, print, and preference-based styles.
Custom Properties
Define and reuse CSS variables with live updates.
Pseudo-Classes
Select elements by state and structural position.
Was this helpful?