A React use: Resource Hook: Átfogó Útmutató | MLOG | MLOG}> {/* Feltételezve, hogy ez az azonosító nem létezik, és hibát fog okozni */} ); } export default App;

Ebben a példában, ha a fetchUser függvény hibát dob (pl. 404-es státusz miatt), az ErrorBoundary komponens elkapja a hibát és megjeleníti a fallback UI-t. A fallback bármilyen React komponens lehet, például egy hibaüzenet vagy egy újrapróbálkozás gomb.

Haladó technikák a use: használatával

1. Erőforrások gyorsítótárazása

A felesleges lekérések elkerülése érdekében gyorsítótárazhatja az erőforrást (Promise-t), és újra felhasználhatja azt több komponensben vagy renderelés során. Ez az optimalizálás kulcsfontosságú a teljesítmény szempontjából.

            
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 ( Felhasználói adatok betöltése...
}> ); } export default App;

Ebben a példában:

2. A use: használata szerver oldali komponensekkel

A use: hook különösen hasznos a React szerver oldali komponensekben (Server Components), ahol az adatlekérés közvetlenül a szerveren végezhető el. Ez gyorsabb kezdeti oldalbetöltést és jobb SEO-t eredményez.

Példa Next.js szerver oldali komponenssel

            
// app/user/[id]/page.jsx (Szerver oldali komponens a Next.js-ben)
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}

); }

Ebben a Next.js szerver oldali komponensben a fetchUser függvény a szerveren kéri le a felhasználói adatokat. A use: hook felfüggeszti a komponenst, amíg az adatok rendelkezésre nem állnak, lehetővé téve a hatékony szerver oldali renderelést.

A use: legjobb gyakorlatai

Valós példák

1. E-kereskedelmi terméklista

Képzeljen el egy e-kereskedelmi weboldalt, amely terméklistákat jelenít meg. Minden termékkártya használhatja a use:-t a termék részleteinek lekérésére:

            
// 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) => ( Termék betöltése...
}> ))}
); } export default ProductList;

Ez a megközelítés biztosítja, hogy minden termékkártya egymástól függetlenül töltődjön be, és az oldal általános renderelését nem blokkolják a lassan betöltődő termékek. A felhasználó minden termékhez külön betöltésjelzőt lát, ami jobb élményt nyújt.

2. Közösségi média hírfolyam

Egy közösségi média hírfolyam használhatja a use:-t a felhasználói profilok, bejegyzések és hozzászólások lekérésére:

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

Hozzászólások betöltése...
}>
); } export default Post;

Ez a példa beágyazott Suspense határokat használ a bejegyzés tartalmának és a hozzászólásoknak a független betöltéséhez. A felhasználó láthatja a bejegyzés tartalmát, miközben a hozzászólások még töltődnek.

Gyakori buktatók és elkerülésük

A use: alternatívái

Bár a use: jelentős előnyöket kínál, léteznek alternatív megközelítések az adatlekérésre a Reactben:

Ezen alternatívák közötti választás az alkalmazás bonyolultságától és a konkrét követelményektől függ. Egyszerű adatlekérési forgatókönyvek esetén a use: remek választás lehet. Bonyolultabb esetekben az olyan könyvtárak, mint a useSWR vagy a React Query, megfelelőbbek lehetnek.

Összegzés

A React use: hookja egy hatékony és deklaratív módszert kínál az erőforrások betöltésének és az adatlekérésnek a kezelésére. A use: és a Suspense együttes használatával egyszerűsítheti a komponens logikáját, javíthatja a felhasználói élményt és optimalizálhatja a teljesítményt. Ez az útmutató bemutatta a use: használatának alapjait, haladó technikáit és legjobb gyakorlatait a React alkalmazásokban. Ezen irányelvek követésével hatékonyan kezelheti az aszinkron műveleteket, és robusztus, nagy teljesítményű és felhasználóbarát alkalmazásokat építhet. Ahogy a React folyamatosan fejlődik, az olyan technikák elsajátítása, mint a use:, elengedhetetlenné válik ahhoz, hogy naprakész maradjon és kivételes felhasználói élményt nyújtson.

Források