Introduction
Les données statiques, c'est ennuyeux. Quand un utilisateur arrive sur une page avec des statistiques, des KPIs ou des métriques, l'animation fait toute la différence. Elle capte l'attention, rend l'information mémorable et ajoute une touche de professionnalisme à votre interface.
Dans ce tutoriel, nous allons explorer 5 techniques d'animation de données : des compteurs qui s'incrémentent, des barres de progression circulaires, des graphiques animés, des cartes statistiques et des jauges. Chaque exemple est accompagné de code fonctionnel prêt à l'emploi.
Toutes les demos utilisent l'API Intersection Observer pour déclencher les animations uniquement quand l'élément devient visible. Cela améliore les performances et l'expérience utilisateur.
1. Compteur animé (Animated Counter)
Le compteur animé est l'effet le plus courant pour afficher des chiffres clés. Le nombre s'incrémente progressivement de 0 jusqu'à la valeur cible, créant un effet de "comptage" engageant.
<!-- HTML -->
<div class="counter"
data-target="12847"
data-suffix="+">
0
</div>
<!-- CSS -->
.counter {
font-size: 4rem;
font-weight: 900;
background: linear-gradient(135deg, #6366f1, #8b5cf6);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
}
<!-- JavaScript -->
function animateCounter(element) {
const target = parseFloat(element.dataset.target);
const suffix = element.dataset.suffix || '';
const decimals = parseInt(element.dataset.decimals) || 0;
const duration = 2000;
const startTime = performance.now();
function update(currentTime) {
const elapsed = currentTime - startTime;
const progress = Math.min(elapsed / duration, 1);
// Easing function (ease-out)
const eased = 1 - Math.pow(1 - progress, 3);
const current = eased * target;
element.textContent = current.toFixed(decimals) + suffix;
if (progress < 1) {
requestAnimationFrame(update);
}
}
requestAnimationFrame(update);
}
// Trigger on scroll
const observer = new IntersectionObserver((entries) => {
entries.forEach(entry => {
if (entry.isIntersecting) {
animateCounter(entry.target);
observer.unobserve(entry.target);
}
});
}, { threshold: 0.5 });
document.querySelectorAll('.counter').forEach(el => observer.observe(el));
2. Progress bar circulaire
Les barres de progression circulaires sont parfaites pour afficher des pourcentages ou des scores. L'utilisation de SVG avec stroke-dasharray permet un contrôle précis de l'animation.
<!-- HTML -->
<div class="circular-progress" data-value="75">
<svg width="150" height="150" viewBox="0 0 150 150">
<defs>
<linearGradient id="gradient">
<stop offset="0%" stop-color="#6366f1"/>
<stop offset="100%" stop-color="#8b5cf6"/>
</linearGradient>
</defs>
<circle class="bg" cx="75" cy="75" r="65"/>
<circle class="progress" cx="75" cy="75" r="65"/>
</svg>
<div class="value">0%</div>
</div>
<!-- CSS -->
.circular-progress {
position: relative;
width: 150px;
height: 150px;
}
.circular-progress svg { transform: rotate(-90deg); }
.bg { fill: none; stroke: #1a1a2e; stroke-width: 10; }
.progress {
fill: none;
stroke: url(#gradient);
stroke-width: 10;
stroke-linecap: round;
stroke-dasharray: 408; /* 2 * PI * 65 */
stroke-dashoffset: 408;
transition: stroke-dashoffset 2s ease-out;
}
.value {
position: absolute;
top: 50%; left: 50%;
transform: translate(-50%, -50%);
font-size: 2rem; font-weight: 800;
}
<!-- JavaScript -->
function animateCircular(element) {
const value = parseInt(element.dataset.value);
const circle = element.querySelector('.progress');
const valueEl = element.querySelector('.value');
const circumference = 2 * Math.PI * 65; // ~408
const offset = circumference - (value / 100) * circumference;
circle.style.strokeDashoffset = offset;
// Animate the number
let current = 0;
const interval = setInterval(() => {
current++;
valueEl.textContent = current + '%';
if (current >= value) clearInterval(interval);
}, 2000 / value);
}
3. Bar chart animé
Un graphique en barres simple mais efficace. Chaque barre s'anime depuis la hauteur 0 jusqu'à sa valeur finale, créant un effet de "croissance" satisfaisant.
<!-- HTML -->
<div class="bar-chart">
<div class="bar-item">
<div class="bar-value">85%</div>
<div class="bar" data-value="85"></div>
<div class="bar-label">Lun</div>
</div>
<!-- Repeat for each bar -->
</div>
<!-- CSS -->
.bar-chart {
display: flex;
align-items: flex-end;
gap: 16px;
height: 200px;
padding: 20px;
}
.bar-item {
display: flex;
flex-direction: column;
align-items: center;
gap: 8px;
}
.bar {
width: 50px;
background: linear-gradient(180deg, #6366f1, #8b5cf6);
border-radius: 8px 8px 0 0;
transition: height 1s ease-out;
}
<!-- JavaScript -->
function animateBars() {
const bars = document.querySelectorAll('.bar');
bars.forEach((bar, index) => {
const value = bar.dataset.value;
setTimeout(() => {
bar.style.height = (value / 100) * 150 + 'px';
}, index * 100); // Stagger effect
});
}
4. Statistiques cards avec animation
Les cartes de statistiques combinent plusieurs éléments : une icône, un compteur animé et un label. L'effet d'entrée échelonné crée une cascade visuelle agréable.
<!-- HTML -->
<div class="stats-grid">
<div class="stat-card">
<div class="stat-icon">👥</div>
<div class="stat-value" data-target="15420">0</div>
<div class="stat-label">Utilisateurs</div>
</div>
</div>
<!-- CSS -->
.stats-grid {
display: grid;
grid-template-columns: repeat(3, 1fr);
gap: 20px;
}
.stat-card {
background: #12121a;
border: 1px solid rgba(255,255,255,0.08);
border-radius: 16px;
padding: 24px;
text-align: center;
opacity: 0;
transform: translateY(20px);
transition: all 0.6s ease-out;
}
.stat-card.visible {
opacity: 1;
transform: translateY(0);
}
.stat-value {
font-size: 2.5rem;
font-weight: 900;
background: linear-gradient(135deg, #6366f1, #8b5cf6);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
}
<!-- JavaScript -->
function animateStats() {
const cards = document.querySelectorAll('.stat-card');
cards.forEach((card, index) => {
setTimeout(() => {
card.classList.add('visible');
const valueEl = card.querySelector('.stat-value');
animateCounter(valueEl);
}, index * 200);
});
}
5. Gauge / Jauge animée
La jauge est idéale pour afficher des scores, performances ou niveaux. L'arc SVG se remplit progressivement tandis que l'aiguille pivote vers la valeur cible.
<!-- HTML -->
<div class="gauge" data-value="72">
<svg width="200" height="120" viewBox="0 0 200 120">
<defs>
<linearGradient id="gaugeGradient">
<stop offset="0%" stop-color="#ef4444"/>
<stop offset="50%" stop-color="#f59e0b"/>
<stop offset="100%" stop-color="#22c55e"/>
</linearGradient>
</defs>
<path class="bg-arc" d="M 20 100 A 80 80 0 0 1 180 100"/>
<path class="progress-arc" d="M 20 100 A 80 80 0 0 1 180 100"/>
<circle class="needle" cx="100" cy="100" r="8"/>
<line class="needle" x1="100" y1="100" x2="100" y2="30"/>
</svg>
<div class="gauge-value">0</div>
</div>
<!-- CSS -->
.gauge { position: relative; width: 200px; height: 120px; }
.bg-arc { fill: none; stroke: #1a1a2e; stroke-width: 20; }
.progress-arc {
fill: none;
stroke: url(#gaugeGradient);
stroke-width: 20;
stroke-linecap: round;
stroke-dasharray: 251; /* Arc length */
stroke-dashoffset: 251;
transition: stroke-dashoffset 2s ease-out;
}
.needle {
transform-origin: 100px 100px;
transition: transform 2s ease-out;
}
<!-- JavaScript -->
function animateGauge(element) {
const value = parseInt(element.dataset.value);
const arc = element.querySelector('.progress-arc');
const needles = element.querySelectorAll('.needle');
const valueEl = element.querySelector('.gauge-value');
const arcLength = 251;
const offset = arcLength - (value / 100) * arcLength;
const rotation = -90 + (value / 100) * 180;
arc.style.strokeDashoffset = offset;
needles.forEach(n => n.style.transform = `rotate(${rotation}deg)`);
// Animate number
let current = 0;
const interval = setInterval(() => {
current++;
valueEl.textContent = current;
if (current >= value) clearInterval(interval);
}, 2000 / value);
}
Aperçu live, customizer, code vanilla — zéro dépendance.
Bonnes pratiques
Performance
- Utilisez
requestAnimationFrameplutôt quesetIntervalpour les animations fluides - Préférez les propriétés CSS animables comme
transformetopacity - Limitez le nombre d'animations simultanées pour éviter les ralentissements
- Utilisez
will-changeavec parcimonie sur les éléments animés
UX et Design
- Durée d'animation : 1-2 secondes pour les données, pas plus
- Utilisez des easings naturels comme
ease-outou des courbes cubiques - Déclenchez au scroll pour éviter les animations invisibles au chargement
- Échelonnez les animations (stagger) pour un effet cascade agréable
Accessibilité
/* Respecter les preferences utilisateur */
@media (prefers-reduced-motion: reduce) {
.counter-value,
.circular-progress .progress,
.bar,
.stat-card,
.gauge .progress-arc,
.gauge .needle {
transition: none;
animation: none;
}
}
/* Ajouter des attributs ARIA */
<div class="circular-progress"
role="progressbar"
aria-valuenow="75"
aria-valuemin="0"
aria-valuemax="100"
aria-label="Progression : 75%">
</div>
Trop d'animations peuvent distraire l'utilisateur et nuire à la lisibilité. Réservez ces effets pour les données importantes et les moments clés du parcours utilisateur.
Conclusion
L'animation des données est un excellent moyen de rendre vos interfaces plus engageantes et mémorables. Les 5 techniques présentées ici couvrent la majorité des cas d'usage : compteurs pour les chiffres clés, barres de progression pour les pourcentages, graphiques pour les comparaisons, cartes pour les KPIs et jauges pour les scores.
N'oubliez pas de toujours respecter les préférences d'accessibilité de vos utilisateurs et de mesurer l'impact de ces animations sur les performances. Utilisées avec parcimonie, elles transformeront vos tableaux de bord et pages de statistiques.
Retrouvez plus de 50 effets de data visualization dans notre bibliothèque d'effets, avec code copiable en un clic.





