Codeaufteilung mit React.lazy und Suspense

Sie sollten Ihren Nutzern nie mehr Code als nötig senden. Teilen Sie Ihre Bundles also auf, damit das nicht passiert.

Mit der Methode React.lazy lässt sich eine React-Anwendung mithilfe von dynamischen Importen ganz einfach auf Komponentenebene aufteilen.

import React, { lazy } from 'react';

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

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

Welchen Nutzen bieten sie?

Eine große React-Anwendung besteht in der Regel aus vielen Komponenten, Hilfsmethoden und Drittanbieterbibliotheken. Wenn nicht versucht wird, verschiedene Teile einer Anwendung nur dann zu laden, wenn sie benötigt werden, wird ein einzelnes, großes JavaScript-Bundle an Ihre Nutzer gesendet, sobald sie die erste Seite laden. Dies kann die Seitenleistung erheblich beeinträchtigen.

Die Funktion React.lazy bietet eine integrierte Möglichkeit, Komponenten in einer Anwendung mit sehr wenig Aufwand in separate JavaScript-Blöcke aufzuteilen. In Kombination mit der Komponente Suspense können Sie dann Ladestatus verwalten.

Spannung

Das Problem bei der Bereitstellung einer großen JavaScript-Nutzlast für Nutzer ist die Zeit, die die Seite zum Laden benötigt, insbesondere auf schwächeren Geräten und bei langsameren Netzwerkverbindungen. Deshalb sind Codeaufteilung und Lazy Loading so nützlich.

Es wird jedoch immer eine leichte Verzögerung geben, wenn eine Code-Split-Komponente über das Netzwerk abgerufen wird. Daher ist es wichtig, einen nützlichen Ladestatus anzuzeigen. Dieses Problem lässt sich mit React.lazy und der Komponente Suspense beheben.

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

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

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

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

Suspense akzeptiert eine fallback-Komponente, mit der Sie jede React-Komponente als Ladestatus anzeigen können. Das folgende Beispiel zeigt, wie das funktioniert. Der Avatar wird nur gerendert, wenn auf die Schaltfläche geklickt wird. Dann wird eine Anfrage gestellt, um den Code abzurufen, der für die gesperrte AvatarComponent erforderlich ist. In der Zwischenzeit wird die Fallback-Ladekomponente angezeigt.

Der Code, aus dem AvatarComponent besteht, ist klein, weshalb die Ladeanzeige nur kurz angezeigt wird. Das Laden größerer Komponenten kann viel länger dauern, insbesondere bei schwachen Netzwerkverbindungen.

Hier ein Beispiel, das die Funktionsweise verdeutlicht:

  • Wenn Sie sich eine Vorschau der Website ansehen möchten, klicken Sie auf View App (App ansehen) und dann auf Fullscreen (Vollbild) Vollbild.
  • Drücken Sie „Strg + Umschalttaste + J“ (oder „Befehlstaste + Wahltaste + J“ auf einem Mac), um die Entwicklertools zu öffnen.
  • Klicken Sie auf den Tab Netzwerk.
  • Klicken Sie auf das Drop-down-Menü Drosselung, das standardmäßig auf Keine Drosselung eingestellt ist. Wählen Sie Schnelles 3G aus.
  • Klicken Sie in der App auf den Button Click Me.

Die Ladeanzeige wird jetzt länger angezeigt. Der gesamte Code, aus dem die AvatarComponent besteht, wird als separater Block abgerufen.

Netzwerkbereich der Entwicklertools, in dem eine chunk.js-Datei heruntergeladen wird

Mehrere Komponenten sperren

Ein weiteres Feature von Suspense ist, dass Sie das Laden mehrerer Komponenten aussetzen können, auch wenn sie alle Lazy Loading verwenden.

Beispiel:

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>
)

Dies ist eine äußerst nützliche Methode, um das Rendern mehrerer Komponenten zu verzögern, während nur ein einziger Ladestatus angezeigt wird. Sobald alle Komponenten abgerufen wurden, werden sie dem Nutzer gleichzeitig angezeigt.

Das können Sie sich in der folgenden Einbettung ansehen:

Andernfalls kann es leicht zu einem gestaffelten Laden kommen, bei dem verschiedene Teile einer Benutzeroberfläche nacheinander geladen werden und jeweils eine eigene Ladeanzeige haben. Das kann die Nutzererfahrung beeinträchtigen.

Ladefehler beheben

Mit Suspense können Sie einen temporären Ladestatus anzeigen, während im Hintergrund Netzwerkanfragen gestellt werden. Aber was ist, wenn diese Netzwerkanfragen aus irgendeinem Grund fehlschlagen? Möglicherweise sind Sie offline oder Ihre Webanwendung versucht, eine versionierte URL per Lazy Loading zu laden, die veraltet ist und nach einer erneuten Bereitstellung des Servers nicht mehr verfügbar ist.

React hat ein Standardmuster für den Umgang mit solchen Ladefehlern: die Verwendung einer Fehlergrenze. Wie in der Dokumentation beschrieben, kann jede React-Komponente als Error Boundary dienen, wenn sie eine oder beide der Lebenszyklusmethoden static getDerivedStateFromError() oder componentDidCatch() implementiert.

Wenn Sie Fehler beim Lazy Loading erkennen und beheben möchten, können Sie die Suspense-Komponente in eine übergeordnete Komponente einbinden, die als Fehlergrenze dient. In der Methode render() der Fehlergrenze können Sie die untergeordneten Elemente unverändert rendern, wenn kein Fehler vorliegt, oder eine benutzerdefinierte Fehlermeldung rendern, wenn etwas schiefgeht:

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>
)

Fazit

Wenn Sie nicht sicher sind, wo Sie mit der Anwendung von Codeaufteilung auf Ihre React-Anwendung beginnen sollen, gehen Sie so vor:

  1. Beginnen Sie auf der Routenebene. Routen sind die einfachste Möglichkeit, Punkte in Ihrer Anwendung zu identifizieren, die aufgeteilt werden können. In der React-Dokumentation wird gezeigt, wie Suspense zusammen mit react-router verwendet werden kann.
  2. Identifiziere alle großen Komponenten auf einer Seite deiner Website, die nur bei bestimmten Nutzerinteraktionen gerendert werden (z. B. beim Klicken auf eine Schaltfläche). Durch das Aufteilen dieser Komponenten werden Ihre JavaScript-Nutzlasten minimiert.
  3. Alles andere, was sich außerhalb des Bildschirms befindet und für den Nutzer nicht wichtig ist, sollte aufgeteilt werden.