Əsas məzmuna keç
FrontDepth, Ana səhifə

React və render

useEffect: asılılıqlar və cleanup

useEffect komponenti React-dən kənardakı sistemlərlə necə sinxronlaşdırır — setup və cleanup nə vaxt işləyir, asılılıqlar necə müqayisə olunur, Strict Mode effektləri niyə iki dəfə işə salır — və render dövrlərindən, stale closure-lardan, fetch yarışlarından və lazımsız effektlərdən necə qaçmaq olar.

JuniorMiddleSeniorYenilənib: 16 noyabr 2026

Oxu səviyyəsi

Seçilmiş səviyyəyə qədər olan bölmələr göstərilir.

Bu mövzu Junior səviyyəsindən başlayır.

JuniorKonsepsiya

Effekt nə üçündür

React komponentində iki növ məntiq var. Render props və state-i JSX-ə çevirir və təmiz (pure) olmalıdır: eyni girişlər, eyni nəticə, heç bir yan təsir. Event handler-lər konkret qarşılıqlı əlaqəyə — klikə, formun göndərilməsinə — cavab kimi işləyir və dəyişikliklər məhz orada edilir. Bəzi işlər isə heç birinə uyğun gəlmir: onlar istifadəçi nəsə etdiyi üçün yox, komponent ekranda olduğu üçün baş verməlidir. Effekt məhz bunun üçündür. react.dev effektləri konkret event-in yox, "render-in özünün səbəb olduğu" yan təsirlər kimi tərif edir.

Effektin tipik işi xarici sistemlə sinxronlaşmaqdır, yəni React-in idarə etmədiyi bir şeylə:

  • şəbəkə bağlantısı (chat otağı, WebSocket);
  • brauzer API-ləri: document.title, IntersectionObserver, window üzərindəki listener;
  • taymerlər;
  • React-dən kənar vidjet: xəritə, qrafik, video pleyer.
JSX
import { useEffect, useState } from "react";

function ChatRoom({ roomId }) {
  const [messages, setMessages] = useState([]);

  useEffect(() => {
    const connection = createConnection(roomId);
    connection.on("message", (m) => setMessages((list) => [...list, m]));
    connection.connect();
    return () => connection.disconnect();
  }, [roomId]);

  return <MessageList messages={messages} />;
}

Effektin üç hissəsi var: setup (qoşulmaq), cleanup — setup-ın qaytardığı funksiya (ayrılmaq) — və asılılıqlar ([roomId]: otaq dəyişəndə yenidən qoşul). Bunu "mount zamanı işləyən kod" kimi yox, bir sinxronlaşmanı necə başlatmaq və necə dayandırmaq barədə təsvir kimi oxu. react.dev bunu belə ifadə edir: effekt yalnız nəyisə sinxronlaşdırmağa başlaya və sonra onu dayandıra bilər.

Effektə nə aid deyil

  • Hesablamalar. Dəyəri props və state-dən hesablamaq olursa, onu render zamanı hesabla.
  • İstifadəçi əməliyyatlarına reaksiya. Formu göndərmək, məhsul almaq, klikdən sonra bildiriş göstərmək — bunlar onlara səbəb olan event handler-ə aiddir.

react.dev-in sadə qaydası belədir: kodun niyə işlədiyini soruş. O, konkret qarşılıqlı əlaqə üzündən işləyirsə, bu, event-dir. İstifadəçi komponenti gördüyü üçün işləyirsə, effektdir.

Effektlər yalnız client-də işləyir, server render zamanı heç vaxt. Ona görə də yalnız brauzerdə olan API-lərə ehtiyacı olan kodun yeri effektlərdir.

JuniorKonsepsiya

Effektlər və cleanup-lar nə vaxt işləyir

React iki addımda işləyir: render (komponentini çağırıb JSX-i hesablamaq) və commit (dəyişiklikləri DOM-a tətbiq etmək). Effektlər commit-dən sonra işləyir:

Text
render → commit (DOM updated) → browser paints → useEffect setup

Yenilənməyə qarşılıqlı əlaqə səbəb olmayıbsa, React adətən əvvəlcə brauzerə ekranı çəkməyə (paint) imkan verir, effekti isə ondan sonra işə salır, beləliklə effektlər istifadəçinin gördüyünü gecikdirmir. Yenilənməyə klik kimi qarşılıqlı əlaqə səbəb olubsa, React effekti paint-dən əvvəl də işə sala bilər. Hər iki halda effekt işləyəndə DOM artıq yenilənmiş olur.

Cleanup-ın vaxtı

Asılılıqların dəyişdiyi hər commit-dən sonra React əvvəlcə köhnə dəyərlərlə əvvəlki cleanup-ı, sonra yeni dəyərlərlə yeni setup-ı işə salır. Komponent silinəndə sonuncu cleanup son dəfə işləyir:

Text
mount, roomId "general"       setup:   connect "general"
re-render, same roomId        (nothing)
re-render, roomId "travel"    cleanup: disconnect "general"
                              setup:   connect "travel"
unmount                       cleanup: disconnect "travel"

Hər render-in öz effekti var. İşləyən cleanup əvvəlki render zamanı yaradılıb, ona görə də o, həmin render-in roomId-si üzərində qurulmuş olur. Sənə lazım olan da məhz budur: qoşulduğun otaqdan ayrılırsan. Bir komponentin daxilində effektlər elan olunduqları sıra ilə işləyir, uşaq komponentin effektləri isə valideynin effektlərindən əvvəl işləyir.

Strict Mode: setup, cleanup, setup

Development rejimində Strict Mode ilk mount-dan dərhal sonra bir əlavə setup + cleanup dövrü işə salır, ona görə də connect → disconnect → connect görürsən. Bu, stress testdir. Cleanup setup-ı tam güzgüləyirsə, istifadəçi fərqi hiss etmir. Nəsə pozulursa — iki bağlantı, iki dəfə qeydə alınmış listener, iki dəfə işləyən taymer — deməli cleanup ya yoxdur, ya da natamamdır. Production-da setup bir dəfə işləyir.

Düzgün sual "effekti necə bir dəfə işə salım?" yox, "effektimi necə düzəldim ki, yenidən mount-dan sonra da işləsin?" sualıdır. Əlavə dövrü ref bayrağı ilə gizlətmə: react.dev xəbərdarlıq edir ki, bu, bug-ı düzəltmir, sadəcə gizlədir. Üstəlik, eyni unmount və yenidən mount istifadəçi ekrandan çıxıb geri qayıdanda real həyatda da baş verir.

JuniorKonsepsiya

Asılılıqlar massivi (dependency array)

JSX
useEffect(setup);
useEffect(setup, []);
useEffect(setup, [a, b]);
  • Array yoxdur: effekt hər commit-dən sonra işləyir.
  • []: yalnız ilk commit-dən sonra işləyir, cleanup-ı isə unmount zamanı. Bu, yalnız effekt həqiqətən heç bir reaktiv dəyər oxumursa düzgündür.
  • [a, b]: ilk commit-dən sonra və a və ya b-nin dəyişdiyi hər commit-dən sonra.

"Dəyişib" o deməkdir ki, asılılığı əvvəlki render-dəki dəyəri ilə müqayisə edəndə Object.is false qaytarıb. Sətir, ədəd və boolean üçün bu, adi dəyər bərabərliyidir (iki xırda istisna ilə: NaN NaN-a bərabərdir, 0 isə -0-dan fərqlənir). Obyekt, massiv və funksiyalar üçün isə bu, identiklikdir: eyni məzmunlu yeni obyekt dəyişmiş sayılır.

JSX
function SearchResults({ query, page }) {
  const options = { query, page };

  useEffect(() => {
    loadResults(options);
  }, [options]);
}

options hər render-də yeni obyektdir, ona görə bu effekt hər render-dən sonra işləyir. Bunun əvəzinə primitivlərdən asılı ol ([query, page]) və obyekti effektin içində yarat.

Asılılıqları sən seçmirsən

Array effektin oxuduğu hər reaktiv dəyəri sadalamalıdır: props, state və komponentin gövdəsində onlardan hesablanan hər şey. react-hooks/exhaustive-deps lint qaydası bunu sənin yerinə yoxlayır.

  • useState-in set funksiyası və useRef-in ref obyekti stabildir, onları yazmaya bilərsən.
  • Komponentdən kənarda elan olunmuş dəyərlər reaktiv deyil və siyahıya yazılmır.
  • ref.current və ya location.pathname kimi dəyişkən dəyərlər asılılıq ola bilməz: onların dəyişməsi render-ə səbəb olmur, ona görə React bunu heç vaxt hiss etməz.

Linter istəmədiyin asılılığı tələb edirsə, xəbərdarlığı susdurma — kodu elə dəyiş ki, effektə həmin dəyər lazım olmasın. Onu effektin içinə və ya komponentdən kənara köçür, state-i oxumaq əvəzinə updater funksiyadan (setCount((c) => c + 1)) istifadə et və ya dəyəri Effect Event vasitəsilə oxu. Stale closure bug-larının çoxu məhz susdurulmuş lint xəbərdarlığından başlayır.

MiddleKonsepsiya

Bəlkə effektə ehtiyac yoxdur

Heç bir xarici sistem iştirak etmirsə, çox güman ki, effektə ehtiyacın yoxdur. Yalnız bir state-i digərinə görə düzəldən effektlər komponenti həm yavaşladır — hər commit-dən sonra əlavə render — həm də başa düşməyi çətinləşdirir. react.dev-in sadaladığı ən tipik hallar:

Törəmə dəyərlər: onları render zamanı hesabla.

JSX
const [fullName, setFullName] = useState("");
useEffect(() => {
  setFullName(firstName + " " + lastName);
}, [firstName, lastName]);

İlk render köhnəlmiş fullName göstərir, sonra effekt state-i dəyişir və React yenidən render edir. const fullName = firstName + " " + lastName; daha qısadır, həmişə uyğundur və bir dəfə render olunur. Hesablama bahalıdırsa, onu effektə yox, useMemo-ya bük.

Prop dəyişəndə state-i sıfırlamaq: key istifadə et. <Profile key={userId} userId={userId} /> React-ə hər istifadəçinin profilini ayrı komponent kimi qəbul etdirir, ona görə də onun state-i "təmizləyən" effekt olmadan sıfırlanır.

İstifadəçi əməliyyatlarına reaksiya: event handler-dən istifadə et.

JSX
function BuyButton({ product }) {
  function handleClick() {
    addToCart(product);
    showNotification(`Added ${product.name} to the cart`);
  }
  return <button onClick={handleClick}>Buy</button>;
}

Səbəti izləyib bildiriş göstərən effekt səhifə yüklənəndə, yeniləndikdən sonra və ya səbət başqa səbəbdən dəyişəndə də işləyərdi. Bildirişin səbəbi klikdir, deməli onun yeri klik handler-idir.

Effekt zəncirləri, yəni yalnız başqa effektləri işə salmaq üçün state dəyişən effektlər: nəyi bacarırsansa render zamanı hesabla, növbəti state-in hamısını isə bir event handler-də təyin et.

Valideyni dəyişiklik barədə xəbərdar etmək: valideynin callback-ini state-i yeniləyən eyni event handler-də çağır və ya state-i yuxarı qaldır ki, sinxron saxlanmalı heç nə qalmasın.

Xarici store-a abunə olmaq: bunun üçün xüsusi hook var — useSyncExternalStore.

Geriyə real sinxronlaşmalar qalır: bağlantılar, abunəliklər, taymerlər, imperativ vidjetlər, "istifadəçi bu ekranı gördü" analitikası və data fetching (fetching bölməsindəki şərtlərlə). Komponenti review edəndə lazımsız effekti silmək çox vaxt elə onun bug-ının həllidir.

MiddleTipik səhvlər

Sonsuz render dövrləri

State dəyişən effekt yenidən render-ə səbəb olur. Bir dəfəlik bu, normaldır. Yenidən render effektin asılılıqlarını da dəyişəndə — və ya dependency array ümumiyyətlə olmayanda — bu, dövrə çevrilir:

JSX
useEffect(() => {
  setCount(count + 1);
});

react.dev bunu elektrik rozetkasını özünə qoşmağa bənzədir: effekt state-i dəyişir, render effekti yenidən işə salır, effekt yenə state-i dəyişir.

Bunun daha az nəzərə çarpan variantı da var: məhsul siyahısı item-ləri effektdə filtrləyir, filtr obyekti isə render zamanı yaradılır:

JSX
function ProductList({ products, status, sort }) {
  const [visible, setVisible] = useState([]);
  const filter = { status, sort };

  useEffect(() => {
    setVisible(applyFilter(products, filter));
  }, [products, filter]);

  return <Table rows={visible} />;
}

Hər render yeni filter obyekti yaradır, ona görə Object.is asılılığın dəyişdiyini bildirir. Effekt işləyir və visible-a yeni massiv yazır; bu state dəyişikliyi render-ə səbəb olur, render isə daha bir filter yaradır. Boş dayanmalı olan səhifə durmadan commit edir. Development rejimində React belə xəbərdarlıq yazır: "Maximum update depth exceeded. This can happen when a component calls setState inside useEffect, but useEffect either doesn't have a dependency array, or one of the dependencies changes on every render." Production build-i isə heç nə yazmır — səhifə sadəcə CPU yandırır.

Dövr üçün iki şərt lazımdır: effekt state-i yeniləyir və bu yeniləmə effektin asılılıqlarını dəyişir. Onlardan birini qır:

  1. Effektdən istifadə etmə. visible törəmə datadır: render zamanı const visible = applyFilter(products, { status, sort });, bahalıdırsa useMemo-nun içində. Bu, əlavə render-i tamamilə aradan qaldırır.
  2. Primitivlərdən asılı ol. [products, status, sort] yaz və obyekti effektin içində qur.
  3. Obyekti stabilləşdir: həqiqətən ötürülməlidirsə, useMemo(() => ({ status, sort }), [status, sort]).

State-i eyni dəyərə (Object.is-ə görə) təyin etmək React-ə yeniləməni buraxmağa (bail out) imkan verir. Ona görə dövr formalı effektdə setReady(true) bir dövrədən sonra dayanır, setVisible([...]) isə heç vaxt dayanmır. Render-də yaradılan funksiya və massivlərlə, eləcə də valideynin hər render-də yenidən yaratdığı props ilə eyni tələyə düşməmək üçün diqqətli ol.

MiddleTipik səhvlər

Effektlərdə stale closure

Hər render yeni props və state sabitləri yaradır, həmin render-də yaradılan effekt isə onlar üzərində olur. Effekt yeni render-lərdən sonra da işləyən funksiya qoyub gedirsə — interval, abunəlik callback-i — həmin funksiya köhnə dəyərləri görməyə davam edir. Buna deyilir.

Qaralamanı bir neçə saniyədən bir saxlayan redaktora bax:

JSX
function Editor({ docId }) {
  const [text, setText] = useState("");

  useEffect(() => {
    const id = setInterval(() => {
      saveDraft(docId, text);
    }, 3000);
    return () => clearInterval(id);
  }, []);

  return <textarea value={text} onChange={(e) => setText(e.target.value)} />;
}

Effekt bir dəfə işləyir, ona görə də interval callback-i text-in "" olduğu ilk render-ə aiddir. İstifadəçi yazır və yeni mətni görür, tətbiq isə hər üç saniyədən bir boş ilk versiyanı saxlayır. Səhifə yenidən yüklənəndən sonra düzəlişlər yoxa çıxır. Linter docId və text-i çatışmayan asılılıq kimi göstərərdi: buradakı [] əslində gizlədilmiş susdurmadır.

Həll yolları, ən birbaşasından başlayaraq:

  1. Asılılıqları yaz: [docId, text]. Interval hər dəyişiklikdən sonra təzə closure ilə yenidən yaradılır və eyni anda yenə yalnız bir taymer olur. Autosave üçün bu, həm də "son düymə basışından üç saniyə sonra saxla" deməkdir, yəni — bunu interval yox, setTimeout daha aydın ifadə edir.
  2. Son dəyəri ref-dən oxu. Ref bütün render-lərin bölüşdüyü bir dəyişkən qutudur:
JSX
const textRef = useRef(text);
useEffect(() => {
  textRef.current = text;
}, [text]);

useEffect(() => {
  const id = setInterval(() => saveDraft(docId, textRef.current), 3000);
  return () => clearInterval(id);
}, [docId]);

Ref-i render zamanı yox, effektdə və ya event handler-də yenilə.

  1. useEffectEvent (React 19.2-dən stabildir): "cari mətni saxla" məntiqini Effect Event-ə köçür; o, asılılıq olmadan həmişə son props və state-i görür. Aşağıdakı senior bölməsinə bax.

Updater funksiya (setCount((c) => c + 1)) stale closure-u yalnız callback state-i əvvəlki dəyərinə görə yazmalı olanda həll edir. Autosave isə cari dəyəri oxuyub başqa yerə göndərməlidir, ona görə ona yuxarıdakı həllərdən biri lazımdır.

SeniorNümunə

Data fetching və race condition-lar

Effektdə data fetch etmək olar, amma sadəlövh variantda klassik bug var — cavablar sorğuların göndərildiyi sıradan fərqli sırada gələ bilər:

JSX
useEffect(() => {
  fetchResults(query).then((json) => setResults(json));
}, [query]);

Əvvəl "re", sonra "react" yaz: iki sorğu gedir. "re" cavabı daha yavaşdırsa, o, sonuncu gəlir və "react" nəticələrinin üzərinə yazılır; ekranda istifadəçinin artıq axtarmadığı sorğunun nəticələri görünür.

react.dev-in göstərdiyi həll köhnə sorğunu köhnəlmiş kimi işarələyən cleanup-dır:

JSX
useEffect(() => {
  let ignore = false;
  fetchResults(query).then((json) => {
    if (!ignore) setResults(json);
  });
  return () => {
    ignore = true;
  };
}, [query]);

query dəyişəndə React növbəti setup-dan əvvəl əvvəlki cleanup-ı işə salır, ona görə əvvəlki effektin ignore-u true olur və onun gecikmiş cavabı atılır. Hər effektin öz ignore-u var — cleanup öz render-inin dəyişəni üzərində closure-dur — ona görə yalnız sonuncu sorğunun cavabı istifadə olunur.

Sorğunun özünü də ləğv edə bilərsən:

JSX
useEffect(() => {
  const controller = new AbortController();
  fetch(`/api/search?q=${encodeURIComponent(query)}`, { signal: controller.signal })
    .then((response) => response.json())
    .then((json) => setResults(json))
    .catch((error) => {
      if (error.name !== "AbortError") setError(error);
    });
  return () => controller.abort();
}, [query]);

Abort etmək trafikə də qənaət edir; ləğv olunmuş fetch AbortError ilə reject olur və sən onu nəzərə almırsan. Development-də Strict Mode ilk sorğunu başladıb dərhal ləğv edir — bu, gözləniləndir, production-da isə bir sorğu gedir.

Data qatı bunu niyə daha yaxşı edir

Effektdəki fetch keşləmir, komponentlər arasında eyni sorğuları birləşdirmir (dedup etmir), yalnız render-dən sonra başlayır (yəni iç-içə komponentlər şəlalə kimi bir-birinin ardınca fetch edir) və serverdə işləmir. react.dev framework-ün daxili data fetching mexanizmini və ya TanStack Query, SWR, React Router kimi client tərəf keşini tövsiyə edir. ignore şablonu yenə də vacibdir: o alətlər məhz bunu sənin yerinə edir, bu sual isə müsahibələrdə standartdır.

SeniorFramework

useLayoutEffect və useEffectEvent

useLayoutEffect

useLayoutEffect-in imzası useEffect ilə eynidir, amma o, brauzer ekranı yenidən çəkməzdən əvvəl işləyir. React zəmanət verir ki, onun kodu və ondan planlaşdırılan hər state yeniləməsi paint-dən əvvəl emal olunacaq. Buna görə o, layout-u ölçüb istifadəçi səhv variantı görməmiş düzəltmək üçün alətdir:

JSX
function Tooltip({ anchorTop, children }) {
  const ref = useRef(null);
  const [height, setHeight] = useState(0);

  useLayoutEffect(() => {
    setHeight(ref.current.getBoundingClientRect().height);
  }, []);

  const top = anchorTop - height < 0 ? anchorTop + 24 : anchorTop - height;
  return <div ref={ref} style={{ position: "absolute", top }}>{children}</div>;
}

useEffect ilə brauzer tooltip-i səhv yerdə çəkib bir kadr sonra yerini dəyişə bilərdi: gözə çarpan titrəmə (flicker). Bunun qiyməti var: layout effektləri paint-i bloklayır, onların içindəki state yeniləməsi isə React-i qalan bütün effektləri, useEffect-lər də daxil olmaqla, dərhal işə salmağa məcbur edir. useEffect-ə üstünlük ver, useLayoutEffect-ə isə yalnız ölçünü paint-dən əvvəl tətbiq etmək mütləq lazım olanda müraciət et. Layout effektləri server render zamanı da işləmir, ona görə server HTML-i həmişə ilk, ölçülməmiş keçiddir.

useEffectEvent

Bəzən effekt dəyəri oxumalı, amma ona reaksiya verməməlidir. Chat otağı roomId dəyişəndə yenidən qoşulmalıdır, theme dəyişəndə isə yox, halbuki "qoşuldu" bildirişi theme-dən istifadə edir:

JSX
import { useEffect, useEffectEvent } from "react";

function ChatRoom({ roomId, theme }) {
  const onConnected = useEffectEvent(() => {
    showNotification("Connected!", theme);
  });

  useEffect(() => {
    const connection = createConnection(roomId);
    connection.on("connected", () => onConnected());
    connection.connect();
    return () => connection.disconnect();
  }, [roomId]);
}

Effect Event həmişə son props və state-i görür və reaktiv deyil, ona görə heç vaxt dependency array-ə yazılmır. useEffectEvent React 19.2-də stabil API kimi çıxıb (cari buraxılış 19.3-dür); eslint-plugin-react-hooks-u yenilə ki, linter onu asılılıq kimi tələb etməsin. Qaydalar:

  • onu yalnız eyni komponentin effektlərinin (və ya digər Effect Event-lərin) içindən çağır, render zamanı heç vaxt;
  • başqa komponentlərə və hook-lara ötürmə — onun identikliyi qəsdən hər render-də dəyişir;
  • effekti yenidən işə salmalı olan asılılıqları gizlətmək üçün istifadə etmə. O, mahiyyətcə effektdən göndərilən event olan məntiq üçündür: cari səbət ölçüsü ilə ziyarəti log etmək, cari temada bildiriş göstərmək, son mətni oxuyan autosave tiki.
SeniorMüsahibə məsləhətləri

Müsahibə üçün məsləhətlər

30 saniyəlik cavab. "useEffect komponenti React-dən kənardakı nəsə ilə sinxronlaşdırır. React setup-ı commit-dən sonra, adətən paint-dən sonra işə salır. Asılılıq dəyişəndə — Object.is ilə müqayisə olunur — əvvəlki cleanup-ı köhnə dəyərlərlə, sonra yeni setup-ı işə salır, sonuncu cleanup isə unmount zamanı işləyir. Development-də Strict Mode cleanup-ın setup-ı geri qaytardığını yoxlamaq üçün bir əlavə setup + cleanup dövrü əlavə edir. Bug-ların çoxu çatışmayan cleanup, stabil olmayan asılılıqlar və stale closure-lardır — bir çox effekt isə ümumiyyətlə olmamalıdır."

Gözlənilən suallar

  • Render, commit, effekt və cleanup hansı ardıcıllıqla işləyir? Mount → update → unmount üçün zaman xəttini çək və cleanup-ın köhnə render-in dəyərlərini gördüyünü göstər.
  • Effektim development-də niyə iki dəfə işləyir? Strict Mode. Cleanup-ı düzəlt, ref bayrağı əlavə etmə.
  • Bu komponent niyə dövrə düşüb? Effekt state dəyişir və hər render-də yenidən yaradılan obyektdən, massivdən və ya funksiyadan asılıdır — ya da array-i yoxdur. Render zamanı hesabla, primitivlərdən asılı ol və ya memoizasiya et.
  • Intervalım niyə köhnə state-i görür? Stale closure. Həllər: updater funksiya, düzgün asılılıqlar, ref, useEffectEvent.
  • Effektdə təhlükəsiz fetch necə edilir? Cleanup-da ignore bayrağı və ya AbortController; daha yaxşısı, framework loader-i və ya keş kitabxanası.
  • useEffect, yoxsa useLayoutEffect? Adətən paint-dən sonra və paint-dən əvvəl. Layout effektləri paint-i bloklayır; onları ölçmələr üçün işlət.

Bal itirdən səhvlər

  • Effektləri componentDidMount / componentDidUpdate kimi izah etmək. Sinxronlaşmanın başlanması və dayandırılmasından danış; react.dev effektin baxış bucağından, hər dəfə bir başlat/dayandır dövrü ilə düşünməyi məsləhət görür.
  • []-ı "bir dəfə işlət" deməyin üsulu saymaq. Boş array məqsəd yox, heç bir reaktiv dəyər oxumayan effektin nəticəsidir.
  • Kodu yenidən qurmaq əvəzinə exhaustive-deps-i susdurmaq.
  • Törəmə state-i hesablamaq və ya klikə cavab vermək üçün effektdən istifadə etmək.

Senior səviyyəni göstərən məqamlar

Yalnız qaydaları yox, mühakiməni göstər: code review-da hansı effektləri silərdin, effekti komponentlərə aydın API verən custom hook-a (useOnlineStatus, useChatRoom) necə bükərdin və iş nə vaxt effektə yox, framework-ün data qatına aiddir. Bunu real nasazlıqlarla bağla: yalnız development log-larında görünən render dövrü, səssizcə köhnə mətni saxlayan autosave, köhnə sorğunun nəticələrini göstərən axtarış.

Platformadakı render-loop, autosave-stale-closure və search-race incident-ləri effektlərin debug edilməsini işləyən tətbiqdə məşq etməyə imkan verir.

JuniorYoxlama siyahısı

Effektləri review edərkən nəyi yoxlamalı

Yazmadığın effekti — komanda yoldaşının, kitabxananın və ya AI assistentin kodunu — review edəndə bu siyahıdan istifadə et. Effekt bug-ları nadir hallarda dərhal görünür; onlar sonra təkrarlanan bağlantılar, render dövrləri və köhnə dəyərləri oxuyan callback-lər kimi üzə çıxır.

  • Effekt React-dən kənardakı nə iləsə sinxronlaşırmı? Props və ya state-dən hesablanan dəyərlərin yeri render-dir, klikə və ya submit-ə reaksiyaların yeri isə event handler-dir. Yalnız bir state-i başqa state-dən təyin edən effekt köhnə data ilə əlavə render yaradır; çox vaxt düzəliş onu silməkdir.
  • Hər setup-ın onu geri qaytaran cleanup-ı varmı? Bağlantılar kəsilməli, taymerlər təmizlənməli, listener-lər isə eyni funksiya referansı ilə silinməlidir. Development-də Strict Mode mount zamanı setup, cleanup, setup ardıcıllığını işə salır: təkrarlanan bağlantı və ya iki dəfə işləyən taymer cleanup-ın çatışmadığını göstərir; ikinci dövrü ötürən ref bayrağı bunu sadəcə gizlədir.
  • Dependency array effektin oxuduğu hər reaktiv dəyəri sadalayırmı? Props, state və onlardan hesablanan dəyərlərin hamısı sayılır; susdurulmuş react-hooks/exhaustive-deps xəbərdarlığı və ya onları buraxan [] interval və abunəliklərin köhnə render-in dəyərlərini oxumasına səbəb olur — bu, .
  • State dəyişən effekt render zamanı yaradılan obyektdən, massivdən və ya funksiyadan asılıdırmı? Hər render Object.is-in dəyişmiş saydığı yeni referans gətirir, ona görə hər dəfə yeni obyekt və ya massiv yazan effekt, array-i olmayan effekt kimi, heç vaxt dayanmır. Development "Maximum update depth exceeded" yazır, production isə heç nə; bunun əvəzinə primitivlərdən asılı ol.
  • Fetch-in asılı olduğu dəyər dəyişəndə köhnə cavab atılır və ya ləğv olunurmu? Cavablar sorğuların göndərildiyi sıradan fərqli sırada gələ bilər: cleanup-da ignore bayrağı və ya ləğv edilən AbortController yoxdursa, gecikmiş köhnə cavab yenisinin üzərinə yazılır.

Özünü yoxla

  • Məşq

    Kodun nəticəsini təxmin et, açıq müsahibə suallarına cavab ver və özünü qiymətləndir.

    4 nəticə sualı · 3 açıq sual

  • Quiz

    İzahlı test sualları və yekun nəticə.

    6 sual

Bu mövzudan istifadə edən praktiki işlər.