Le hook `use:` de React : Un guide complet | MLOG | MLOG}> {/* Assuming this ID doesn't exist and will cause an error */} ); } export default App;

Dans cet exemple, si la fonction fetchUser lève une erreur (par exemple, en raison d'un statut 404), le composant ErrorBoundary interceptera l'erreur et affichera l'interface de secours. Le fallback peut être n'importe quel composant React, comme un message d'erreur ou un bouton de réessai.

Techniques avancées avec use:

1. Mise en cache des ressources

Pour éviter les récupérations redondantes, vous pouvez mettre en cache la ressource (la promesse) et la réutiliser à travers plusieurs composants ou rendus. Cette optimisation est cruciale pour les performances.

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

const resourceCache = new Map();

async function fetchUser(id) {
  const response = await fetch(`https://jsonplaceholder.typicode.com/users/${id}`);
  if (!response.ok) {
    throw new Error(`Failed to fetch user: ${response.status}`);
  }
  return response.json();
}

function getUserResource(userId) {
  if (!resourceCache.has(userId)) {
    resourceCache.set(userId, {
      read() {
        if (!this.promise) {
          this.promise = fetchUser(userId);
        }
        if (this.result) {
          return this.result;
        }
        throw this.promise;
      }
    });
  }
  return resourceCache.get(userId);
}

function UserProfile({ userId }) {
  const resource = getUserResource(userId);
  const user = resource.read();

  return (
    

{user.name}

Email: {user.email}

Phone: {user.phone}

); } function App() { return ( Loading user data...
}> ); } export default App;

Dans cet exemple :

2. Utilisation de use: avec les Server Components

Le hook use: est particulièrement utile dans les React Server Components, où la récupération de données peut être effectuée directement sur le serveur. Cela se traduit par des chargements de page initiaux plus rapides et un meilleur SEO.

Exemple avec un Server Component Next.js

            
// app/user/[id]/page.jsx (Server Component in Next.js)
import React from 'react';

async function fetchUser(id) {
  const response = await fetch(`https://jsonplaceholder.typicode.com/users/${id}`);
  if (!response.ok) {
    throw new Error(`Failed to fetch user: ${response.status}`);
  }
  return response.json();
}

export default async function UserPage({ params }) {
  const user = React.use(fetchUser(params.id));

  return (
    

{user.name}

Email: {user.email}

Phone: {user.phone}

); }

Dans ce server component Next.js, la fonction fetchUser récupère les données de l'utilisateur sur le serveur. Le hook use: suspend le composant jusqu'à ce que les données soient disponibles, permettant un rendu côté serveur efficace.

Bonnes pratiques pour use:

Exemples concrets

1. Liste de produits e-commerce

Imaginez un site e-commerce affichant des listes de produits. Chaque fiche produit peut utiliser use: pour récupérer les détails du produit :

            
// ProductCard.jsx
import React, { Suspense } from 'react';

async function fetchProduct(productId) {
  const response = await fetch(`/api/products/${productId}`);
  if (!response.ok) {
    throw new Error(`Failed to fetch product: ${response.status}`);
  }
  return response.json();
}

function ProductCard({ productId }) {
  const product = React.use(fetchProduct(productId));

  return (
    

{product.name}

{product.description}

Price: ${product.price}

); } function ProductList({ productIds }) { return (
{productIds.map((productId) => ( Loading product...
}> ))}
); } export default ProductList;

Cette approche garantit que chaque fiche produit se charge indépendamment, et le rendu global de la page n'est pas bloqué par des produits qui se chargent lentement. L'utilisateur voit des indicateurs de chargement individuels pour chaque produit, offrant une meilleure expérience.

2. Fil d'actualité de réseau social

Un fil d'actualité de réseau social peut utiliser use: pour récupérer les profils d'utilisateurs, les publications et les commentaires :

            
// Post.jsx
import React, { Suspense } from 'react';

async function fetchPost(postId) {
  const response = await fetch(`/api/posts/${postId}`);
  if (!response.ok) {
    throw new Error(`Failed to fetch post: ${response.status}`);
  }
  return response.json();
}

async function fetchComments(postId) {
  const response = await fetch(`/api/posts/${postId}/comments`);
  if (!response.ok) {
    throw new Error(`Failed to fetch comments: ${response.status}`);
  }
  return response.json();
}

function Comments({ postId }) {
  const comments = React.use(fetchComments(postId));

  return (
    
    {comments.map((comment) => (
  • {comment.text}
  • ))}
); } function Post({ postId }) { const post = React.use(fetchPost(postId)); return (

{post.title}

{post.content}

Loading comments...
}>
); } export default Post;

Cet exemple utilise des limites de Suspense imbriquées pour charger le contenu de la publication et les commentaires de manière indépendante. L'utilisateur peut voir le contenu de la publication pendant que les commentaires sont encore en cours de chargement.

Pièges courants et comment les éviter

Alternatives Ă  use:

Bien que use: offre des avantages significatifs, il existe d'autres approches pour la récupération de données dans React :

Le choix entre ces alternatives dépend de la complexité de votre application et de vos besoins spécifiques. Pour des scénarios simples de récupération de données, use: peut être une excellente option. Pour des scénarios plus complexes, des bibliothèques comme useSWR ou React Query peuvent être plus appropriées.

Conclusion

Le hook use: dans React offre une manière puissante et déclarative de gérer le chargement des ressources et la récupération des données. En tirant parti de use: avec Suspense, vous pouvez simplifier la logique de vos composants, améliorer l'expérience utilisateur et optimiser les performances. Ce guide a couvert les principes fondamentaux, les techniques avancées et les bonnes pratiques pour utiliser use: dans vos applications React. En suivant ces directives, vous pouvez gérer efficacement les opérations asynchrones et construire des applications robustes, performantes et conviviales. Alors que React continue d'évoluer, la maîtrise de techniques comme use: devient essentielle pour rester à la pointe et offrir des expériences utilisateur exceptionnelles.

Ressources