Reacts use: Resource Hook: En Omfattende Guide | MLOG | MLOG}> {/* Assuming this ID doesn't exist and will cause an error */} ); } export default App;

I dette eksempel, hvis fetchUser-funktionen kaster en fejl (f.eks. på grund af en 404-status), vil ErrorBoundary-komponenten fange fejlen og vise fallback-UI'et. Fallback kan være enhver React-komponent, såsom en fejlmeddelelse eller en genforsøg-knap.

Avancerede teknikker med use:

1. Caching af ressourcer

For at undgå overflødig hentning kan du cache ressourcen (Promise) og genbruge den på tværs af flere komponenter eller renders. Denne optimering er afgørende for ydeevnen.

            
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;

I dette eksempel:

2. Brug af use: med Server Components

use: hook'en er særligt nyttig i React Server Components, hvor datahentning kan udføres direkte på serveren. Dette resulterer i hurtigere indlæsningstider for den første side og forbedret SEO.

Eksempel med Next.js Server Component

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

); }

I denne Next.js-serverkomponent henter fetchUser-funktionen brugerdata på serveren. use: hook'en suspenderer komponenten, indtil dataene er tilgængelige, hvilket muliggør effektiv server-side rendering.

Best Practices for use:

Eksempler fra den virkelige verden

1. Produktliste i e-handel

Forestil dig en e-handels-hjemmeside, der viser produktlister. Hvert produktkort kan bruge use: til at hente produktdetaljer:

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

Denne tilgang sikrer, at hvert produktkort indlæses uafhængigt, og den samlede side-rendering blokeres ikke af langsomt indlæsende produkter. Brugeren ser individuelle indlæsningsindikatorer for hvert produkt, hvilket giver en bedre oplevelse.

2. Feed på sociale medier

Et feed på sociale medier kan bruge use: til at hente brugerprofiler, opslag og kommentarer:

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

Dette eksempel bruger indlejrede Suspense-grænser til at indlæse opslagets indhold og kommentarer uafhængigt. Brugeren kan se opslagets indhold, mens kommentarerne stadig indlæses.

Almindelige faldgruber og hvordan man undgår dem

Alternativer til use:

Selvom use: tilbyder betydelige fordele, findes der alternative tilgange til datahentning i React:

Valget mellem disse alternativer afhænger af kompleksiteten af din applikation og dine specifikke krav. For simple datahentningsscenarier kan use: være en fremragende mulighed. For mere komplekse scenarier kan biblioteker som useSWR eller React Query være mere passende.

Konklusion

use: hook'en i React giver en kraftfuld og deklarativ måde at håndtere ressourceindlæsning og datahentning. Ved at udnytte use: med Suspense kan du forenkle din komponentlogik, forbedre brugeroplevelsen og optimere ydeevnen. Denne guide har dækket de grundlæggende principper, avancerede teknikker og best practices for brug af use: i dine React-applikationer. Ved at følge disse retningslinjer kan du effektivt håndtere asynkrone operationer og bygge robuste, performante og brugervenlige applikationer. I takt med at React fortsætter med at udvikle sig, bliver det afgørende at mestre teknikker som use: for at være på forkant og levere exceptionelle brugeroplevelser.

Ressourcer