Vai al contenuto
animorio
EN
Guide

Guida

Hover e micro-interazioni dei pulsanti: tempi, molle e stati

Un pulsante ben animato ha quattro momenti: quando il puntatore arriva, quando il dito preme, quando l’azione è in corso e quando torna a riposo. Quanto deve durare ognuno, perché le molle funzionano meglio delle curve, come scrivere l’hover solo per chi ha un mouse e come non far aspettare nessuno.

31 ottobre 202610 minuti di letturaIl team di Animorio

Pulsante che pesaPulsante che pesa

Un pulsante è la parte di un sito che si tocca di più, e per questo è quella in cui un’animazione sbagliata si nota di più. Un hover troppo lento fa sembrare la pagina impastata, una pressione che non si vede fa cliccare due volte, un ritorno brusco dà l’impressione di un elastico che si spezza. Le micro-interazioni dei pulsanti non sono decorazioni: sono il modo in cui l’interfaccia risponde «ti ho sentito». In questa guida le smontiamo una alla volta, con i tempi che usiamo nella libreria di Animorio e il codice per farle.

I quattro stati di un pulsante

Prima di animare conviene elencare gli stati, perché ognuno ha un compito diverso.

Riposo. Il pulsante deve sembrare cliccabile senza muoversi: forma, colore e contrasto fanno tutto. Un pulsante che pulsa o si muove da solo attira l’occhio una volta e poi stanca.

Avvicinamento. Quando il puntatore arriva sopra, il pulsante conferma che ha capito: si schiarisce, si allarga appena, la freccia si sposta di qualche pixel. È lo stato più delicato, perché chi passa sopra spesso non vuole cliccare.

Pressione. Nel momento in cui il dito o il tasto scendono, il pulsante si abbassa. Questa risposta deve essere immediata: è quella che dice «il clic è arrivato».

Esito. Dopo il clic il pulsante racconta cosa è successo: in corso, fatto, errore. È lo stato più trascurato e il più utile.

I tempi: corti all’andata, morbidi al ritorno

Le durate che funzionano sono più corte di quanto si pensi. Come punto di partenza usiamo questi valori, e li cambiamo solo dopo averli provati con la mano.

  • Avvicinamento: 150-250 millisecondi.
  • Pressione: 60-100 millisecondi, quasi istantanea.
  • Rilascio dopo la pressione: 300-500 millisecondi, con un piccolo rimbalzo.
  • Uscita del puntatore: un po’ più lenta dell’entrata, 250-400 millisecondi.

L’asimmetria è voluta. Chi arriva su un pulsante vuole una risposta pronta; quando se ne va, un ritorno più morbido evita che il pulsante «scatti» sotto l’occhio. In CSS basta dare transizioni diverse allo stato normale e a quello in hover: la transizione scritta sullo stato verso cui si va è quella che vale.

.pulsante {
  transition: transform 0.35s cubic-bezier(0.34, 1.56, 0.64, 1),
              background-color 0.3s ease;
}
@media (hover: hover) and (pointer: fine) {
  .pulsante:hover {
    transform: translateY(-2px);
    background-color: var(--accento-chiaro);
    transition-duration: 0.18s;
  }
}
.pulsante:active {
  transform: translateY(1px) scale(0.98);
  transition-duration: 0.06s;
}

La curva cubic-bezier(0.34, 1.56, 0.64, 1) supera la fine di poco e torna indietro: è il modo più semplice di avere un rimbalzo in CSS senza librerie.

L’hover solo per chi ha un mouse

Sul telefono non esiste il passaggio del puntatore. I browser mobili, per compatibilità, applicano :hover al primo tocco e lo lasciano attivo finché non si tocca altrove: il pulsante resta «acceso» dopo il clic, a volte serve un secondo tocco per attivare il link. La soluzione è scrivere ogni hover dentro una media query che chiede un dispositivo capace di passare sopra con precisione.

@media (hover: hover) and (pointer: fine) {
  .scheda:hover .scheda__freccia { transform: translateX(4px); }
}

Per il telefono il feedback si sposta sulla pressione: :active funziona anche al tocco, purché la pagina abbia un gestore touchstart o il CSS dica touch-action: manipulation, che toglie anche il ritardo del doppio tocco.

Le molle: perché sembrano vere

Una curva di animazione ha una durata fissa: il movimento finisce sempre dopo lo stesso tempo, qualunque cosa succeda. Una molla invece ha una rigidità e uno smorzamento, e la durata viene da sola. La differenza si sente quando l’animazione viene interrotta: se il puntatore entra ed esce in fretta, una curva riparte da capo o salta, una molla continua dal punto e dalla velocità in cui si trova. È per questo che le interfacce dei telefoni usano quasi solo molle.

In GSAP una molla vera non c’è, ma si ottiene un comportamento molto vicino con quickTo, che crea una funzione da chiamare a ogni movimento e insegue il valore nuovo senza ripartire da zero.

const pulsante = document.querySelector('.magnetico');
const x = gsap.quickTo(pulsante, 'x', { duration: 0.5, ease: 'elastic.out(1, 0.4)' });
const y = gsap.quickTo(pulsante, 'y', { duration: 0.5, ease: 'elastic.out(1, 0.4)' });

pulsante.addEventListener('pointermove', (e) => {
  const r = pulsante.getBoundingClientRect();
  x((e.clientX - r.left - r.width / 2) * 0.3);
  y((e.clientY - r.top - r.height / 2) * 0.3);
});
pulsante.addEventListener('pointerleave', () => { x(0); y(0); });

È la base del pulsante magnetico: il pulsante si sporge verso il puntatore di un terzo della distanza, la scritta dentro un po’ di più, e quando il puntatore se ne va torna al suo posto con un’oscillazione breve. Il fattore 0,3 è importante: con valori più alti il pulsante «insegue» il puntatore e diventa difficile da cliccare.

Animare il contenuto, non solo la scatola

I pulsanti più riusciti non muovono tutto insieme: muovono una parte, e il resto la segue con un piccolo ritardo. La scritta che si sposta un po’ più del fondo, l’icona che ruota mentre il pulsante si allarga, le lettere che cambiano peso una alla volta. Nel pulsante col peso sotto il dito le lettere vicine al puntatore prendono peso come sotto una lente, ognuna sulla sua molla, e la pillola si allarga quanto serve alle lettere più grosse. Si fa con un carattere variabile e una proprietà CSS per lettera.

const lettere = [...document.querySelectorAll('.pulsante span')];
const pesi = lettere.map((l) => gsap.quickTo(l, '--peso', { duration: 0.4, ease: 'power3.out' }));

pulsante.addEventListener('pointermove', (e) => {
  lettere.forEach((l, i) => {
    const r = l.getBoundingClientRect();
    const d = Math.abs(e.clientX - (r.left + r.width / 2));
    pesi[i](Math.max(350, 800 - d * 6));
  });
});

Nel CSS la lettera usa la variabile: font-variation-settings: 'wght' var(--peso). Il trucco funziona solo con un carattere variabile vero, che abbia l’asse del peso: con un carattere normale il browser salta da un peso all’altro senza passaggi.

Lo stato di esito: far vedere che l’azione è successa

Dopo il clic il pulsante ha un lavoro in più: dire com’è andata, senza costringere a guardare altrove. Tre esempi della libreria mostrano tre casi diversi.

Il pulsante che copia conferma un’azione che non si vede: copiare un testo non cambia niente sulla pagina, quindi il pulsante deve mostrare che è successo. I caratteri volano dentro l’icona degli appunti, che si riempie e diventa una spunta. Dopo un paio di secondi torna com’era, pronto per un’altra copia.

Il pulsante che chiede conferma protegge da un’azione che non si annulla. Al primo clic non cancella niente: la scritta diventa «Click again to delete» e la pillola si allunga; il tempo per rispondere è lo spazio che resta, che si accorcia in tre secondi. È più veloce di una finestra di conferma e più chiaro di un avviso scritto.

Il pulsante da far scorrere chiede un gesto lungo per un’azione importante, come confermare un pagamento. Lasciato troppo presto torna indietro: l’errore costa poco e si capisce subito.

In tutti e tre la regola è la stessa: lo stato di esito si scrive anche come testo, non solo come forma. Un’icona che diventa una spunta va accompagnata da una scritta o da un aria-label che cambia, così chi non vede l’animazione sa comunque cosa è successo.

La pressione sulla tastiera

Chi naviga con la tastiera attiva i pulsanti con Invio o con la barra spaziatrice, e deve avere lo stesso feedback di chi clicca. :active scatta anche con la barra spaziatrice, ma non con Invio su tutti i browser, quindi per le animazioni fatte in JavaScript conviene ascoltare pointerdown e keydown insieme. Il contorno del focus, poi, non va mai tolto: si può disegnare in modo che stia bene con lo stile del sito, con :focus-visible che compare solo a chi usa la tastiera.

.pulsante:focus-visible {
  outline: 2px solid var(--accento);
  outline-offset: 4px;
}

Gli errori più comuni

Spostare il pulsante sotto il puntatore. Un hover che solleva il pulsante di dieci pixel lo fa uscire da sotto il puntatore, l’hover finisce, il pulsante ricade, l’hover ricomincia: un tremolio infinito. Gli spostamenti in hover vanno tenuti sotto i 3-4 pixel, o applicati a un figlio mentre la zona cliccabile resta ferma.

Animare width, padding o margin. Ogni fotogramma ricalcola l’impaginazione di tutta la riga. Per allargare un pulsante si usa transform: scale su un fondo separato, oppure si accetta di animare la larghezza solo quando l’impaginazione intorno non cambia.

Rimbalzi dappertutto. Un rimbalzo dà carattere al pulsante principale; dieci pulsanti che rimbalzano danno il mal di mare. I pulsanti secondari e i link nel testo vogliono transizioni semplici.

Nessuna risposta durante l’attesa. Se l’azione richiede il server, il pulsante deve cambiare stato al clic, non quando arriva la risposta. Il pulsante del carrello parte subito con la borsa che vola via, e il numero si aggiorna quando il server ha confermato.

Provare con la mano

Le micro-interazioni non si giudicano guardando un video: si giudicano usandole, cento volte di fila, con il mouse e con il dito. Ogni pulsante della libreria ha il Playground con le manopole per tempi, distanze e rimbalzi: conviene provarlo con la mano, regolare finché non si smette di notarlo, e solo allora copiarne il codice. Un buon pulsante è quello di cui ci si accorge solo quando manca.

Da provare nella libreria

I pezzi citati nella guida, con la demo dal vivo, le manopole e il codice.

Guide