1. Introduzione
Una demo interattiva e un codelab per scoprire di più su Interaction to Next Paint (INP).
Prerequisiti
- Conoscenza dello sviluppo di HTML e JavaScript.
- Consigliato: leggi la documentazione relativa a INP.
Cosa imparerai
- In che modo l'interazione tra gli utenti e la tua gestione di queste interazioni influisce sull'adattabilità della pagina.
- Come ridurre ed eliminare i ritardi per un'esperienza utente fluida.
Cosa serve
- Un computer con la possibilità di clonare il codice da GitHub ed eseguire i comandi npm.
- Un editor di testo.
- Una versione recente di Chrome per il funzionamento di tutte le misurazioni delle interazioni.
2. Configurazione
Ottieni ed esegui il codice
Il codice si trova nel repository web-vitals-codelabs.
- Clona il repository nel terminale:
git clone https://github.com/GoogleChromeLabs/web-vitals-codelabs.git - Vai alla directory clonata:
cd web-vitals-codelabs/understanding-inp - Installa le dipendenze:
npm ci - Avvia il server web:
npm run start - Visita http://localhost:5173/understanding-inp/ nel browser.
Panoramica dell'app
Nella parte superiore della pagina sono presenti un contatore Punteggio e un pulsante Incrementa. Una classica dimostrazione di reattività e adattabilità.

Sotto il pulsante sono presenti quattro misurazioni:
- INP: il punteggio INP corrente, che in genere corrisponde all'interazione peggiore.
- Interazione: il punteggio dell'interazione più recente.
- FPS: i frame al secondo del thread principale della pagina.
- Timer: un'animazione del timer in esecuzione per aiutarti a visualizzare i jank.
Le voci FPS e Timer non sono affatto necessarie per misurare le interazioni. Vengono aggiunti solo per semplificare la visualizzazione della reattività.
Prova
Prova a interagire con il pulsante Increment e osserva l'aumento del punteggio. I valori INP e Interazione cambiano a ogni incremento?
L'INP misura il tempo che intercorre tra il momento in cui l'utente interagisce e quello in cui la pagina mostra effettivamente l'aggiornamento visualizzato all'utente.
3. Misurazione delle interazioni con Chrome DevTools
Apri DevTools dal menu Altri strumenti > Strumenti per sviluppatori, facendo clic con il tasto destro del mouse sulla pagina e selezionando Ispeziona o utilizzando una scorciatoia da tastiera.
Passa al riquadro Prestazioni, che utilizzerai per misurare le interazioni.

Poi, acquisisci un'interazione nel riquadro Prestazioni.
- Premi il pulsante per registrare.
- Interagisci con la pagina (premi il pulsante Incrementa).
- Interrompi la registrazione.
Nella sequenza temporale risultante, troverai una traccia Interazioni. Espandila facendo clic sul triangolo a sinistra.

Vengono visualizzate due interazioni. Ingrandisci il secondo scorrendo o tenendo premuto il tasto W.

Se passi il mouse sopra l'interazione, puoi vedere che l'interazione è stata rapida, senza tempo di durata dell'elaborazione e con un tempo minimo di ritardo dell'input e ritardo di presentazione, la cui durata esatta dipende dalla velocità della tua macchina.
4. Listener di eventi a esecuzione prolungata
Apri il file index.js e rimuovi il commento dalla funzione blockFor all'interno del listener di eventi.
Visualizza il codice completo: click_block.html
button.addEventListener('click', () => {
blockFor(1000);
score.incrementAndUpdateUI();
});
Salva il file. Il server rileverà la modifica e aggiornerà la pagina.
Prova a interagire di nuovo con la pagina. Le interazioni saranno ora notevolmente più lente.
Traccia di rendimento
Esegui un'altra registrazione nel riquadro Prestazioni per vedere come appare.

Quella che un tempo era una breve interazione ora richiede un secondo intero.
Quando passi il mouse sopra l'interazione, noterai che il tempo viene impiegato quasi interamente nella "Durata dell'elaborazione", ovvero il tempo impiegato per eseguire i callback del listener di eventi. Poiché la chiamata blockFor di blocco si trova interamente all'interno del listener di eventi, è lì che viene impiegato il tempo.
5. Esperimento: durata dell'elaborazione
Prova a riorganizzare il lavoro del listener di eventi per vedere l'effetto su INP.
Aggiorna prima la UI
Cosa succede se inverti l'ordine delle chiamate JS, aggiornando prima l'UI e poi bloccando?
Visualizza il codice completo: ui_first.html
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
blockFor(1000);
});
Hai notato che la UI è apparsa prima? L'ordine influisce sui punteggi INP?
Prova a eseguire una traccia ed esamina l'interazione per vedere se ci sono differenze.
Listener separati
Cosa succede se sposti il lavoro in un listener di eventi separato? Aggiorna la UI in un listener di eventi e blocca la pagina da un listener separato.
Visualizza il codice completo: two_click.html
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
});
button.addEventListener('click', () => {
blockFor(1000);
});
Che aspetto ha ora nel riquadro Prestazioni?
Diversi tipi di eventi
La maggior parte delle interazioni attiva molti tipi di eventi, da quelli del puntatore o dei tasti, a quelli di passaggio del mouse, attivazione/disattivazione dello stato attivo ed eventi sintetici come beforechange e beforeinput.
Molte pagine reali hanno listener per molti eventi diversi.
Cosa succede se modifichi i tipi di evento per i listener di eventi? Ad esempio, sostituire uno dei listener di eventi click con pointerup o mouseup?
Visualizza il codice completo: diff_handlers.html
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
});
button.addEventListener('pointerup', () => {
blockFor(1000);
});
Nessun aggiornamento dell'interfaccia utente
Cosa succede se rimuovi la chiamata per aggiornare l'UI dal listener di eventi?
Visualizza il codice completo: no_ui.html
button.addEventListener('click', () => {
blockFor(1000);
// score.incrementAndUpdateUI();
});
6. Risultati dell'esperimento sulla durata dell'elaborazione
Traccia delle prestazioni: aggiorna prima l'UI
Visualizza il codice completo: ui_first.html
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
blockFor(1000);
});
Se osservi una registrazione del clic sul pulsante nel riquadro Prestazioni, puoi notare che i risultati non sono cambiati. Sebbene sia stato attivato un aggiornamento della UI prima del codice di blocco, il browser non ha aggiornato effettivamente ciò che è stato visualizzato sullo schermo fino al completamento del listener di eventi, il che significa che l'interazione ha comunque richiesto poco più di un secondo per essere completata.

Traccia di rendimento: listener separati
Visualizza il codice completo: two_click.html
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
});
button.addEventListener('click', () => {
blockFor(1000);
});
Anche in questo caso, non c'è alcuna differenza dal punto di vista funzionale. L'interazione richiede comunque un secondo intero.
Se aumenti lo zoom sull'interazione con il clic, vedrai che vengono effettivamente chiamate due funzioni diverse come risultato dell'evento click.
Come previsto, la prima (l'aggiornamento della UI) viene eseguita in modo incredibilmente rapido, mentre la seconda richiede un secondo intero. Tuttavia, la somma dei loro effetti si traduce nella stessa interazione lenta per l'utente finale.

Traccia delle prestazioni: diversi tipi di eventi
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
});
button.addEventListener('pointerup', () => {
blockFor(1000);
});
Questi risultati sono molto simili. L'interazione dura ancora un secondo intero; l'unica differenza è che il listener click più breve, che aggiorna solo l'interfaccia utente, ora viene eseguito dopo il listener pointerup bloccante.

Traccia delle prestazioni: nessun aggiornamento della UI
Visualizza il codice completo: no_ui.html
button.addEventListener('click', () => {
blockFor(1000);
// score.incrementAndUpdateUI();
});
- Il punteggio non si aggiorna, ma la pagina sì.
- Animazioni, effetti CSS, azioni predefinite dei componenti web (input del modulo), inserimento di testo ed evidenziazione del testo continuano ad aggiornarsi.
In questo caso, il pulsante passa a uno stato attivo e torna indietro quando viene fatto clic, il che richiede un paint da parte del browser, il che significa che esiste ancora un INP.
Poiché il listener di eventi ha bloccato il thread principale per un secondo impedendo la visualizzazione della pagina, l'interazione richiede comunque un secondo intero.
Se si registra il pannello Prestazioni, l'interazione è praticamente identica a quelle precedenti.

Concetti chiave
Qualsiasi codice in esecuzione in qualsiasi listener di eventi ritarderà l'interazione.
- Sono inclusi i listener registrati da script diversi e il codice di framework o librerie eseguito nei listener, ad esempio un aggiornamento dello stato che attiva il rendering di un componente.
- Non solo il tuo codice, ma anche tutti gli script di terze parti.
È un problema comune.
Infine, il fatto che il tuo codice non attivi un paint non significa che un paint non attenderà il completamento di listener di eventi lenti.
7. Esperimento: ritardo input
E per quanto riguarda il codice a esecuzione prolungata al di fuori dei listener di eventi? Ad esempio:
- Se hai un
<script>con caricamento ritardato che blocca in modo casuale la pagina durante il caricamento. - Una chiamata API, ad esempio
setInterval, che blocca periodicamente la pagina?
Prova a rimuovere blockFor dal listener di eventi e ad aggiungerlo a setInterval():
Visualizza il codice completo: input_delay.html
setInterval(() => {
blockFor(1000);
}, 3000);
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
});
Che cosa succede?
8. Risultati dell'esperimento sul ritardo input
Visualizza il codice completo: input_delay.html
setInterval(() => {
blockFor(1000);
}, 3000);
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
});
La registrazione di un clic su un pulsante che si verifica mentre l'attività di blocco setInterval è in esecuzione genera un'interazione di lunga durata, anche se non viene eseguita alcuna attività di blocco nell'interazione stessa.
Questi periodi di esecuzione prolungata sono spesso chiamati attività lunghe.
Se passi il mouse sopra l'interazione in DevTools, vedrai che il tempo di interazione è ora attribuito principalmente al ritardo di input, non alla durata dell'elaborazione.

Tieni presente che non influisce sempre sulle interazioni. Se non fai clic mentre l'attività è in esecuzione, potresti avere fortuna. Questi starnuti "casuali" possono essere un incubo da correggere quando causano problemi solo a volte.
Un modo per individuarli è misurare le attività lunghe (o i frame dell'animazione lunghi) e il Total Blocking Time.
9. Presentazione lenta
Finora abbiamo esaminato le prestazioni di JavaScript tramite il ritardo di input o i listener di eventi, ma cos'altro influisce sul rendering del prossimo paint?
Beh, aggiornando la pagina con effetti costosi.
Anche se l'aggiornamento della pagina avviene rapidamente, il browser potrebbe comunque dover lavorare molto per eseguire il rendering.
Nel thread principale:
- Framework UI che devono eseguire il rendering degli aggiornamenti dopo le modifiche dello stato
- Le modifiche al DOM o l'attivazione/disattivazione di molti selettori di query CSS costosi possono attivare molti elementi di stile, layout e visualizzazione.
Al di fuori del thread principale:
- Utilizzo di CSS per potenziare gli effetti della GPU
- Aggiunta di immagini ad alta risoluzione molto grandi
- Utilizzo di SVG/Canvas per disegnare scene complesse

Ecco alcuni esempi che si trovano comunemente sul web:
- Un sito SPA che ricrea l'intero DOM dopo aver fatto clic su un link, senza fare una pausa per fornire un feedback visivo iniziale.
- Una pagina di ricerca che offre filtri di ricerca complessi con un'interfaccia utente dinamica, ma che esegue listener costosi per farlo.
- Un pulsante di attivazione/disattivazione della modalità Buio che attiva lo stile/il layout per l'intera pagina
10. Esperimento: ritardo presentazione
Dispositivo requestAnimationFrame lento
Simuliamo un lungo ritardo di presentazione utilizzando l'API requestAnimationFrame().
Sposta la chiamata blockFor in un callback requestAnimationFrame in modo che venga eseguita dopo la restituzione del listener di eventi:
Visualizza il codice completo: presentation_delay.html
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
requestAnimationFrame(() => {
blockFor(1000);
});
});
Che cosa succede?
11. Risultati dell'esperimento sul ritardo della presentazione
Visualizza il codice completo: presentation_delay.html
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
requestAnimationFrame(() => {
blockFor(1000);
});
});
L'interazione rimane di un secondo, quindi cosa è successo?
requestAnimationFrame richiede un callback prima del paint successivo. Poiché INP misura il tempo che intercorre tra l'interazione e il paint successivo, il blockFor(1000) nel requestAnimationFrame continua a bloccare il paint successivo per un secondo intero.

Tuttavia, tieni presente due cose:
- Al passaggio del mouse, vedrai che tutto il tempo di interazione viene ora impiegato nel "ritardo di presentazione", poiché il blocco del thread principale avviene dopo il ritorno del listener di eventi.
- La radice dell'attività del thread principale non è più l'evento di clic, ma "Frame di animazione attivato".
12. Diagnosi delle interazioni
In questa pagina di test, la reattività è molto visibile, con i punteggi, i timer e l'interfaccia utente del contatore, ma quando si testa la pagina media è più sottile.
Quando le interazioni si protraggono, non è sempre chiaro quale sia la causa. È:
- Ritardo input?
- Durata dell'elaborazione degli eventi?
- Ritardo presentazione?
In qualsiasi pagina, puoi utilizzare DevTools per misurare la reattività. Per acquisire l'abitudine, prova questo flusso:
- Naviga sul web come faresti normalmente.
- Tieni d'occhio il log delle interazioni nella visualizzazione delle metriche in tempo reale del riquadro Prestazioni di DevTools.
- Se vedi un'interazione con un rendimento scarso, prova a ripeterla:
- Se non riesci a ripeterlo, utilizza il log delle interazioni per ottenere insight.
- Se riesci a ripeterlo, registra una traccia nel riquadro Prestazioni.
Tutti i ritardi
Prova ad aggiungere un po' di tutti questi problemi alla pagina:
Visualizza il codice completo: all_the_things.html
setInterval(() => {
blockFor(1000);
}, 3000);
button.addEventListener('click', () => {
blockFor(1000);
score.incrementAndUpdateUI();
requestAnimationFrame(() => {
blockFor(1000);
});
});
Poi utilizza la console e il riquadro Prestazioni per diagnosticare i problemi.
13. Esperimento: lavoro asincrono
Poiché puoi avviare effetti non visivi all'interno delle interazioni, ad esempio effettuare richieste di rete, avviare timer o semplicemente aggiornare lo stato globale, cosa succede quando questi alla fine aggiornano la pagina?
Se il paint successivo dopo un'interazione può essere visualizzato, anche se il browser decide che non è necessario un nuovo aggiornamento del rendering, la misurazione dell'interazione si interrompe.
Per provare, continua ad aggiornare la UI dal click listener, ma esegui il lavoro di blocco dal timeout.
Visualizza il codice completo: timeout_100.html
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
setTimeout(() => {
blockFor(1000);
}, 100);
});
Cosa succede ora?
14. Risultati dell'esperimento sul lavoro asincrono
Visualizza il codice completo: timeout_100.html
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
setTimeout(() => {
blockFor(1000);
}, 100);
});

Ora l'interazione è breve perché il thread principale è disponibile immediatamente dopo l'aggiornamento della UI. L'attività di blocco lunga viene comunque eseguita, ma solo dopo il paint, in modo che l'utente riceva un feedback immediato sulla UI.
Lezione: se non puoi rimuoverlo, almeno spostalo!
Metodi
Possiamo fare di meglio di un setTimeout fisso di 100 millisecondi? Probabilmente vogliamo comunque che il codice venga eseguito il più rapidamente possibile, altrimenti l'avremmo semplicemente rimosso.
Obiettivo:
- L'interazione eseguirà
incrementAndUpdateUI(). blockFor()verrà eseguito il prima possibile, ma non bloccherà il paint successivo.- In questo modo, il comportamento è prevedibile senza "timeout magici".
Ecco alcuni modi per farlo:
setTimeout(0)Promise.then()requestAnimationFramerequestIdleCallbackscheduler.postTask()
"requestPostAnimationFrame"
A differenza di requestAnimationFrame da solo (che tenterà di essere eseguito prima del paint successivo e di solito renderà comunque l'interazione lenta), requestAnimationFrame + setTimeout costituisce un semplice polyfill per requestPostAnimationFrame, eseguendo il callback dopo il paint successivo.
Visualizza il codice completo: raf+task.html
function afterNextPaint(callback) {
requestAnimationFrame(() => {
setTimeout(callback, 0);
});
}
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
afterNextPaint(() => {
blockFor(1000);
});
});
Per l'ergonomia, puoi anche inserirlo in una promise:
Visualizza il codice completo: raf+task2.html
async function nextPaint() {
return new Promise(resolve => afterNextPaint(resolve));
}
button.addEventListener('click', async () => {
score.incrementAndUpdateUI();
await nextPaint();
blockFor(1000);
});
15. Più interazioni (e clic ripetuti)
Spostare il lavoro di blocco lungo può essere utile, ma queste attività lunghe bloccano comunque la pagina, influendo sulle interazioni future, nonché su molte altre animazioni e aggiornamenti della pagina.
Prova di nuovo la versione della pagina con il lavoro asincrono bloccante (o la tua versione, se hai ideato una tua variante per il rinvio del lavoro nell'ultimo passaggio):
Visualizza il codice completo: timeout_100.html
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
setTimeout(() => {
blockFor(1000);
}, 100);
});
Cosa succede se fai clic più volte rapidamente?
Traccia di rendimento
Per ogni clic, viene messa in coda un'attività di un secondo, garantendo che il thread principale venga bloccato per un periodo di tempo significativo.

Quando queste attività lunghe si sovrappongono ai nuovi clic in arrivo, le interazioni risultano lente, anche se il listener di eventi stesso restituisce quasi immediatamente. Abbiamo creato la stessa situazione dell'esperimento precedente con i ritardi di input. Solo che questa volta il ritardo di input non proviene da un setInterval, ma dal lavoro attivato da listener di eventi precedenti.
Strategie
Idealmente, vogliamo rimuovere completamente le attività lunghe.
- Rimuovi completamente il codice non necessario, in particolare gli script.
- Ottimizza il codice per evitare di eseguire attività lunghe.
- Interrompi il lavoro non aggiornato quando arrivano nuove interazioni.
16. Strategia 1: debounce
Una strategia classica. Ogni volta che le interazioni si susseguono rapidamente e gli effetti di elaborazione o di rete sono onerosi, ritarda intenzionalmente l'avvio del lavoro in modo da poter annullare e riavviare. Questo pattern è utile per le interfacce utente, ad esempio i campi di completamento automatico.
- Utilizza
setTimeoutper ritardare l'avvio di un lavoro costoso con un timer, ad esempio da 500 a 1000 millisecondi. - Quando lo fai, salva l'ID del timer.
- Se arriva una nuova interazione, annulla il timer precedente utilizzando
clearTimeout.
Visualizza il codice completo: debounce.html
let timer;
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
if (timer) {
clearTimeout(timer);
}
timer = setTimeout(() => {
blockFor(1000);
}, 1000);
});
Traccia di rendimento

Nonostante i clic multipli, viene eseguita una sola attività blockFor, che attende che non ci siano clic per un secondo intero prima di essere eseguita. Per le interazioni che si verificano in sequenza, come la digitazione in un campo di testo o i target degli elementi che dovrebbero ricevere più clic rapidi, questa è una strategia ideale da utilizzare per impostazione predefinita.
17. Strategia 2: interrompi le attività di lunga durata
C'è ancora la sfortunata possibilità che un ulteriore clic arrivi subito dopo il periodo di debounce, si trovi nel mezzo di questa attività lunga e diventi un'interazione molto lenta a causa del ritardo di input.
Idealmente, se un'interazione avviene nel mezzo della nostra attività, vogliamo mettere in pausa il nostro lavoro in modo che le nuove interazioni vengano gestite immediatamente. Come possiamo farlo?
Esistono alcune API come isInputPending, ma in genere è meglio suddividere le attività lunghe in blocchi.
Tanti setTimeout
Primo tentativo: fai qualcosa di semplice.
Visualizza il codice completo: small_tasks.html
button.addEventListener('click', () => {
score.incrementAndUpdateUI();
requestAnimationFrame(() => {
setTimeout(() => blockFor(100), 0);
setTimeout(() => blockFor(100), 0);
setTimeout(() => blockFor(100), 0);
setTimeout(() => blockFor(100), 0);
setTimeout(() => blockFor(100), 0);
setTimeout(() => blockFor(100), 0);
setTimeout(() => blockFor(100), 0);
setTimeout(() => blockFor(100), 0);
setTimeout(() => blockFor(100), 0);
setTimeout(() => blockFor(100), 0);
});
});
In questo modo, il browser può pianificare ogni attività singolarmente e l'input può avere una priorità più alta.

Siamo tornati a un totale di cinque secondi di lavoro per cinque clic, ma ogni attività di un secondo per clic è stata suddivisa in dieci attività da 100 millisecondi. Di conseguenza, anche se più interazioni si sovrappongono a queste attività, nessuna interazione ha un ritardo di input superiore a 100 millisecondi. Il browser dà la priorità ai listener di eventi in arrivo rispetto al lavoro di setTimeout e le interazioni rimangono reattive.
Questa strategia funziona particolarmente bene quando si pianificano punti di ingresso separati, ad esempio se hai un gruppo di funzionalità indipendenti che devi chiamare al momento del caricamento dell'applicazione. Il semplice caricamento degli script e l'esecuzione di tutto al momento della valutazione degli script potrebbe eseguire tutto in un'attività lunga per impostazione predefinita.
Tuttavia, questa strategia non funziona altrettanto bene per suddividere il codice ad alto accoppiamento, come un ciclo for che utilizza lo stato condiviso.
Ora con yield()
Tuttavia, possiamo sfruttare le moderne funzionalità async e await per aggiungere facilmente "punti di snervamento" a qualsiasi funzione JavaScript.
Ad esempio:
Visualizza il codice completo: yieldy.html
// Polyfill for scheduler.yield()
async function schedulerDotYield() {
return new Promise(resolve => {
setTimeout(resolve, 0);
});
}
async function blockInPiecesYieldy(ms) {
const ms_per_part = 10;
const parts = ms / ms_per_part;
for (let i = 0; i < parts; i++) {
await schedulerDotYield();
blockFor(ms_per_part);
}
}
button.addEventListener('click', async () => {
score.incrementAndUpdateUI();
await blockInPiecesYieldy(1000);
});
Come prima, il thread principale viene ceduto dopo una parte di lavoro e il browser è in grado di rispondere a qualsiasi interazione in arrivo, ma ora è sufficiente un await schedulerDotYield() anziché setTimeout separati, il che lo rende abbastanza ergonomico da essere utilizzato anche nel mezzo di un ciclo for.
Ora con AbortContoller()
Questo approccio funziona, ma ogni interazione pianifica un nuovo lavoro, anche se sono arrivate nuove interazioni che potrebbero aver modificato il lavoro da svolgere.
Con la strategia di debouncing, abbiamo annullato il timeout precedente a ogni nuova interazione. Possiamo fare qualcosa di simile qui? Un modo per farlo è utilizzare un AbortController():
Visualizza il codice completo: aborty.html
// Polyfill for scheduler.yield()
async function schedulerDotYield() {
return new Promise(resolve => {
setTimeout(resolve, 0);
});
}
async function blockInPiecesYieldyAborty(ms, signal) {
const parts = ms / 10;
for (let i = 0; i < parts; i++) {
// If AbortController has been asked to stop, abandon the current loop.
if (signal.aborted) return;
await schedulerDotYield();
blockFor(10);
}
}
let abortController = new AbortController();
button.addEventListener('click', async () => {
score.incrementAndUpdateUI();
abortController.abort();
abortController = new AbortController();
await blockInPiecesYieldyAborty(1000, abortController.signal);
});
Quando viene ricevuto un clic, viene avviato il loop blockInPiecesYieldyAborty for che esegue il lavoro necessario, cedendo periodicamente il thread principale in modo che il browser rimanga reattivo alle nuove interazioni.
Quando viene ricevuto un secondo clic, il primo loop viene contrassegnato come annullato con AbortController e viene avviato un nuovo loop blockInPiecesYieldyAborty. La volta successiva che il primo loop è pianificato per l'esecuzione, rileva che signal.aborted è ora true e restituisce immediatamente il risultato senza eseguire ulteriori operazioni.

18. Conclusione
La suddivisione di tutte le attività lunghe consente a un sito di essere reattivo alle nuove interazioni. In questo modo puoi fornire rapidamente un feedback iniziale e prendere decisioni, ad esempio interrompere il lavoro in corso. A volte questo significa pianificare i punti di ingresso come attività separate. A volte questo significa aggiungere punti "Dare la precedenza" dove opportuno.
Ricorda
- INP misura tutte le interazioni.
- Ogni interazione viene misurata dall'input al successivo paint, ovvero il modo in cui l'utente percepisce la reattività.
- Il ritardo di input, la durata dell'elaborazione degli eventi e il ritardo di presentazione influiscono tutti sulla reattività delle interazioni.
- Puoi misurare facilmente l'INP e le suddivisioni delle interazioni con DevTools.
Strategie
- Non avere codice con tempi di esecuzione lunghi (attività lunghe) nelle tue pagine.
- Sposta il codice non necessario dai listener di eventi fino alla visualizzazione successiva.
- Assicurati che l'aggiornamento del rendering sia efficiente per il browser.