Suddivisione del codice con React.lazy e Suspense

Non devi mai inviare ai tuoi utenti più codice del necessario, quindi suddividi i tuoi bundle per assicurarti che ciò non accada mai.

Il metodo React.lazy semplifica la suddivisione del codice di un'applicazione React a livello di componente utilizzando le importazioni dinamiche.

import React, { lazy } from 'react';

const AvatarComponent = lazy(() => import('./AvatarComponent'));

const DetailsComponent = () => (
  <div>
    <AvatarComponent />
  </div>
)

Perché è utile?

Un'applicazione React di grandi dimensioni è solitamente costituita da molti componenti, metodi di utilità e librerie di terze parti. Se non si cerca di caricare parti diverse di un'applicazione solo quando sono necessarie, un unico bundle di JavaScript di grandi dimensioni verrà inviato agli utenti non appena caricano la prima pagina. Questo può influire notevolmente sulle prestazioni della pagina.

La funzione React.lazy offre un modo integrato per separare i componenti di un'applicazione in blocchi separati di JavaScript con un lavoro minimo. Puoi quindi gestire gli stati di caricamento quando lo accoppi al componente Suspense.

Thriller

Il problema dell'invio di un payload JavaScript di grandi dimensioni agli utenti è il tempo necessario per il caricamento della pagina, soprattutto su dispositivi e connessioni di rete più lenti. Ecco perché la suddivisione del codice e il caricamento lento sono estremamente utili.

Tuttavia, ci sarà sempre un leggero ritardo che gli utenti dovranno sperimentare quando un componente con suddivisione del codice viene recuperato sulla rete, quindi è importante mostrare uno stato di caricamento utile. L'utilizzo di React.lazy con il componente Suspense aiuta a risolvere questo problema.

import React, { lazy, Suspense } from 'react';

const AvatarComponent = lazy(() => import('./AvatarComponent'));

const renderLoader = () => <p>Loading</p>;

const DetailsComponent = () => (
  <Suspense fallback={renderLoader()}>
    <AvatarComponent />
  </Suspense>
)

Suspense accetta un componente fallback che ti consente di visualizzare qualsiasi componente React come stato di caricamento. Il seguente esempio mostra come funziona. Il rendering dell'avatar viene eseguito solo quando si fa clic sul pulsante, dopodiché viene effettuata una richiesta per recuperare il codice necessario per il AvatarComponent sospeso. Nel frattempo, viene mostrato il componente di caricamento di riserva.

In questo caso, il codice che compone AvatarComponent è di piccole dimensioni, motivo per cui l'indicatore di caricamento viene visualizzato solo per un breve periodo di tempo. I componenti più grandi possono richiedere molto più tempo per il caricamento, soprattutto con connessioni di rete deboli.

Per dimostrare meglio come funziona:

  • Per visualizzare l'anteprima del sito, premi Visualizza app, quindi premi Schermo intero schermo intero.
  • Premi "Ctrl+Maiusc+J" (o "Cmd+Opzione+J" su Mac) per aprire DevTools.
  • Fai clic sulla scheda Rete.
  • Fai clic sul menu a discesa Limitazione, che per impostazione predefinita è impostato su Nessuna limitazione. Seleziona 3G veloce.
  • Fai clic sul pulsante Fai clic qui nell'app.

L'indicatore di caricamento verrà visualizzato più a lungo. Nota come tutto il codice che compone AvatarComponent viene recuperato come un blocco separato.

Riquadro Rete di DevTools che mostra il download di un file chunk.js

Sospensione di più componenti

Un'altra funzionalità di Suspense è che ti consente di sospendere il caricamento di più componenti, anche se sono tutti caricati in modalità caricamento lento.

Ad esempio:

import React, { lazy, Suspense } from 'react';

const AvatarComponent = lazy(() => import('./AvatarComponent'));
const InfoComponent = lazy(() => import('./InfoComponent'));
const MoreInfoComponent = lazy(() => import('./MoreInfoComponent'));

const renderLoader = () => <p>Loading</p>;

const DetailsComponent = () => (
  <Suspense fallback={renderLoader()}>
    <AvatarComponent />
    <InfoComponent />
    <MoreInfoComponent />
  </Suspense>
)

Questo è un modo estremamente utile per ritardare il rendering di più componenti mostrando al contempo un singolo stato di caricamento. Una volta completato il recupero di tutti i componenti, l'utente li vede tutti visualizzati contemporaneamente.

Puoi vederlo con il seguente codice di incorporamento:

Senza questo, è facile riscontrare il problema del caricamento scaglionato o di diverse parti di una UI che si caricano una dopo l'altra, ognuna con il proprio indicatore di caricamento. Questo può rendere l'esperienza utente più fastidiosa.

Gestisci gli errori di caricamento

Suspense ti consente di visualizzare uno stato di caricamento temporaneo mentre le richieste di rete vengono eseguite in background. Ma cosa succede se queste richieste di rete non vanno a buon fine per qualche motivo? Potresti essere offline o forse la tua app web sta tentando di eseguire il caricamento lento di un URL con versione non aggiornato e non più disponibile in seguito a un nuovo deployment del server.

React ha un pattern standard per gestire correttamente questi tipi di errori di caricamento: l'utilizzo di un limite di errore. Come descritto nella documentazione, qualsiasi componente React può fungere da error boundary se implementa uno (o entrambi) i metodi del ciclo di vita static getDerivedStateFromError() o componentDidCatch().

Per rilevare e gestire gli errori di caricamento lento, puoi racchiudere il componente Suspense in un componente principale che funge da limite di errore. All'interno del metodo render() del confine di errore, puoi eseguire il rendering dei componenti secondari così come sono se non si verifica alcun errore o eseguire il rendering di un messaggio di errore personalizzato se qualcosa va storto:

import React, { lazy, Suspense } from 'react';

const AvatarComponent = lazy(() => import('./AvatarComponent'));
const InfoComponent = lazy(() => import('./InfoComponent'));
const MoreInfoComponent = lazy(() => import('./MoreInfoComponent'));

const renderLoader = () => <p>Loading</p>;

class ErrorBoundary extends React.Component {
  constructor(props) {
    super(props);
    this.state = {hasError: false};
  }

  static getDerivedStateFromError(error) {
    return {hasError: true};
  }

  render() {
    if (this.state.hasError) {
      return <p>Loading failed! Please reload.</p>;
    }

    return this.props.children;
  }
}

const DetailsComponent = () => (
  <ErrorBoundary>
    <Suspense fallback={renderLoader()}>
      <AvatarComponent />
      <InfoComponent />
      <MoreInfoComponent />
    </Suspense>
  </ErrorBoundary>
)

Conclusione

Se non sai da dove iniziare ad applicare la suddivisione del codice alla tua applicazione React, segui questi passaggi:

  1. Inizia a livello di percorso. Le route sono il modo più semplice per identificare i punti della tua applicazione che possono essere suddivisi. La documentazione di React mostra come utilizzare Suspense insieme a react-router.
  2. Identifica i componenti di grandi dimensioni in una pagina del tuo sito che vengono visualizzati solo in seguito a determinate interazioni dell'utente (ad esempio il clic su un pulsante). La suddivisione di questi componenti ridurrà al minimo i payload JavaScript.
  3. Valuta la possibilità di suddividere tutto ciò che è fuori schermo e non è fondamentale per l'utente.