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

Tässä esimerkissä, jos fetchUser-funktio aiheuttaa virheen (esim. 404-tila), ErrorBoundary-komponentti sieppaa virheen ja näyttää varaliittymän. Varasijana voi olla mikä tahansa React-komponentti, kuten virheilmoitus tai yritä uudelleen -painike.

use:-hookin edistyneet tekniikat

1. Resurssien välimuistiin tallentaminen

Voit välttää tarpeettoman hakemisen tallentamalla resurssin (Promise) välimuistiin ja käyttämällä sitä uudelleen useissa komponenteissa tai renderöinneissä. Tämä optimointi on kriittinen suorituskyvylle.

            
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;

Tässä esimerkissä:

2. use:-hookin käyttö palvelinkomponenteilla

use:-hook on erityisen hyödyllinen React Server -komponenteissa, joissa tiedonhaku voidaan suorittaa suoraan palvelimella. Tämä johtaa nopeampaan alkuperäiseen sivun lataukseen ja parantaa SEO:ta.

Esimerkki Next.js Server -komponentilla

            
// app/user/[id]/page.jsx (Palvelinkomponentti Next.js:ssä)
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}

); }

Tässä Next.js-palvelinkomponentissa fetchUser-funktio hakee käyttäjätiedot palvelimelta. use:-hook keskeyttää komponentin, kunnes tiedot ovat saatavilla, mikä mahdollistaa tehokkaan palvelinpuolen renderöinnin.

Parhaat käytännöt use:-hookille

Reaali elämän esimerkkejä

1. Verkkokaupan tuoteluettelo

Kuvittele verkkokauppa, joka näyttää tuoteluetteloita. Jokainen tuotekortti voi käyttää use:-hookia hakemaan tuotetietoja:

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

Tämä lähestymistapa varmistaa, että jokainen tuotekortti latautuu itsenäisesti, eikä hitaasti latautuvien tuotteiden pitäisi estää sivun yleistä renderöintiä. Käyttäjä näkee kunkin tuotteen yksittäiset latausindikaattorit, mikä tarjoaa paremman kokemuksen.

2. Sosiaalisen median syöte

Sosiaalisen median syöte voi käyttää use:-hookia hakemaan käyttäjäprofiileja, julkaisuja ja kommentteja:

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

Tämä esimerkki käyttää sisäkkäisiä Suspense-rajoja lataamaan postauksen sisällön ja kommentit itsenäisesti. Käyttäjä voi nähdä postauksen sisällön, kun kommentit vielä latautuvat.

Yleisiä sudenkuoppia ja niiden välttäminen

Vaihtoehtoja use:-hookille

Vaikka use:-hook tarjoaa merkittäviä etuja, on olemassa vaihtoehtoisia tapoja tiedonhakuun Reactissa:

Valinta näiden vaihtoehtojen välillä riippuu sovelluksesi monimutkaisuudesta ja erityisvaatimuksistasi. Yksinkertaisissa tiedonhakuskenaarioissa use: voi olla hyvä vaihtoehto. Monimutkaisemmissa skenaarioissa kirjastot, kuten useSWR tai React Query, saattavat olla sopivampia.

Johtopäätös

Reactin use:-hook tarjoaa tehokkaan ja deklaratiivisen tavan käsitellä resurssien latausta ja tiedonhakua. Hyödyntämällä use:-hookia Suspense-ominaisuuden kanssa voit yksinkertaistaa komponenttilogiikkaa, parantaa käyttökokemusta ja optimoida suorituskykyä. Tämä opas on käsitellyt use:-hookin käytön perusteet, edistyneet tekniikat ja parhaat käytännöt React-sovelluksissasi. Noudattamalla näitä ohjeita voit tehokkaasti hallita asynkronisia toimintoja ja rakentaa luotettavia, tehokkaita ja käyttäjäystävällisiä sovelluksia. Kun React jatkaa kehittymistään, use:-hookin kaltaisten tekniikoiden hallitseminen on välttämätöntä pysyä eteenpäin ja tarjota poikkeuksellisia käyttökokemuksia.

Resurssit