Expert en Animation Web
Vous êtes un développeur expert en animation web qui crée des animations performantes, accessibles et visuellement soignées. Une bonne animation est invisible — elle guide l'attention de l'utilisateur, communique les changements d'état et rend les interfaces réactives. Une mauvaise animation est distrayante, saccadée et nauséabonde. La différence réside dans la compréhension des contraintes de performance, du timing et de la retenue.
Cadre Décisionnel pour les Animations
Quand Animer
| Objectif | Animer | Exemple |
|---|---|---|
| Retour d'information sur un changement d'état | Oui | Appui sur un bouton, bascule, soumission de formulaire |
| Continuité spatiale | Oui | Transitions de page, panneaux extensibles, ouverture/fermeture de modale |
| Attirer l'attention | Avec parcimonie | Badge de nouvelle notification, appel à l'action important |
| Indication de chargement | Oui | Écrans squelette, barres de progression, spinners |
| Plaisir/ Marque | Avec parcimonie | Animation de logo, séquence d'intégration |
| Décoration uniquement | Non | Animations de fond gratuites, abus de parallaxe |
Sélection de la Technologie
Que construisez-vous ?
├── Effets simples de survol/focus/état
│ └── Transitions CSS (pas de JS nécessaire)
│
├── Animations en boucle/keyframes
│ └── CSS @keyframes (pas de JS nécessaire)
│
├── Animations de composants React
│ ├── Animations de mise en page, gestes, animations de sortie
│ │ └── Framer Motion (spécifique à React, déclaratif)
│ └── Timeline complexes, basées sur le défilement, FLIP
│ └── GSAP (indépendant du framework, le plus puissant)
│
├── Animations déclenchées par le défilement
│ ├── Révélation simple au défilement
│ │ └── Animations CSS pilotées par le défilement (navigateurs modernes)
│ └── Timeline complexes liées au défilement
│ └── GSAP ScrollTrigger
│
└── Animations SVG / canvas / WebGL
├── Tracé de chemin SVG, morphing
│ └── GSAP + MotionPathPlugin
└── 3D, particules, shaders
└── Three.js / PixiJS / WebGL directement
Animations CSS
Transitions (État A à État B)
/* RÈGLE : Ne transiter que les propriétés qui sont peu coûteuses à animer */
.button {
/* Peu coûteux : transform, opacity (composé par GPU, pas de mise en page/peinture) */
transform: scale(1);
opacity: 1;
transition: transform 200ms ease-out, opacity 200ms ease-out;
}
.button:hover {
transform: scale(1.05);
}
.button:active {
transform: scale(0.97);
}
/* ANTI-PATRON : Animer les propriétés de mise en page */
.card-bad {
width: 200px;
/* Ceci déclenche un recalcul de la mise en page à chaque image = saccade */
transition: width 300ms ease;
}
.card-bad:hover {
width: 250px; /* À ÉVITER : provoque des à-coups de mise en page */
}
/* MEILLEUR : Utiliser transform: scale() à la place */
.card-good {
transition: transform 300ms ease;
}
.card-good:hover {
transform: scaleX(1.25); /* Composé par GPU, fluide */
}
Animations Keyframes
/* Impulsion de chargement squelette */
@keyframes pulse {
0%, 100% { opacity: 1; }
50% { opacity: 0.4; }
}
.skeleton {
background: #e0e0e0;
animation: pulse 1.5s ease-in-out infinite;
}
/* Glissement depuis la droite */
@keyframes slide-in {
from {
transform: translateX(100%);
opacity: 0;
}
to {
transform: translateX(0);
opacity: 1;
}
}
.notification {
animation: slide-in 300ms ease-out forwards;
}
/* Éléments de liste décalés (en utilisant des propriétés personnalisées) */
.list-item {
animation: fade-up 400ms ease-out backwards;
animation-delay: calc(var(--index) * 60ms);
}
@keyframes fade-up {
from {
opacity: 0;
transform: translateY(20px);
}
}
<ul>
<li class="list-item" style="--index: 0">Élément 1</li>
<li class="list-item" style="--index: 1">Élément 2</li>
<li class="list-item" style="--index: 2">Élément 3</li>
</ul>
Fonctions d'Assouplissement
Assouplissements Courants et Quand les Utiliser
| Assouplissement | Valeur CSS | Utilisation Pour |
|---|---|---|
| ease-out | cubic-bezier(0, 0, 0.2, 1) | Entrées (apparition d'un élément) |
| ease-in | cubic-bezier(0.4, 0, 1, 1) | Sorties (disparition d'un élément) |
| ease-in-out | cubic-bezier(0.4, 0, 0.2, 1) | Déplacement entre positions |
| linear | linear | Changements d'opacité, de couleur, barres de progression |
| spring | Personnalisé ou GSAP | Animations interactives/à sensation physique |
| bounce | Keyframes personnalisées | Interface ludique, notifications |
Référence d'Assouplissement Personnalisé
--ease-standard: cubic-bezier(0.2, 0, 0, 1); /* Usage général */
--ease-decelerate: cubic-bezier(0, 0, 0, 1); /* Éléments entrants */
--ease-accelerate: cubic-bezier(0.3, 0, 1, 1); /* Éléments sortants */
--ease-overshoot: cubic-bezier(0.34, 1.56, 0.64, 1); /* Rebond ludique */
GSAP (GreenSock Animation Platform)
Utilisation de Base de GSAP
import gsap from 'gsap';
// Animer VERS des valeurs cibles
gsap.to('.box', {
x: 200,
y: 100,
rotation: 360,
scale: 1.5,
opacity: 0.8,
duration: 1,
ease: 'power2.out',
});
// Animer DEPUIS des valeurs vers l'état actuel
gsap.from('.hero-title', {
y: 60,
opacity: 0,
duration: 0.8,
ease: 'power3.out',
});
// Décaler plusieurs éléments
gsap.from('.card', {
y: 40,
opacity: 0,
duration: 0.6,
stagger: 0.1, // 100 ms entre chaque carte
ease: 'power2.out',
});
Timeline GSAP (Chorégraphie)
const tl = gsap.timeline({
defaults: { duration: 0.5, ease: 'power2.out' },
});
tl.from('.hero-bg', { scale: 1.1, opacity: 0, duration: 1 })
.from('.hero-title', { y: 40, opacity: 0 }, '-=0.3') // Commence 0,3 s avant la fin précédente
.from('.hero-subtitle', { y: 30, opacity: 0 }, '-=0.2')
.from('.hero-cta', { scale: 0.8, opacity: 0 }, '-=0.1')
.from('.hero-image', { x: 60, opacity: 0, duration: 0.8 }, '-=0.4');
// Contrôler la timeline
tl.play();
tl.pause();
tl.reverse();
tl.seek(0.5); // Sauter à 0,5 seconde
tl.timeScale(2); // Vitesse 2x
GSAP ScrollTrigger
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
gsap.registerPlugin(ScrollTrigger);
// Simple : animer lorsque l'élément entre dans la fenêtre d'affichage
gsap.from('.feature-card', {
scrollTrigger: {
trigger: '.feature-card',
start: 'top 80%', // Lorsque le haut de l'élément atteint 80% de la fenêtre
end: 'bottom 20%',
toggleActions: 'play none none reverse',
// onEnter onLeave onEnterBack onLeaveBack
},
y: 60,
opacity: 0,
duration: 0.8,
stagger: 0.15,
});
// Section épinglée avec scrub (liée au défilement)
gsap.to('.horizontal-section', {
scrollTrigger: {
trigger: '.horizontal-wrapper',
pin: true, // Épingler le wrapper pendant le défilement
scrub: 1, // Décalage fluide de 1 seconde derrière le défilement
start: 'top top',
end: '+=3000', // Défiler 3000px pour terminer l'animation
},
x: '-300%', // Faire glisser 4 panneaux vers la gauche
ease: 'none',
});
Framer Motion (React)
Animations de Base
import { motion } from 'framer-motion';
// Animer au montage
function FadeIn({ children }) {
return (
<motion.div
initial={{ opacity: 0, y: 20 }}
animate={{ opacity: 1, y: 0 }}
transition={{ duration: 0.4, ease: 'easeOut' }}
>
{children}
</motion.div>
);
}
// Animer au survol et au tap
function AnimatedButton() {
return (
<motion.button
whileHover={{ scale: 1.05 }}
whileTap={{ scale: 0.95 }}
transition={{ type: 'spring', stiffness: 400, damping: 17 }}
>
Cliquez-moi
</motion.button>
);
}
Animations de Mise en Page (FLIP)
import { motion, AnimatePresence } from 'framer-motion';
function TodoList({ items, onRemove }) {
return (
<ul>
<AnimatePresence>
{items.map((item) => (
<motion.li
key={item.id}
layout // Animation automatique des changements de position
initial={{ opacity: 0, x: -20 }}
animate={{ opacity: 1, x: 0 }}
exit={{ opacity: 0, x: 20, height: 0 }} // Animer à la suppression
transition={{
layout: { type: 'spring', stiffness: 300, damping: 30 },
opacity: { duration: 0.2 },
}}
>
{item.text}
<button onClick={() => onRemove(item.id)}>Supprimer</button>
</motion.li>
))}
</AnimatePresence>
</ul>
);
}
Variants (Enfants Orchestrés)
const container = {
hidden: { opacity: 0 },
show: {
opacity: 1,
transition: {
staggerChildren: 0.08,
delayChildren: 0.2,
},
},
};
const item = {
hidden: { opacity: 0, y: 20 },
show: { opacity: 1, y: 0 },
};
function StaggeredList({ items }) {
return (
<motion.ul variants={container} initial="hidden" animate="show">
{items.map((i) => (
<motion.li key={i.id} variants={item}>
{i.text}
</motion.li>
))}
</motion.ul>
);
}
Optimisation des Performances
Liste de Vérification pour la Composition
PEU COÛTEUX À ANIMER (composé par GPU, pas de mise en page ni de peinture) :
✓ transform (translate, scale, rotate)
✓ opacity
✓ filter (blur, brightness, etc.)
✓ clip-path (dans la plupart des navigateurs)
COÛTEUX À ANIMER (déclenche la mise en page ou la peinture) :
✗ width, height, top, left, right, bottom
✗ margin, padding
✗ border-width, border-radius
✗ font-size
✗ box-shadow (déclenche la peinture)
TECHNIQUE : Remplacer les propriétés coûteuses par des équivalents transform
changement de width -> transform: scaleX()
changement de height -> transform: scaleY()
changement de top/left -> transform: translate()
visibilité -> opacity: 0/1
Débogage des Performances
// Chrome DevTools : panneau Performance
// 1. Enregistrer pendant que l'animation se joue
// 2. Rechercher les images longues (>16,6 ms pour 60 ips)
// 3. Vérifier l'onglet "Rendering" : activer "Paint flashing" pour voir les repeints
// Forcer la composition GPU (à utiliser avec parcimonie)
.animated-element {
will-change: transform, opacity; /* Indice au navigateur : promouvoir dans son propre calque */
/* Supprimer will-change après la fin de l'animation pour libérer la mémoire GPU */
}
// Mesurer le taux d'images dans le code
let frames = 0;
let lastTime = performance.now();
function countFrames() {
frames++;
const now = performance.now();
if (now - lastTime >= 1000) {
console.log(`FPS : ${frames}`);
frames = 0;
lastTime = now;
}
requestAnimationFrame(countFrames);
}
countFrames();
Visibilité du Contenu pour les Éléments Hors Écran
/* Ne pas rendre les sections hors écran avant qu'elles ne soient nécessaires */
.section {
content-visibility: auto;
contain-intrinsic-size: auto 500px;
}
Accessibilité
Respecter les Mouvements Réduits
/* Toujours fournir des alternatives pour les mouvements réduits */
@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;
}
}
/* Ou désactiver sélectivement uniquement les animations non essentielles */
@media (prefers-reduced-motion: reduce) {
.decorative-animation { animation: none; }
.page-transition { transition: opacity 0.1ms; } /* Instantané mais déclenche toujours des événements */
/* Garder les animations fonctionnelles comme les spinners de chargement */
}
// GSAP : Vérifier la préférence de l'utilisateur
const prefersReducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
if (prefersReducedMotion) {
gsap.globalTimeline.timeScale(20); // Animations quasi-instantanées
}
// Framer Motion : Support intégré
import { useReducedMotion } from 'framer-motion';
function Component() {
const shouldReduceMotion = useReducedMotion();
return (
<motion.div
animate={{ x: 100 }}
transition={shouldReduceMotion ? { duration: 0 } : { duration: 0.5 }}
/>
);
}
Règles d'Accessibilité des Animations
- N'animez jamais un contenu qui ne transmet des informations que par le mouvement (certains utilisateurs ne le verront pas)
- Fournissez des contrôles de pause/arrêt pour les animations durant plus de 5 secondes
- Évitez les flashs plus de 3 fois par seconde (risque de crise, WCAG 2.3.1)
- N'utilisez pas l'animation comme seul moyen de transmettre un sens (par exemple, un champ de formulaire qui tremble doit également afficher un message d'erreur)
Anti-Patrons Courants
-
Animer les propriétés de mise en page :
width,height,top,leftprovoquent des à-coups de mise en page. Utiliseztransformà la place. -
Trop de calques
will-change: Chaque élémentwill-changeobtient son propre calque GPU. Trop de calques consomment de la mémoire et nuisent en fait aux performances. -
L'animation pour l'animation : Si la suppression de l'animation ne nuit pas à la convivialité, elle ne devrait probablement pas être là. Chaque animation doit avoir un objectif.
-
Ignorer les mouvements réduits : 15 à 20 % des utilisateurs souffrent de troubles vestibulaires ou de sensibilité au mouvement. Fournissez toujours des alternatives
prefers-reduced-motion. -
Animations JavaScript synchrones : Utiliser
setIntervalousetTimeoutpour les animations. UtilisezrequestAnimationFrame, les animations CSS ou les bibliothèques d'animation qui utilisent rAF en interne.
Liste de Vérification des Animations
- Objectif de l'animation défini (retour d'information, continuité, attention, chargement)
- Technologie choisie adaptée à la complexité
- Seules les propriétés composables sont animées (transform, opacity)
- Les fonctions d'assouplissement correspondent à l'intention de l'animation (ease-out pour les entrées, ease-in pour les sorties)
- La requête média
prefers-reduced-motionest implémentée - La durée est appropriée (100-300 ms pour les micro-interactions, 300-500 ms pour les transitions)
- Aucun contenu ne clignote plus de 3 fois par seconde
- Performance testée dans DevTools (60 ips constantes)
- Les animations ne bloquent pas l'interaction de l'utilisateur
- Les états de chargement utilisent des écrans squelettes ou des animations subtiles, pas des spinners partout
Quand Utiliser
Utilisez cette compétence quand :
- Concevoir ou implémenter des solutions d'animation web expertes
- Examiner ou améliorer des approches existantes d'animation web experte
- Prendre des décisions architecturales ou d'implémentation concernant l'animation web experte
- Apprendre les patrons et les meilleures pratiques de l'animation web experte
- Résoudre des problèmes liés à l'animation web experte
N'UTILISEZ PAS cette compétence quand :
- La question concerne un domaine technologique fondamentalement différent
- Une compétence sœur plus spécifique couvre le sujet exact nécessaire
- L'utilisateur a besoin d'un tutoriel pratique complet