React - načítanie dát z API: useEffect, stav načítania a vlastný hook

Takmer každá aplikácia v Reacte potrebuje dáta zo servera. Základ je krátky – useEffect a fetch –, no aby komponent fungoval spoľahlivo, treba vyriešiť aj stav načítania, chyby a situáciu, keď používateľ odíde zo stránky skôr, než odpoveď príde.

V návode postavíme zoznam používateľov s vyhľadávaním a nakoniec celú logiku presunieme do znovupoužiteľného hooku useFetch. Ako testovacie API slúži verejná služba JSONPlaceholder.

Príprava projektu

Nový projekt vytvoríte nástrojom Vite (potrebný je Node.js 18 alebo novší):

npm create vite@latest pouzivatelia -- --template react
cd pouzivatelia
npm install
npm run dev

1. Najjednoduchšia verzia

import { useEffect, useState } from 'react';

export default function Pouzivatelia() {
  const [pouzivatelia, setPouzivatelia] = useState([]);

  useEffect(() => {
    fetch('https://jsonplaceholder.typicode.com/users')
      .then((odpoved) => odpoved.json())
      .then((data) => setPouzivatelia(data));
  }, []);

  return (
    <ul>
      {pouzivatelia.map((p) => (
        <li key={p.id}>{p.name}</li>
      ))}
    </ul>
  );
}

Prázdne pole [] na konci useEffect znamená, že efekt sa spustí iba raz – po prvom vykreslení komponentu. Bez neho by sa dáta načítavali po každom vykreslení a keďže setPouzivatelia spôsobí ďalšie vykreslenie, vznikol by nekonečný cyklus.

Tento kód funguje, ale používateľ nevidí, že sa niečo načítava, a pri chybe sa nezobrazí nič.

2. Stav načítania a chyby

import { useEffect, useState } from 'react';

export default function Pouzivatelia() {
  const [pouzivatelia, setPouzivatelia] = useState([]);
  const [nacitava, setNacitava] = useState(true);
  const [chyba, setChyba] = useState(null);

  useEffect(() => {
    async function nacitaj() {
      try {
        const odpoved = await fetch('https://jsonplaceholder.typicode.com/users');

        if (!odpoved.ok) {
          throw new Error(`Server vrátil chybu ${odpoved.status}`);
        }

        setPouzivatelia(await odpoved.json());
      } catch (e) {
        setChyba(e.message);
      } finally {
        setNacitava(false);
      }
    }

    nacitaj();
  }, []);

  if (nacitava) return <p>Načítavam…</p>;
  if (chyba) return <p className="chyba">Chyba: {chyba}</p>;

  return (
    <ul>
      {pouzivatelia.map((p) => (
        <li key={p.id}>
          <strong>{p.name}</strong> – {p.email}
        </li>
      ))}
    </ul>
  );
}

Dve poznámky:

  • Funkciu odovzdanú do useEffect nemožno označiť ako async – efekt smie vrátiť iba funkciu na upratanie, nie Promise. Preto je asynchrónny kód vo vnútornej funkcii nacitaj.
  • fetch pri odpovedi 404 alebo 500 výnimku nevyhodí, preto kontrolujeme odpoved.ok.

3. Zrušenie požiadavky pri odchode z komponentu

Ak sa komponent odstráni (používateľ prejde na inú stránku) skôr, než odpoveď príde, nastavovať jeho stav už nemá zmysel. Navyše pri rýchlo sa meniacich parametroch môže pomalšia staršia odpoveď prísť až po novšej a prepísať ju. Oboje rieši AbortController a upratovacia funkcia efektu:

useEffect(() => {
  const ovladac = new AbortController();

  async function nacitaj() {
    try {
      const odpoved = await fetch(url, { signal: ovladac.signal });
      if (!odpoved.ok) throw new Error(`Server vrátil chybu ${odpoved.status}`);
      setPouzivatelia(await odpoved.json());
    } catch (e) {
      if (e.name !== 'AbortError') setChyba(e.message);
    } finally {
      if (!ovladac.signal.aborted) setNacitava(false);
    }
  }

  nacitaj();

  return () => ovladac.abort(); // spustí sa pri odstránení komponentu alebo zmene url
}, [url]);

V režime vývoja (StrictMode) React každý efekt zámerne spustí, upratá a spustí znova. V sieťovej karte prehliadača preto uvidíte prvú požiadavku zrušenú – to je v poriadku a práve to overuje, že upratovanie funguje.

4. Vyhľadávanie s oneskorením

Ak sa dotaz posiela pri každom stlačení klávesu, server dostane požiadavku na každé písmeno. Lepšie je počkať, kým používateľ na chvíľu prestane písať (tzv. debounce):

// src/useOneskorenaHodnota.js
import { useEffect, useState } from 'react';

export function useOneskorenaHodnota(hodnota, ms = 400) {
  const [oneskorena, setOneskorena] = useState(hodnota);

  useEffect(() => {
    const casovac = setTimeout(() => setOneskorena(hodnota), ms);
    return () => clearTimeout(casovac);
  }, [hodnota, ms]);

  return oneskorena;
}

Každé nové písmeno zruší predchádzajúci časovač, takže hodnota sa zmení až 400 ms po poslednom stlačení.

5. Vlastný hook useFetch

Stav načítania, chyby a rušenie požiadaviek sa opakuje v každom komponente, ktorý niečo načítava. Patrí preto do vlastného hooku – obyčajnej funkcie, ktorej názov začína na use:

// src/useFetch.js
import { useEffect, useState } from 'react';

export function useFetch(url) {
  const [stav, setStav] = useState({ data: null, nacitava: true, chyba: null });

  useEffect(() => {
    if (!url) return;

    const ovladac = new AbortController();
    setStav((s) => ({ ...s, nacitava: true, chyba: null }));

    fetch(url, { signal: ovladac.signal })
      .then((odpoved) => {
        if (!odpoved.ok) throw new Error(`Server vrátil chybu ${odpoved.status}`);
        return odpoved.json();
      })
      .then((data) => setStav({ data, nacitava: false, chyba: null }))
      .catch((e) => {
        if (e.name !== 'AbortError') {
          setStav({ data: null, nacitava: false, chyba: e.message });
        }
      });

    return () => ovladac.abort();
  }, [url]);

  return stav;
}

Komponent sa potom zmenší na to podstatné:

// src/App.jsx
import { useState } from 'react';
import { useFetch } from './useFetch';
import { useOneskorenaHodnota } from './useOneskorenaHodnota';

export default function App() {
  const [hladanie, setHladanie] = useState('');
  const dotaz = useOneskorenaHodnota(hladanie);
  const parametre = new URLSearchParams(dotaz ? { name_like: dotaz } : {});
  const { data, nacitava, chyba } = useFetch(`https://jsonplaceholder.typicode.com/users?${parametre}`);

  return (
    <main>
      <input
        type="search"
        placeholder="Hľadať podľa mena…"
        value={hladanie}
        onChange={(e) => setHladanie(e.target.value)}
      />

      {nacitava && <p>Načítavam…</p>}
      {chyba && <p className="chyba">Chyba: {chyba}</p>}
      {data && data.length === 0 && <p>Nič sa nenašlo.</p>}

      <ul>
        {data?.map((p) => (
          <li key={p.id}>{p.name}</li>
        ))}
      </ul>
    </main>
  );
}

Parameter name_like je filter služby JSONPlaceholder; vaše API bude mať vlastný.

Kedy siahnuť po knižnici

Hook useFetch stačí pre menšie aplikácie. Ak potrebujete ukladanie odpovedí do vyrovnávacej pamäte, automatické obnovovanie dát, opakovanie neúspešných požiadaviek či stránkovanie, nevymýšľajte ho sami – použite knižnicu TanStack Query (predtým React Query) alebo SWR. Ich rozhranie je veľmi podobné nášmu hooku:

import { useQuery } from '@tanstack/react-query';

const { data, isPending, error } = useQuery({
  queryKey: ['pouzivatelia'],
  queryFn: () => fetch('/api/users').then((r) => r.json()),
});

Zhrnutie

  • Dáta načítavajte v useEffect a správne uveďte závislosti ([] alebo [url]).
  • Vždy ošetrite tri stavy: načítava sa, chyba, hotovo.
  • V upratovacej funkcii efektu rušte požiadavku cez AbortController.
  • Pri vyhľadávaní posielajte dotaz s oneskorením.
  • Opakujúcu sa logiku presuňte do vlastného hooku.
O autorovi

Ing.Jaroslav Vadel

Som zakladateľom www.projectik.eu. Hrám sa na programátora, ktorý ovláda: c#,cpp,java,unity3d,php,html,NI testand,NI Vision Builder,Cognex In-Sight,NI LabView "Naprogramovať program, ktorý funguje vie každy. Ale to, že program funguje ešte neznamena, že je napísany správne "

Súvisiace články