Introduction aux sliders comparatifs
Les sliders de comparaison avant/après sont des composants UI extrêmement populaires pour présenter des transformations visuelles. Que ce soit pour montrer une retouche photo, un avant/après rénovation, ou la différence entre deux versions d'un design, ce pattern offre une interaction intuitive et engageante.
Dans ce tutoriel complet, nous allons explorer plusieurs approches pour créer ce type de slider : de la version JavaScript complète avec support tactile, jusqu'à une version 100% CSS utilisant un input range. Chaque méthode a ses avantages selon vos besoins.
La technique CSS clip-path pour révéler une image, le drag JavaScript avec gestion des événements souris et tactiles, et une approche CSS-only élégante avec input[type="range"].
Structure HTML de base
La structure d'un slider comparatif repose sur deux couches superposées : l'image "après" en arrière-plan et l'image "avant" par-dessus, partiellement visible grâce à un masque CSS. Une poignée permet à l'utilisateur de contrôler la zone de révélation.
<div class="comparison-slider">
<!-- Couche arriere : image APRES -->
<div class="comparison-layer after">
<img src="after.jpg" alt="Apres"/>
</div>
<!-- Couche avant : image AVANT (masquee) -->
<div class="comparison-layer before">
<img src="before.jpg" alt="Avant"/>
</div>
<!-- Poignee draggable -->
<div class="comparison-handle"></div>
<!-- Labels optionnels -->
<span class="comparison-label before">Avant</span>
<span class="comparison-label after">Apres</span>
</div>
Points clés de la structure
- Ordre des couches : L'image "après" est en premier dans le DOM mais apparait en arrière grâce au z-index
- Position relative : Le conteneur parent doit être en
position: relativepour que les enfants absolus se positionnent correctement - Aspect ratio : Définissez une hauteur fixe ou utilisez
aspect-ratiopour maintenir les proportions - Overflow hidden : Essentiel pour masquer les parties des images qui débordent
CSS : la magie de clip-path
La propriété CSS clip-path est la clé de ce composant. Elle permet de définir une zone visible pour un élément, masquant tout ce qui se trouve en dehors. Pour notre slider, nous utilisons inset() qui fonctionne comme un cadre intérieur.
.comparison-slider {
position: relative;
width: 100%;
max-width: 600px;
aspect-ratio: 16 / 10;
overflow: hidden;
border-radius: 12px;
cursor: ew-resize;
user-select: none;
}
.comparison-layer {
position: absolute;
top: 0;
left: 0;
width: 100%;
height: 100%;
}
.comparison-layer img {
width: 100%;
height: 100%;
object-fit: cover;
}
.comparison-layer.after {
z-index: 1;
}
.comparison-layer.before {
z-index: 2;
/* clip-path: inset(top right bottom left) */
/* Montre 50% gauche de l'image AVANT */
clip-path: inset(0 50% 0 0);
}
Comprendre clip-path: inset()
La fonction inset() prend 4 valeurs dans l'ordre : top, right, bottom, left (comme les marges). Ces valeurs définissent la distance depuis chaque bord vers l'intérieur :
inset(0 50% 0 0): masque 50% depuis la droite, montrant la moitie gaucheinset(0 0 0 0): aucun masque, image entièrement visibleinset(0 100% 0 0): masque tout depuis la droite, image invisible
clip-path est très performant car il est accéléré par le GPU. C'est bien meilleur que de modifier la width d'un élément qui déclenche un reflow du layout.
Slider horizontal avec poignée draggable
Maintenant, ajoutons l'interactivite JavaScript. La poignée doit suivre le curseur de l'utilisateur et mettre à jour le clip-path en temps réel. Nous devons gérer les événements mousedown, mousemove et mouseup.
.comparison-handle {
position: absolute;
top: 0;
bottom: 0;
left: 50%;
width: 4px;
background: white;
transform: translateX(-50%);
z-index: 10;
box-shadow: 0 0 10px rgba(0,0,0,0.3);
}
/* Cercle de la poignee */
.comparison-handle::before {
content: '';
position: absolute;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
width: 44px;
height: 44px;
background: white;
border-radius: 50%;
box-shadow: 0 2px 12px rgba(0,0,0,0.4);
}
/* Icone fleches */
.comparison-handle::after {
content: '↔';
position: absolute;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
font-size: 1.2rem;
color: #333;
}
function initComparisonSlider(container) {
const before = container.querySelector('.before');
const handle = container.querySelector('.comparison-handle');
let isDragging = false;
// Calculer la position en pourcentage
function getPercent(clientX) {
const rect = container.getBoundingClientRect();
const x = clientX - rect.left;
return Math.max(0, Math.min(100, (x / rect.width) * 100));
}
// Mettre a jour le slider
function updateSlider(percent) {
before.style.clipPath = `inset(0 ${100 - percent}% 0 0)`;
handle.style.left = percent + '%';
}
// Evenements souris
container.addEventListener('mousedown', (e) => {
isDragging = true;
updateSlider(getPercent(e.clientX));
});
document.addEventListener('mousemove', (e) => {
if (!isDragging) return;
updateSlider(getPercent(e.clientX));
});
document.addEventListener('mouseup', () => {
isDragging = false;
});
}
// Initialisation
initComparisonSlider(document.querySelector('.comparison-slider'));
Explication du code JavaScript
- getPercent() : Calcule la position du curseur en pourcentage de la largeur du conteneur
- Math.max/min : Limite la valeur entre 0 et 100 pour éviter les débordements
- isDragging : Flag pour savoir si l'utilisateur est en train de glisser
- Écouteurs sur document : Les événements mousemove et mouseup sont sur le document pour continuer le drag même si le curseur sort du slider
Slider vertical
Une variante intéressante est le slider vertical, ou l'utilisateur glisse de haut en bas. Il suffit d'adapter le clip-path et la position de la poignée. Cette version est parfaite pour les comparaisons portrait ou les timelines.
.comparison-slider.vertical {
cursor: ns-resize;
}
.comparison-slider.vertical .before {
/* Masque depuis le bas au lieu de la droite */
clip-path: inset(0 0 50% 0);
}
.comparison-slider.vertical .comparison-handle {
/* Barre horizontale */
top: 50%;
bottom: auto;
left: 0;
right: 0;
width: auto;
height: 4px;
transform: translateY(-50%);
}
.comparison-slider.vertical .comparison-handle::after {
transform: translate(-50%, -50%) rotate(90deg);
}
function initVerticalSlider(container) {
const before = container.querySelector('.before');
const handle = container.querySelector('.comparison-handle');
let isDragging = false;
function getPercent(clientY) {
const rect = container.getBoundingClientRect();
const y = clientY - rect.top;
return Math.max(0, Math.min(100, (y / rect.height) * 100));
}
function updateSlider(percent) {
// inset: top right bottom left
before.style.clipPath = `inset(0 0 ${100 - percent}% 0)`;
handle.style.top = percent + '%';
}
container.addEventListener('mousedown', (e) => {
isDragging = true;
updateSlider(getPercent(e.clientY));
});
document.addEventListener('mousemove', (e) => {
if (!isDragging) return;
updateSlider(getPercent(e.clientY));
});
document.addEventListener('mouseup', () => isDragging = false);
}
Version CSS-only avec input range
Une approche élégante sans JavaScript consiste à utiliser un <input type="range"> invisible superpose au slider. L'utilisateur interagit avec le range natif, et nous utilisons des variables CSS pour mettre à jour l'affichage.
<div class="comparison-css-only" style="--pos: 50">
<div class="layer after"><img src="after.jpg"/></div>
<div class="layer before"><img src="before.jpg"/></div>
<div class="handle"></div>
<!-- Input range invisible -->
<input
type="range"
min="0"
max="100"
value="50"
oninput="this.parentElement.style.setProperty('--pos', this.value)"
/>
</div>
.comparison-css-only {
position: relative;
overflow: hidden;
--pos: 50; /* Variable CSS */
}
.comparison-css-only .before {
clip-path: inset(0 calc((100 - var(--pos)) * 1%) 0 0);
}
.comparison-css-only .handle {
left: calc(var(--pos) * 1%);
}
/* Input range invisible */
.comparison-css-only input[type="range"] {
position: absolute;
inset: 0;
width: 100%;
height: 100%;
margin: 0;
opacity: 0;
cursor: ew-resize;
z-index: 20;
-webkit-appearance: none;
}
Cette approche fonctionne sans JavaScript et bénéficie du support tactile natif des navigateurs. L'input range géré automatiquement le drag sur mobile sans code supplémentaire.
Touch support et accessibilité
Pour une expérience complète sur mobile, nous devons ajouter les événements tactiles. De plus, l'accessibilité est importante : les utilisateurs de clavier doivent pouvoir contrôler le slider.
function initComparisonSliderFull(container) {
const before = container.querySelector('.before');
const handle = container.querySelector('.comparison-handle');
let isDragging = false;
let currentPercent = 50;
function getPercent(clientX) {
const rect = container.getBoundingClientRect();
return Math.max(0, Math.min(100,
((clientX - rect.left) / rect.width) * 100
));
}
function updateSlider(percent) {
currentPercent = percent;
before.style.clipPath = `inset(0 ${100 - percent}% 0 0)`;
handle.style.left = percent + '%';
}
// Souris
container.addEventListener('mousedown', e => {
isDragging = true;
updateSlider(getPercent(e.clientX));
});
document.addEventListener('mousemove', e => {
if (isDragging) updateSlider(getPercent(e.clientX));
});
document.addEventListener('mouseup', () => isDragging = false);
// Touch
container.addEventListener('touchstart', e => {
isDragging = true;
updateSlider(getPercent(e.touches[0].clientX));
}, { passive: true });
container.addEventListener('touchmove', e => {
if (isDragging) {
updateSlider(getPercent(e.touches[0].clientX));
}
}, { passive: true });
container.addEventListener('touchend', () => isDragging = false);
// Clavier (accessibilite)
container.setAttribute('tabindex', '0');
container.setAttribute('role', 'slider');
container.setAttribute('aria-valuemin', '0');
container.setAttribute('aria-valuemax', '100');
container.setAttribute('aria-valuenow', '50');
container.addEventListener('keydown', e => {
const step = e.shiftKey ? 10 : 2;
if (e.key === 'ArrowLeft') {
updateSlider(currentPercent - step);
container.setAttribute('aria-valuenow', currentPercent);
} else if (e.key === 'ArrowRight') {
updateSlider(currentPercent + step);
container.setAttribute('aria-valuenow', currentPercent);
}
});
}
Points importants pour l'accessibilité
- tabindex="0" : Permet au slider de recevoir le focus clavier
- role="slider" : Indique aux lecteurs d'écran le type de composant
- aria-value* : Communique la valeur actuelle et les limites
- Touches flèches : Permettent de déplacer le slider sans souris
- Shift + flèche : Déplacement plus rapide (10% au lieu de 2%)
L'option { passive: true } améliore les performances sur mobile en indiquant au navigateur que l'événement ne sera pas annulé avec preventDefault(). Cela permet un scrolling plus fluide.
Bonnes pratiques et conseils
Voici quelques recommandations pour créer des sliders de comparaison professionnels et performants.
Performance
- Optimisez vos images : Utilisez des formats modernes (WebP, AVIF) et des tailles appropriées
- Lazy loading : Chargez les images uniquement quand le slider est visible
- Préférez clip-path : Plus performant que modifier width ou left sur les images
- Évitez les box-shadow complexes : Ils peuvent ralentir le rendu pendant le drag
UX Design
- Position initiale : 50% est le standard, mais adaptez selon le contenu
- Poignée visible : Elle doit clairement indiquer qu'on peut interagir
- Labels : Ajoutez "Avant"/"Après" pour clarifier
- Cursor : Utilisez
ew-resizeoucol-resize
Cas d'usage idéaux
- Retouche photo et filtres
- Rénovation et architecture (avant/après travaux)
- Comparaison de designs et maquettes
- Démonstration de produits (avec/sans fonctionnalité)
- Évolution temporelle (historique vs actuel)
/* Respect des preferences utilisateur */
@media (prefers-reduced-motion: reduce) {
.comparison-slider * {
transition: none !important;
}
}
/* Focus visible pour accessibilite */
.comparison-slider:focus-visible {
outline: 3px solid #6366f1;
outline-offset: 2px;
}
Conclusion
Le slider de comparaison avant/après est un composant versatile qui enrichit considérablement l'expérience utilisateur. Que vous choisissiez l'approche JavaScript complète pour un contrôle total, ou la version CSS-only pour sa simplicité, vous disposez maintenant de toutes les techniques nécessaires.
Les points clés à retenir :
- clip-path: inset() est votre meilleur ami pour ce type d'effet
- Pensez toujours au support tactile et à l'accessibilité clavier
- La version CSS-only avec input range est parfaite pour les cas simples
- Optimisez vos images pour des performances fluides
Retrouvez des sliders de comparaison prêts à l'emploi dans notre bibliothèque d'effets, avec des variantes animées et des styles personnalisables.
Aperçu live, customizer, code vanilla — zéro dépendance.


