Informazioni sull'interazione con Next Paint (INP)

1. Introduzione

Una demo interattiva e un codelab per scoprire di più su Interaction to Next Paint (INP).

Un diagramma che mostra un'interazione sul thread principale. L'utente esegue un input mentre vengono eseguite attività di blocco. L'input viene ritardato fino al completamento di queste attività, dopodiché vengono eseguiti i listener di eventi pointerup, mouseup e evento di clic, quindi vengono avviate le operazioni di rendering e painting fino alla presentazione del frame successivo

Prerequisiti

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.

  1. Clona il repository nel terminale: git clone https://github.com/GoogleChromeLabs/web-vitals-codelabs.git
  2. Vai alla directory clonata: cd web-vitals-codelabs/understanding-inp
  3. Installa le dipendenze: npm ci
  4. Avvia il server web: npm run start
  5. 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à.

Uno screenshot dell'app demo per questo codelab

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.

Uno screenshot del riquadro Prestazioni di DevTools accanto all'app

Poi, acquisisci un'interazione nel riquadro Prestazioni.

  1. Premi il pulsante per registrare.
  2. Interagisci con la pagina (premi il pulsante Incrementa).
  3. Interrompi la registrazione.

Nella sequenza temporale risultante, troverai una traccia Interazioni. Espandila facendo clic sul triangolo a sinistra.

Una dimostrazione animata della registrazione di un'interazione utilizzando il riquadro Prestazioni di DevTools

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

Uno screenshot del riquadro Prestazioni di DevTools, con il cursore posizionato sopra l'interazione nel riquadro e un tooltip che elenca la breve durata dell'interazione

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.

Un'interazione di un secondo nel riquadro Prestazioni

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.

Un'interazione di un secondo nel riquadro Prestazioni

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.

Un'immagine ingrandita dell'interazione di un secondo in questo esempio, che mostra che la prima chiamata di funzione richiede meno di un millisecondo per essere completata

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.

Una visualizzazione ingrandita dell'interazione di un secondo in questo esempio, che mostra che il listener di eventi di clic impiega meno di un millisecondo per essere completato, dopo il listener pointerup

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.

Un'interazione di un secondo nel riquadro Prestazioni

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.

Il riquadro Prestazioni di DevTools mostra un'attività di blocco di un secondo, un'interazione che si verifica in parte durante l'attività e un'interazione di 642 millisecondi, attribuita principalmente al ritardo di input

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

Schizzo dei diversi elementi del rendering sul web

RenderingNG

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.

Un'interazione di un secondo nel riquadro Prestazioni

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:

  1. Naviga sul web come faresti normalmente.
  2. Tieni d'occhio il log delle interazioni nella visualizzazione delle metriche in tempo reale del riquadro Prestazioni di DevTools.
  3. 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);
});

Un'interazione di 27 millisecondi con un'attività lunga di un secondo che ora si verifica più avanti nella traccia

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()
  • requestAnimationFrame
  • requestIdleCallback
  • scheduler.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.

Più attività lunghe di un secondo nel thread principale, che causano interazioni lente fino a 800 ms

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 setTimeout per 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

Più interazioni, ma una sola attività lunga come risultato di tutte

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.

Più interazioni, ma tutto il lavoro pianificato è stato suddiviso in molte attività più piccole

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.

Il lavoro del thread principale è ora suddiviso in molti piccoli frammenti, le interazioni sono brevi e il lavoro dura solo il tempo necessario

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.

Scopri di più