Vous n'avez jamais besoin d'envoyer plus de code que nécessaire à vos utilisateurs. Divisez donc vos bundles pour vous assurer que cela ne se produise jamais.
La méthode React.lazy permet de diviser facilement le code d'une application React au niveau des composants à l'aide d'importations dynamiques.
import React, { lazy } from 'react';
const AvatarComponent = lazy(() => import('./AvatarComponent'));
const DetailsComponent = () => (
<div>
<AvatarComponent />
</div>
)
En quoi est-ce utile ?
Une application React volumineuse se compose généralement de nombreux composants, méthodes utilitaires et bibliothèques tierces. Si vous n'essayez pas de charger différentes parties d'une application uniquement lorsqu'elles sont nécessaires, un seul bundle JavaScript volumineux sera envoyé à vos utilisateurs dès qu'ils chargeront la première page. Cela peut avoir un impact significatif sur les performances de la page.
La fonction React.lazy permet de séparer les composants d'une application en différents fragments de JavaScript, sans trop d'efforts. Vous pouvez ensuite gérer les états de chargement en l'associant au composant Suspense.
Suspense
Le problème avec l'envoi d'une charge utile JavaScript volumineuse aux utilisateurs est le temps nécessaire au chargement de la page, en particulier sur les appareils et les connexions réseau plus faibles. C'est pourquoi la division du code et le chargement différé sont extrêmement utiles.
Toutefois, les utilisateurs subiront toujours un léger délai lors de la récupération d'un composant fractionné par code sur le réseau. Il est donc important d'afficher un état de chargement utile. L'utilisation de React.lazy avec le composant Suspense permet de résoudre ce problème.
import React, { lazy, Suspense } from 'react';
const AvatarComponent = lazy(() => import('./AvatarComponent'));
const renderLoader = () => <p>Loading</p>;
const DetailsComponent = () => (
<Suspense fallback={renderLoader()}>
<AvatarComponent />
</Suspense>
)
Suspense accepte un composant fallback qui vous permet d'afficher n'importe quel composant React en tant qu'état de chargement. L'exemple suivant montre comment cela fonctionne.
L'avatar n'est affiché que lorsque l'utilisateur clique sur le bouton. Une requête est alors envoyée pour récupérer le code nécessaire au AvatarComponent suspendu.
En attendant, le composant de chargement de remplacement s'affiche.
Ici, le code qui compose AvatarComponent est petit, c'est pourquoi l'icône de chargement ne s'affiche que pendant une courte période. Le chargement des composants plus volumineux peut prendre beaucoup plus de temps, en particulier sur les connexions réseau faibles.
Pour mieux illustrer ce fonctionnement :
- Pour prévisualiser le site, appuyez sur View App (Afficher l'application), puis sur Fullscreen (Plein écran)
.
- Appuyez sur Ctrl+Maj+J (ou Cmd+Option+J sur Mac) pour ouvrir les outils de développement.
- Cliquez sur l'onglet Réseau.
- Cliquez sur le menu déroulant Limitation, qui est défini sur Aucune limitation par défaut. Sélectionnez Fast 3G (3G rapide).
- Cliquez sur le bouton Click Me (Cliquez ici) dans l'application.
L'indicateur de chargement s'affiche désormais plus longtemps. Notez que tout le code qui compose AvatarComponent est récupéré sous la forme d'un fragment distinct.
Suspendre plusieurs composants
Une autre fonctionnalité de Suspense est qu'il vous permet de suspendre le chargement de plusieurs composants, même s'ils sont tous chargés de manière différée.
Exemple :
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>
)
C'est un moyen extrêmement utile de retarder l'affichage de plusieurs composants tout en n'affichant qu'un seul état de chargement. Une fois que tous les composants ont été récupérés, l'utilisateur peut les voir tous affichés en même temps.
Vous pouvez le voir dans l'intégration suivante :
Sans cela, vous risquez de rencontrer un problème de chargement échelonné, ou de voir différentes parties d'une UI se charger l'une après l'autre, chacune avec son propre indicateur de chargement. Cela peut rendre l'expérience utilisateur plus déroutante.
Gérer les échecs de chargement
Suspense vous permet d'afficher un état de chargement temporaire pendant que les requêtes réseau sont effectuées en arrière-plan. Mais que se passe-t-il si ces requêtes réseau échouent pour une raison quelconque ? Vous êtes peut-être hors connexion, ou votre application Web tente peut-être de charger de manière différée une URL versionnée obsolète et qui n'est plus disponible suite à un redéploiement du serveur.
React dispose d'un modèle standard pour gérer correctement ces types d'échecs de chargement : l'utilisation d'une limite d'erreur. Comme décrit dans la documentation, tout composant React peut servir de limite d'erreur s'il implémente l'une des méthodes de cycle de vie static getDerivedStateFromError() ou componentDidCatch() (ou les deux).
Pour détecter et gérer les échecs de chargement différé, vous pouvez encapsuler votre composant Suspense dans un composant parent qui sert de limite d'erreur. Dans la méthode render() de la limite d'erreur, vous pouvez afficher les enfants tels quels s'il n'y a pas d'erreur, ou afficher un message d'erreur personnalisé en cas de problème :
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>
)
Conclusion
Si vous ne savez pas par où commencer pour appliquer la division du code à votre application React, procédez comme suit :
- Commencez au niveau de la route. Les routes sont le moyen le plus simple d'identifier les points de votre application qui peuvent être divisés. La documentation React montre comment utiliser
Suspenseavecreact-router. - Identifiez les composants volumineux d'une page de votre site qui ne s'affichent que lors de certaines interactions de l'utilisateur (par exemple, un clic sur un bouton). La division de ces composants réduira vos charges utiles JavaScript.
- Envisagez de diviser tout autre élément hors écran qui n'est pas essentiel pour l'utilisateur.