Hook `use:` w React: Kompleksowy przewodnik | MLOG | MLOG}> {/* Assuming this ID doesn't exist and will cause an error */} ); } export default App;

W tym przykładzie, jeśli funkcja fetchUser zgłosi błąd (np. z powodu statusu 404), komponent ErrorBoundary przechwyci błąd i wyświetli interfejs zastępczy. Interfejs zastępczy może być dowolnym komponentem Reacta, takim jak komunikat o błędzie lub przycisk ponawiania próby.

Zaawansowane techniki z use:

1. Buforowanie (caching) zasobów

Aby uniknąć zbędnego pobierania, można buforować zasób (Promise) i używać go ponownie w wielu komponentach lub renderowaniach. Ta optymalizacja jest kluczowa dla wydajności.

            
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;

W tym przykładzie:

2. Użycie use: z komponentami serwerowymi

Hook use: jest szczególnie użyteczny w komponentach serwerowych Reacta (React Server Components), gdzie pobieranie danych może być wykonywane bezpośrednio na serwerze. Skutkuje to szybszym początkowym ładowaniem strony i lepszym SEO.

Przykład z komponentem serwerowym 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}

); }

W tym komponencie serwerowym Next.js, funkcja fetchUser pobiera dane użytkownika na serwerze. Hook use: wstrzymuje komponent do czasu, aż dane będą dostępne, co pozwala na wydajne renderowanie po stronie serwera.

Najlepsze praktyki dla use:

Przykłady z życia wzięte

1. Lista produktów w e-commerce

Wyobraź sobie stronę e-commerce wyświetlającą listę produktów. Każda karta produktu może używać use: do pobierania szczegółów produktu:

            
// 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;

Takie podejście zapewnia, że każda karta produktu ładuje się niezależnie, a ogólne renderowanie strony nie jest blokowane przez wolno ładujące się produkty. Użytkownik widzi indywidualne wskaźniki ładowania dla każdego produktu, co zapewnia lepsze doświadczenie.

2. Tablica w mediach społecznościowych

Tablica w mediach społecznościowych może używać use: do pobierania profili użytkowników, postów i komentarzy:

            
// 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;

Ten przykład używa zagnieżdżonych granic Suspense do niezależnego ładowania treści posta i komentarzy. Użytkownik może zobaczyć treść posta, podczas gdy komentarze wciąż się ładują.

Częste pułapki i jak ich unikać

Alternatywy dla use:

Chociaż use: oferuje znaczące korzyści, istnieją alternatywne podejścia do pobierania danych w React:

Wybór między tymi alternatywami zależy od złożoności Twojej aplikacji i konkretnych wymagań. W prostych scenariuszach pobierania danych use: może być świetną opcją. W bardziej złożonych scenariuszach bardziej odpowiednie mogą być biblioteki takie jak useSWR lub React Query.

Podsumowanie

Hook use: w React dostarcza potężny i deklaratywny sposób obsługi ładowania zasobów i pobierania danych. Wykorzystując use: z Suspense, możesz uprościć logikę swoich komponentów, poprawić doświadczenie użytkownika i zoptymalizować wydajność. Ten przewodnik omówił podstawy, zaawansowane techniki i najlepsze praktyki używania use: w aplikacjach React. Postępując zgodnie z tymi wytycznymi, możesz skutecznie zarządzać operacjami asynchronicznymi i budować solidne, wydajne i przyjazne dla użytkownika aplikacje. W miarę jak React ewoluuje, opanowanie technik takich jak use: staje się niezbędne, aby pozostać na czele i dostarczać wyjątkowe doświadczenia użytkownika.

Zasoby