Éléments interactifs en JavaScript : drag, magnetic et morph

Apprenez à créer des éléments interactifs engageants qui réagissent au curseur : drag and drop, effets magnétiques, animations élastiques et morphing de formes. Des techniques qui transforment vos interfaces.

Introduction aux éléments interactifs

Les interfaces modernes ne se contentent plus d'afficher du contenu statique. Les utilisateurs s'attendent à des interactions fluides et engageantes qui répondent à leurs actions de manière naturelle et intuitive.

Dans ce guide complet, nous allons explorer 6 techniques essentielles pour créer des éléments interactifs en JavaScript pur : du drag and drop natif aux effets magnétiques, en passant par les animations élastiques et le morphing de formes.

💡
Bon à savoir

Toutes ces techniques fonctionnent en JavaScript vanilla, sans dépendance externe. Elles utilisent principalement les événements mousedown, mousemove et mouseup combines avec requestAnimationFrame pour des animations fluides.

Chaque exemple est accompagné d'une demo interactive et du code complet que vous pouvez copier et adapter à vos projets. Les techniques présentées sont compatibles avec tous les navigateurs modernes.

1. Drag and Drop natif

Le drag and drop est l'une des interactions les plus intuitives. Permettre à l'utilisateur de déplacer des éléments à la souris crée une expérience tactile et engageante, même sur desktop.

Voici une implementation simple mais efficace qui gère correctement les limites du conteneur :

Drag me
draggable.js
function makeDraggable(element, container) {
  let isDragging = false;
  let startX, startY, initialX, initialY;

  element.addEventListener('mousedown', (e) => {
    isDragging = true;
    startX = e.clientX;
    startY = e.clientY;
    initialX = element.offsetLeft;
    initialY = element.offsetTop;
    element.classList.add('dragging');
  });

  document.addEventListener('mousemove', (e) => {
    if (!isDragging) return;

    const dx = e.clientX - startX;
    const dy = e.clientY - startY;

    // Calcul des limites
    const maxX = container.offsetWidth - element.offsetWidth;
    const maxY = container.offsetHeight - element.offsetHeight;

    let newX = Math.max(0, Math.min(maxX, initialX + dx));
    let newY = Math.max(0, Math.min(maxY, initialY + dy));

    element.style.left = newX + 'px';
    element.style.top = newY + 'px';
  });

  document.addEventListener('mouseup', () => {
    isDragging = false;
    element.classList.remove('dragging');
  });
}

Points clés de l'implementation

  • Calcul des offsets : On stocke la position initiale au mousedown pour calculer le déplacement relatif
  • Limites du conteneur : Math.max et Math.min garantissent que l'élément reste dans sa zone
  • Écoute sur document : mousemove et mouseup sur document pour éviter de perdre le drag si le curseur sort de l'élément

2. Éléments magnétiques

L'effet magnétique attire un élément vers le curseur quand celui-ci s'en approche. C'est une technique très populaire pour les boutons CTA car elle crée une sensation d'interactivite unique.

magnetic.js
function makeMagnetic(element, zone, strength = 0.35, radius = 120) {
  zone.addEventListener('mousemove', (e) => {
    const rect = element.getBoundingClientRect();
    const centerX = rect.left + rect.width / 2;
    const centerY = rect.top + rect.height / 2;

    const deltaX = e.clientX - centerX;
    const deltaY = e.clientY - centerY;
    const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);

    if (distance < radius) {
      // Plus le curseur est proche, plus l'attraction est forte
      const factor = 1 - (distance / radius);
      const moveX = deltaX * strength * factor;
      const moveY = deltaY * strength * factor;

      element.style.transform = `translate(${moveX}px, ${moveY}px)`;
    } else {
      element.style.transform = 'translate(0, 0)';
    }
  });

  zone.addEventListener('mouseleave', () => {
    element.style.transform = 'translate(0, 0)';
  });
}
🎯
Paramètres ajustables

strength (0.2-0.5) contrôle l'intensité du déplacement. radius (80-150px) définit la zone d'activation. Expérimentez pour trouver le bon équilibre entre effet spectaculaire et utilisabilite.

3. Effet élastique au drag

L'effet élastique ajoute une physique réaliste au drag and drop : l'élément suit le curseur avec un léger retard et un effet de rebond, comme s'il était attaché par un élastique.

Elastic
elastic-drag.js
function makeElasticDrag(element, container) {
  let isDragging = false;
  let targetX = 0, targetY = 0;
  let currentX = 0, currentY = 0;
  let velocityX = 0, velocityY = 0;

  const spring = 0.15;  // Force du ressort
  const friction = 0.75; // Amortissement

  function animate() {
    // Physique du ressort
    const dx = targetX - currentX;
    const dy = targetY - currentY;

    velocityX += dx * spring;
    velocityY += dy * spring;

    velocityX *= friction;
    velocityY *= friction;

    currentX += velocityX;
    currentY += velocityY;

    element.style.transform = `translate(${currentX}px, ${currentY}px)`;

    requestAnimationFrame(animate);
  }

  animate();

  let offsetX, offsetY;

  element.addEventListener('mousedown', (e) => {
    isDragging = true;
    const rect = container.getBoundingClientRect();
    offsetX = e.clientX - rect.left - currentX;
    offsetY = e.clientY - rect.top - currentY;
  });

  document.addEventListener('mousemove', (e) => {
    if (!isDragging) return;
    const rect = container.getBoundingClientRect();
    targetX = e.clientX - rect.left - offsetX;
    targetY = e.clientY - rect.top - offsetY;
  });

  document.addEventListener('mouseup', () => {
    isDragging = false;
  });
}

La physique du ressort

Cette technique utilise un modèle de spring physics simplifie :

  • spring (0.1-0.3) : Plus la valeur est élevée, plus l'élément suit rapidement
  • friction (0.7-0.9) : Contrôle l'amortissement, une valeur basse = plus de rebonds
  • requestAnimationFrame : Assure une animation à 60fps pour une fluidité optimale

4. Rotation 3D suivant le curseur

L'effet de rotation 3D (ou "tilt effect") fait pivoter un élément en fonction de la position du curseur, créant une illusion de profondeur très immersive.

Bougez la souris
tilt-3d.js
function makeTiltable(element, maxAngle = 20) {
  element.addEventListener('mousemove', (e) => {
    const rect = element.getBoundingClientRect();

    // Position relative du curseur (-0.5 a 0.5)
    const x = (e.clientX - rect.left) / rect.width - 0.5;
    const y = (e.clientY - rect.top) / rect.height - 0.5;

    // Rotation inversee pour un effet naturel
    const rotateY = x * maxAngle;
    const rotateX = -y * maxAngle;

    element.style.transform = `
      perspective(1000px)
      rotateX(${rotateX}deg)
      rotateY(${rotateY}deg)
      scale3d(1.05, 1.05, 1.05)
    `;
  });

  element.addEventListener('mouseleave', () => {
    element.style.transform = 'perspective(1000px) rotateX(0) rotateY(0)';
  });
}
⚠️
Performance

Les transformations 3D sont accélérées par le GPU, mais évitez d'appliquer cet effet à trop d'éléments simultanément. Pour les listes longues, activez l'effet uniquement sur l'élément survole.

5. Morph de formes au hover

Le morphing de formes permet de transformer fluidement un élément d'une forme à une autre. Combine avec clip-path ou border-radius, vous pouvez créer des transitions organiques fascinantes.

Cliquez sur les formes ci-dessous pour les voir se transformer :

morph.css
.morph-shape {
  width: 100px;
  height: 100px;
  background: linear-gradient(135deg, #6366f1, #8b5cf6);
  cursor: pointer;
  transition: all 0.6s cubic-bezier(0.68, -0.55, 0.265, 1.55);
}

.morph-shape.circle {
  border-radius: 50%;
}

.morph-shape.square {
  border-radius: 16px;
}

.morph-shape.rounded {
  border-radius: 30%;
}

.morph-shape.blob {
  border-radius: 60% 40% 30% 70% / 60% 30% 70% 40%;
}

/* Animation continue pour le blob */
@keyframes blobMorph {
  0%, 100% {
    border-radius: 60% 40% 30% 70% / 60% 30% 70% 40%;
  }
  50% {
    border-radius: 30% 60% 70% 40% / 50% 60% 30% 60%;
  }
}
morph.js
const shapes = ['circle', 'square', 'rounded', 'blob'];

function makeMorphable(element) {
  let currentIndex = shapes.findIndex(
    s => element.classList.contains(s)
  );

  element.addEventListener('click', () => {
    // Retirer la classe actuelle
    element.classList.remove(shapes[currentIndex]);

    // Passer a la forme suivante
    currentIndex = (currentIndex + 1) % shapes.length;

    // Ajouter la nouvelle classe
    element.classList.add(shapes[currentIndex]);
  });
}

6. Combinaisons créatives

La vraie magie arrive quand vous combinez plusieurs effets. Voici un élément qui intègre drag, rotation 3D et morphing au survol :

Drag + Tilt + Morph
combo-interactive.js
function makeComboInteractive(element, container) {
  let isDragging = false;
  let posX = 0, posY = 0;
  let rotateX = 0, rotateY = 0;

  function updateTransform() {
    element.style.transform = `
      translate(${posX}px, ${posY}px)
      perspective(800px)
      rotateX(${rotateX}deg)
      rotateY(${rotateY}deg)
    `;
  }

  // Drag
  let startX, startY, startPosX, startPosY;

  element.addEventListener('mousedown', (e) => {
    isDragging = true;
    startX = e.clientX;
    startY = e.clientY;
    startPosX = posX;
    startPosY = posY;
    element.style.borderRadius = '50%'; // Morph en cercle
  });

  document.addEventListener('mousemove', (e) => {
    if (isDragging) {
      posX = startPosX + (e.clientX - startX);
      posY = startPosY + (e.clientY - startY);
      // Tilt pendant le drag
      rotateY = (e.clientX - startX) * 0.1;
      rotateX = -(e.clientY - startY) * 0.1;
      updateTransform();
    }
  });

  document.addEventListener('mouseup', () => {
    isDragging = false;
    rotateX = 0;
    rotateY = 0;
    element.style.borderRadius = '20px'; // Retour carre
    updateTransform();
  });
}

Bonnes pratiques

Avant de déployer ces effets en production, gardez ces recommandations en tête :

Performance

  • Utilisez transform plutôt que top/left pour les animations (GPU accéléré)
  • requestAnimationFrame pour les animations continues
  • will-change avec parcimonie sur les éléments qui seront animés
  • Throttle les events mousemove si nécessaire

Accessibilité

  • prefers-reduced-motion : Désactivez les animations pour les utilisateurs sensibles
  • Focus visible : Assurez que les éléments restent accessibles au clavier
  • ARIA : Ajoutez les attributs appropries pour les lecteurs d'écran
accessibility.css
@media (prefers-reduced-motion: reduce) {
  .draggable,
  .magnetic-btn,
  .tilt-card,
  .morph-shape {
    transition: none !important;
    animation: none !important;
  }
}

Touch support

N'oubliez pas d'ajouter le support tactile pour les appareils mobiles :

touch-support.js
// Ajoutez les events touch en parallele des events mouse
element.addEventListener('touchstart', handleStart, { passive: false });
element.addEventListener('touchmove', handleMove, { passive: false });
element.addEventListener('touchend', handleEnd);

function handleStart(e) {
  e.preventDefault();
  const touch = e.touches[0];
  // Utiliser touch.clientX et touch.clientY
}

Conclusion

Les éléments interactifs transforment une interface ordinaire en une expérience mémorables. En maîtrisant le drag and drop, les effets magnétiques, les animations élastiques et le morphing, vous disposez d'un arsenal complet pour créer des interfaces uniques.

L'important est de doser ces effets avec parcimonie : trop d'interactions peuvent devenir fatigantes. Utilisez-les stratégiquement sur vos éléments clés (CTAs, cards importantes, navigation) pour maximiser leur impact.

🎨
Allez plus loin

Retrouvez 50+ effets interactifs prêts à l'emploi dans notre bibliothèque d'effets, avec code copiable et personnalisable.

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.