Slider comparatif Avant/Après

Apprenez à créer un slider de comparaison interactif permettant aux utilisateurs de révéler deux états d'une image ou d'un élément. Idéal pour les portfolios, retouches photo et démonstrations produit.

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.

💡
Ce que vous allez apprendre

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.

comparison-slider.html
<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: relative pour que les enfants absolus se positionnent correctement
  • Aspect ratio : Définissez une hauteur fixe ou utilisez aspect-ratio pour 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.

APRÈS
AVANT
Avant Après
comparison-slider.css
.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 gauche
  • inset(0 0 0 0) : aucun masque, image entièrement visible
  • inset(0 100% 0 0) : masque tout depuis la droite, image invisible
⚡
Performance

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.css
.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;
}
comparison-slider.js
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.

APRÈS
AVANT
vertical-slider.css
.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);
}
vertical-slider.js
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.

APRÈS
AVANT
css-only-slider.html
<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>
css-only-slider.css
.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;
}
👍
Avantage CSS-only

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.

touch-support.js
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%)
⚠️
passive: true pour les événements touch

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-resize ou col-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)
reduced-motion.css
/* 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
🎨
Allez plus loin

Retrouvez des sliders de comparaison prêts à l'emploi dans notre bibliothèque d'effets, avec des variantes animées et des styles personnalisables.

35+ effets Galeries & Sliders prêts à copier

Aperçu live, customizer, code vanilla — zéro dépendance.

Voir les effets Sliders

Les effets de cet article dans le catalogue

Les mêmes techniques, prêtes à copier : aperçu en direct, réglages et code complet sur la page de leur catégorie.

À lire aussi

Trois articles proches pour aller plus loin.