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

React və render

State idarəetməsi və xarici store-lar

Hər state parçası harada yaşamalıdır və niyə: lokal, ortaq, server, URL və form state-i, hesablanan dəyərlər, state-in yuxarı qaldırılması, context və onun re-render qiyməti, reducer-lər, useSyncExternalStore ilə xarici store-lar, tearing, selector-lar və server state keşləri.

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.

Başlamazdan əvvəl

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

JuniorKonsepsiya

State növləri və hər birinin yeri

"State idarəetməsi" deyəndə çox vaxt kitabxana seçimi nəzərdə tutulur. Amma ilk sual başqadır: bu hansı növ state-dir? Hər növün öz tələbləri və təbii yeri var.

NövNümunələrTəbii yeri
Lokal UI state-iaçıq dropdown, aktiv tab, yazılmaqda olan şərhondan istifadə edən komponentdə useState
Ortaq client state-isəbət, tema, daxil olmuş istifadəçiən yaxın ortaq valideyn; çox sayda uzaq komponent oxuyursa, context və ya xarici store
Server state-iAPI-dən gələn məhsullar, sifarişlər, istifadəçi profiliserver state keşi (TanStack Query, SWR, framework-ün data yükləməsi)
URL state-ifiltrlər, sıralama, səhifə nömrəsi, paylaşmaq istədiyin tabURL: route və search parametrləri
Form state-isahələrin dəyərləri, toxunulmuş sahələr, validasiya xətalarıformun özü, mürəkkəb formlar üçün isə form kitabxanası

Bu fərq niyə vacibdir:

  • Server state-i sənin deyil. O, serverdə yaşayır, başqaları onu dəyişə bilər və köhnəlir. Ona sadəcə dəyişən yox, keşləmə, yenidən sorğulama və invalidasiya lazımdır.
  • URL state-i səhifə yenilənəndə də qalmalı, Back düyməsi ilə işləməli və link kimi paylaşıla bilməlidir. useState-də saxlanan filtr refresh-dən sonra yox olur.
  • Form state-i qısaömürlüdür. Çox vaxt idarə olunmayan input-lar və submit zamanı FormData kifayət edir; formdan kənarda heç kimə hər düymə basışı lazım deyil.
  • Lokal UI state-i komponenti ilə birlikdə ölməlidir. Onu qlobal store-a qoysan, ekrandan uzun yaşayır, səhifələr arasında sızır və hər dəyişikliyi qlobal edir.

Bir səhifədə adətən bir neçə növ eyni vaxtda olur:

JSX
function ProductsPage() {
  const [searchParams, setSearchParams] = useSearchParams();
  const sort = searchParams.get("sort") ?? "popular";

  const { data: products = [] } = useQuery({
    queryKey: ["products", { sort }],
    queryFn: () => fetchProducts({ sort }),
  });

  const [isFilterOpen, setFilterOpen] = useState(false);
  const addToCart = useCartStore((state) => state.add);

  // ...
}

Sıralama URL-də yaşayır (burada React Router-in useSearchParams-ı ilə), məhsul siyahısı query keşində, panelin açıq olması lokal state-də, səbət isə ortaq store-da.

Lokaldan başla

Yaxşı default qayda: state-i ondan istifadə edən komponentdə saxla. Onu yalnız başqa komponentə lazım olanda yuxarı qaldır, React-dən kənara isə yalnız çox sayda uzaq komponentə lazım olanda və ya React-dən kənarda dəyişəndə çıxar. State-i sonradan köçürmək kiçik refaktorinqdir; hər şeyi saxlayan qlobal store-u açmaq isə böyük iş.

JuniorNümunə

Təkrarlanan state yox, hesablanan dəyər

react.dev-in "Choosing the State Structure" səhifəsi beş prinsip verir: əlaqəli state-i qruplaşdır, ziddiyyətlərdən qaç, artıq state saxlama, təkrarlamadan qaç, dərin iç-içəlikdən qaç. Real bug-ların çoxu ortadakı üç prinsipdən gəlir: bir-biri ilə uyğun olmalı iki state parçası bir gün uyğun olmur.

Saxlama, hesabla

JSX
function TodoList({ todos }) {
  const [filter, setFilter] = useState("all");
  const [visibleTodos, setVisibleTodos] = useState(todos);

  useEffect(() => {
    setVisibleTodos(todos.filter((todo) => filter === "all" || todo.done === (filter === "done")));
  }, [todos, filter]);

  // ...
}

visibleTodos sinxron saxlanmalı olan surətdir. Hər dəyişiklik əvvəlcə köhnə siyahı ilə, effektdən sonra isə yenidən render olunur; effekti unudan istənilən kod yolu səhv data göstərir. Əvəzində onu render zamanı hesabla:

JSX
function TodoList({ todos }) {
  const [filter, setFilter] = useState("all");
  const visibleTodos = todos.filter((todo) => filter === "all" || todo.done === (filter === "done"));

  // ...
}

react.dev-in qaydası: nəyisə mövcud props və ya state-dən hesablamaq mümkündürsə, onu state-ə qoyma, render zamanı hesabla. Hesablama həqiqətən bahadırsa, onu useMemo-ya bük; dəyər yenə hesablanan dəyərdir, sadəcə keşlənir.

Surət yox, id saxla

items-in yanında selectedItem saxlamaq eyni obyekti iki yerdə təkrarlayır: elementi redaktə et, seçim köhnə başlığı göstərəcək. selectedId saxla və elementi render zamanı tap: items.find((item) => item.id === selectedId).

Ziddiyyəti mümkünsüz et

İki boolean — isSending və isSent — heç vaxt olmamalı bir vəziyyətə imkan verir: hər ikisi true. "typing", "sending" və "sent" dəyərləri olan bir status dəyişəni isə özü-özünə zidd ola bilməz.

Props-u state-də təkrarlama

JSX
function Message({ messageColor }) {
  const [color, setColor] = useState(messageColor);
  // ...
}

useState arqumentindən yalnız ilk render-də istifadə edir, ona görə valideyn sonra "red" ötürəndə color "blue" olaraq qalır. Prop-dan birbaşa istifadə et. Həqiqətən yalnız ilk dəyər lazımdırsa, bunu adda bildir: initialColor və ya defaultColor.

MiddleFramework

State-i yuxarı qaldırmaq, context və onun re-render qiyməti

İki komponent birlikdə dəyişməlidirsə, react.dev-in cavabı state-i yuxarı qaldırmaqdır: onu hər ikisindən çıxar, ən yaxın ortaq valideyndə saxla və onu dəyişən event handler ilə birlikdə aşağı ötür. Hər unikal state parçasına bir komponent "sahiblik edir" — bu, vahid həqiqət mənbəyidir (single source of truth).

Yuxarı qaldırmaq props-un onlardan istifadə etməyən komponentlərdən keçməsinə səbəb ola bilər. Context-ə əl atmazdan əvvəl react.dev iki şey təklif edir: sadəcə props ötür (açıq data axını asan izlənir), və ya komponentləri ayır və JSX-i children kimi ötür ki, <Layout posts={posts} /> əvəzinə <Layout><Posts posts={posts} /></Layout> yazılsın.

Context-in qiyməti

Context dəyəri istənilən dərinliyə çatdırır. Qiyməti yeniləmələrin necə işləməsindədir: React value-su dəyişən provider-dən başlayaraq context-i oxuyan hər komponenti yenidən render edir, köhnə və yeni dəyərləri Object.is ilə müqayisə edir. İstehlakçıları memo-ya bükmək bunun qarşısını almır.

JSX
function ShopProvider({ children }) {
  const [cart, setCart] = useState([]);
  const [theme, setTheme] = useState("light");
  const addToCart = (product) => setCart((lines) => addLine(lines, product));

  return (
    <ShopContext value={{ cart, addToCart, theme, setTheme }}>
      {children}
    </ShopContext>
  );
}

Burada iki problem gizlənib:

  1. value obyekti hər render-də yenidən yaranır, ona görə ShopProvider hansı səbəbdən render olunursa olunsun, bütün istehlakçılar yenidən render olunur.
  2. Əlaqəsiz data bir dəyəri bölüşür. Yalnız addToCart-a ehtiyacı olan məhsul kartı da səbət dəyişəndə yenidən render olunur, çünki addToCart-ı saxlayan obyekt yenidir.

Düzəlişlər, təsirinə görə

  • State-i aşağı endir. Bir komponentin istifadə etdiyi state (tək mətn sahəsindəki qaralama) ümumiyyətlə ortaq context-ə aid deyil.
  • Context-ləri birlikdə dəyişən şeylərə görə böl, action-ları isə ayrıca context-ə çıxar. setState funksiyaları heç vaxt dəyişmir, ona görə bir dəfə qurulmuş action-lar dəyəri sabit qalır.
  • Dəyərləri sabitləşdir: obyektlər üçün useMemo, funksiyalar üçün useCallback. Bu, provider-in yenidən render olunmasından gələn re-render-ləri dayandırır, real dəyişiklikdən gələnləri yox: hər şeyi bir yerə yığan dəyəri memo etsən də, onun istənilən hissəsi dəyişəndə o da dəyişir.
  • Selector-lu xarici store-dan istifadə et — çox sayda komponentin hər biri tez dəyişən state-in kiçik bir hissəsinə ehtiyac duyanda.

Context çox yerdə oxunan və nadir dəyişən dəyərlər üçün yaxşıdır: tema, cari hesab, locale, router.

Həftəlik çağırışlardakı Context fırtınası çağırışında context re-render-lərini tapıb aradan qaldırmağı məşq edə bilərsən: bir mağaza context-i istifadəçini, temanı, səbəti və hədiyyə qeydini saxlayır, bir bitki əlavə etmək isə bütün 24 məhsul kartını yenidən render edir.

MiddleNümunə

Reducer-lər və immutable yeniləmələr

Bir neçə event handler eyni state-i bir-biri ilə əlaqəli şəkildə yeniləyəndə useReducer bu məntiqi bir təmiz funksiyaya köçürür: (state, action) => nextState. Komponentlər yalnız nə baş verdiyini təsvir edir (dispatch({ type: "added", product })), state-in necə dəyişəcəyinə isə reducer qərar verir.

JavaScript
function cartReducer(state, action) {
  switch (action.type) {
    case "added": {
      const exists = state.lines.some((line) => line.id === action.product.id);
      const lines = exists
        ? state.lines.map((line) =>
            line.id === action.product.id ? { ...line, qty: line.qty + 1 } : line,
          )
        : [...state.lines, { id: action.product.id, qty: 1 }];
      return { ...state, lines };
    }
    case "cleared":
      return { ...state, lines: [] };
    default:
      return state;
  }
}

Immutability niyə zövq məsələsi deyil

React nəyinsə dəyişib-dəyişmədiyinə referansa görə qərar verir. setState və ya dispatch cari state ilə Object.is-ə görə eyni olan dəyər alanda React həmin komponentin re-render-ini ötürür. memo, dependency array-lər və store selector-ları da referansları müqayisə edir. Dəyişdirən (mutating) reducer bunların hamısını sındırır:

JavaScript
case "added":
  state.lines.push({ id: action.product.id, qty: 1 });
  return state;

Reducer eyni obyekti qaytarır, ona görə React dəyişiklik görmür və ekran yenilənmir, halbuki data dəyişib. Növbəti əlaqəsiz render onu birdən göstərir və bug təsadüfi görünür. Strict Mode-da React development zamanı təmiz olmayan kodu üzə çıxarmaq üçün reducer-ləri iki dəfə çağırır; burada bu, sətri iki dəfə əlavə edir.

Immutable yeniləmə yalnız dəyişən yolu kopyalayır, qalan hər şeyi təkrar istifadə edir. Yuxarıdakı reducer-də dəyişməyən sətirlər referanslarını saxlayır, ona görə memo(CartLine) komponenti onları ötürür, state.user-i oxuyan selector isə səbət dəyişəndə dəyişiklik görmür. İncə dənəli re-render-ləri mümkün edən məhz bu structural sharing-dir. Immer kimi kitabxanalar (Redux Toolkit-in createSlice-ı ondan istifadə edir) "dəyişdirən" görünüşlü kod yazmağa imkan verir və eyni immutable nəticəni yaradır.

Reducer və context birlikdə

Çox sayda uzaq komponentin oxuduğu və dəyişdiyi ekran üçün react.dev ikisini birləşdirir: bir context state üçün, biri də dispatch üçün. dispatch komponentin bütün ömrü boyu sabitdir, ona görə yalnız action göndərən komponentlər ("Add" düyməsi) siyahı dəyişdiyinə görə heç vaxt yenidən render olunmur. Bir tətbiqdə hər feature üçün belə bir cüt ola bilər.

MiddleVeb platforma

Xarici store-lar: subscribe, snapshot-lar və selector-lar

Bəzi state React-dən kənarda yaşayır: Redux və ya Zustand store-u, modul səviyyəsində keş, navigator.onLine kimi brauzer API-si. React onun dəyişdiyini görə bilmir, ona görə store-dan iki şey lazımdır: cari dəyəri oxumaq yolu (snapshot) və dəyişiklikdən xəbər tutmaq yolu (subscribe). React-in bunun üçün hook-u useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot?)-dur.

Bu müqaviləyə uyğun store kiçikdir. Zustand-ın nüvəsi (vanilla.ts-dəki createStore) belə qurulub:

JavaScript
function createStore(createState) {
  let state;
  const listeners = new Set();

  const getState = () => state;
  const setState = (partial) => {
    const next = typeof partial === "function" ? partial(state) : partial;
    if (Object.is(next, state)) return;
    const previous = state;
    state = Object.assign({}, state, next);
    listeners.forEach((listener) => listener(state, previous));
  };
  const subscribe = (listener) => {
    listeners.add(listener);
    return () => listeners.delete(listener);
  };

  state = createState(setState, getState);
  return { getState, setState, subscribe };
}

State içində gizlidir, listener-lər Set-də saxlanır, setState isə dəyişikliyi səthi şəkildə yeni obyektə birləşdirir, ona görə referansları müqayisə edən hər kəs dəyişikliyi görür. Real versiya bir də replace flag-ı qəbul edir.

Selector-lar və bərabərlik

JSX
function useStore(store, selector) {
  return useSyncExternalStore(store.subscribe, () => selector(store.getState()));
}

const count = useStore(cartStore, (state) => state.lines.length);

Store-un hər dəyişikliyindən sonra React snapshot funksiyasını yenidən çağırır və nəticə Object.is-ə görə fərqlənəndə komponenti yenidən render edir. Selector komponentin "mənə yalnız bu hissə lazımdır" deməsinin yoludur. Bərabərlik isə nəyin dəyişiklik sayıldığını müəyyən edən qaydadır:

  • Primitiv (lines.length) və ya mövcud referans (state.user) seçmək Object.is ilə yaxşı işləyir.
  • Yeni qurulan obyekt və ya massiv ({ count, total }, lines.map(...)) hər çağırışda yeni referans verir. React-Redux-un useSelector-ı (default olaraq ===) onda hər action-da yenidən render edir; useSyncExternalStore ilə isə sonsuz dövrə girə bilər. Səthi müqayisədən istifadə et (React-Redux-da shallowEqual, Zustand-da useShallow) və ya dəyərləri bir-bir seç.

Redux hər dispatch-dən sonra, reducer eyni state qaytarsa belə, bütün listener-ləri çağırır; komponentləri artıq re-render-dən qoruyan useSelector-dakı selector müqayisəsidir.

Platformada

Özün qur bölməsindəki Mini state kitabxanası layihəsində bunu sıfırdan yazırsan: Redux üslubunda store, abunələr, bərabərlik funksiyalı selector-lar, middleware və useSyncExternalStore üzərində hook. Zustand: bütün store 164 sətirdə turu isə v5.1.0 versiyasındakı real vanilla.ts və react.ts fayllarını oxuyur.

SeniorFramework

Tearing, concurrent render və sabit snapshot-lar

React 18-dən bəri render concurrent ola bilər: transition zamanı React input-u emal etmək üçün render-i dayandırıb sonra davam etdirə bilər. React öz state-ini (useState, context) belə fasilələr boyunca ardıcıl saxlayır, amma sahibi olmadığı dəyərləri qoruya bilmir. Komponent render zamanı dəyişkən store-u birbaşa oxuyursa və React fasilədə ikən store dəyişirsə, dəyişiklikdən əvvəl render olunan komponentlər köhnə, sonra render olunanlar isə yeni dəyəri göstərir. React 18 işçi qrupu buna tearing deyir: UI eyni state üçün bir neçə dəyər göstərir.

useSyncExternalStore bunun qarşısını almaq üçündür. React store-u yalnız getSnapshot vasitəsilə oxuyur və commit-dən əvvəl onu yoxlayır: react.dev-ə görə, transition yeniləməsində React DOM-a dəyişiklikləri tətbiq etməzdən dərhal əvvəl getSnapshot-ı ikinci dəfə çağırır, dəyər dəyişibsə, yeniləməni bloklayan yeniləmə kimi yenidən başladır ki, ekrandakı hər komponent store-un eyni versiyasını göstərsin. Qiyməti budur: store dəyişikliyindən gələn yeniləmələr sinxrondur; transition-dakı useState yeniləmələri kimi hissələrə bölünə bilmir.

Snapshot müqaviləsi

Store dəyişməyibsə, getSnapshot-ın təkrar çağırışları eyni dəyəri qaytarmalıdır (Object.is-ə görə). React onu hər render-də və store-un hər bildirişindən sonra çağırır; fərqli dəyər "yenidən render et" deməkdir.

JSX
const summary = useSyncExternalStore(store.subscribe, () => ({
  count: store.getState().todos.length,
}));

Bu snapshot hər çağırışda yeni obyektdir, ona görə React heç vaxt sabit dəyər görmür. React 19 əvvəlcə "The result of getSnapshot should be cached to avoid an infinite loop" yazır, sonra "Maximum update depth exceeded" ilə dayanır. Düzəlişlər:

JSX
const count = useSyncExternalStore(store.subscribe, () => store.getState().todos.length);

const { count, add } = useTodoStore(
  useShallow((state) => ({ count: state.todos.length, add: state.add })),
);

Birincisi primitiv qaytarır. İkincisi Zustand-dır: onun sənədləri xəbərdarlıq edir ki, v5-də hər render-də yeni referans qaytaran selector sonsuz yeniləmə dövrünə səbəb ola bilər, useShallow isə sahələri səthi bərabər qaldıqca əvvəlki obyekti qaytarır. React-Redux üçüncü yolla gedir: seçimi memo edən useSyncExternalStoreWithSelector-dan istifadə edir.

Daha iki qayda

  • subscribe sabit olmalıdır. Hər render-də yeni funksiya React-i hər dəfə abunəni ləğv edib yenidən abunə olmağa məcbur edir; onu komponentdən kənarda elan et və ya memo et.
  • Snapshot-lar immutable-dır. Mənbə dəyişkəndirsə, keşlənmiş snapshot qaytar və onu yalnız data dəyişəndə əvəz et.

Server render üçün üçüncü arqument — getServerSnapshot — serverdə və hydration zamanı eyni dəyəri qaytarmalıdır; onsuz komponenti serverdə render etmək xəta atır. Zustand ora store-un ilkin state-ini ötürür, server render-in ilkin state-i göstərməsinin səbəbi budur.

SeniorFramework

Server state-i state deyil, keşdir

TanStack Query sənədləri server state-ini fərqli edən şeyləri sadalayır: o, nəzarət etmədiyin yerdə uzaqda saxlanır, asinxron API-lər tələb edir, onu dəyişə bilən başqa insanlarla bölüşülür və köhnələ bilər. Onu client store-da { data, loading, error } kimi saxlamaq keşi əl ilə yazmaq deməkdir: nə vaxt yenidən sorğulamaq, təkrar sorğulardan necə qaçmaq, köhnə data-nı necə atmaq, ardıcıllığı pozulmuş cavablarla nə etmək. Tətbiqlərin çoxu bunların bir hissəsini səhv edir.

Server state kitabxanası keşi öz üzərinə götürür:

JSX
function useProducts(sort) {
  return useQuery({
    queryKey: ["products", { sort }],
    queryFn: () => fetchProducts({ sort }),
    staleTime: 60_000,
  });
}

function useAddReview() {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: postReview,
    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["products"] }),
  });
}

TanStack Query necə davranır (v5)

  • Hər key üçün bir keş girişi. queryKey sabit sətrə hash olunur. Eyni key-li iki komponent bir query-ni bölüşür, ona görə hər ikisi birlikdə mount olanda bir sorğu gedir (deduplikasiya). Query funksiyasının istifadə etdiyi hər dəyər key-də olmalıdır; biri çatışmırsa, fərqli sorğular bir girişi bölüşür — məsələn, bir filtrin nəticələri digəri üçün göstərilir.
  • staleTime-ın default-u 0-dır: keşlənmiş data dərhal köhnəlmiş sayılır. Köhnəlmiş data yenə dərhal göstərilir; query-ni istifadə edən yeni komponent mount olanda, pəncərə yenidən fokuslananda və şəbəkə bərpa olunanda arxa planda yenidən sorğulanır. Köhnəlmə məhz bu anlarda yoxlanılır; sadəcə vaxt bitdiyinə görə heç nə sorğulanmır.
  • gcTime-ın default-u 5 dəqiqədir: mount olunmuş istifadəçisi qalmayan (qeyri-aktiv) query bundan sonra silinir.
  • Uğursuz sorğular xəta göstərilməzdən əvvəl eksponensial gecikmə ilə 3 dəfə təkrarlanır.
  • Structural sharing: eyni JSON qaytaran yenidən sorğu köhnə referansları saxlayır, ona görə komponentlər və memo edilmiş selector-lar dəyişiklik görmür.
  • invalidateQueries uyğun gələn query-ləri köhnəlmiş kimi işarələyir (key prefiksi onunla başlayan bütün key-lərə uyğun gəlir) və hazırda render olunanları yenidən sorğulayır.

isPending hələ data olmadığını bildirir; isFetching isə istənilən sorğu zamanı, arxa plandakı yenidən sorğu da daxil olmaqla, true olur. isFetching üçün spinner göstərmək hər pəncərə fokusunda loader-in yanıb-sönməsinə səbəb olur.

TanStack Query: useQuery-nin həyatı turu bir çağırışı QueryClient, QueryCache, Query və QueryObserver boyunca izləyir: hər key üçün bir ortaq query, hər komponent üçün bir observer.

Client store-a nə qalır

TanStack sənədləri açıq deyir ki, kitabxana client state idarəetməsini əvəz etmir. Server data-sı query keşinə köçəndən sonra qalan qlobal client state-i adətən kiçik olur: tema, qaralama, UI flag-ları, bəzən səbət. Əsl qazanc da budur: client store yalnız client-in həqiqətən sahib olduğu şeylərə qədər kiçilir.

SeniorTipik səhvlər

Düzgün yeri seçmək və tipik səhvlər

Redux Toolkit, Zustand və ya sadə context arasında seçim hər state parçası üçün düzgün yeri seçməkdən az əhəmiyyətlidir. "State idarəetməsi problemlərinin" çoxu səhv yerdə saxlanan state-dir. Bu sualları ardıcıllıqla ver:

  1. Onu hesablamaq olarmı — props-dan, başqa state-dən və ya URL-dən? Onda saxlama.
  2. Serverdən gəlir? Server state keşi və ya framework-ün data yükləməsi; client store-da surəti heç vaxt.
  3. Səhifə yenilənəndə qalmalı və ya paylaşıla bilməlidir? URL.
  4. Doldurulmaqda olan formdur? Formun özü və ya form kitabxanası.
  5. Ondan bir komponent istifadə edir? Orada useState.
  6. Bir neçə yaxın komponent istifadə edir? Ortaq valideynə qaldır.
  7. Çox sayda uzaq komponent oxuyur və nadir dəyişir? Context.
  8. Çox sayda komponentin hər birinə onun bir hissəsi lazımdır və tez dəyişir? Selector-lu xarici store.

Real kodda rast gəlinən səhvlər

  • API data-sının Redux-a və ya Zustand-a kopyalanması. Data köhnəlir, eyni siyahını üç komponent ayrı-ayrı sorğulayır, hər mutasiya isə bir neçə yerdə əl ilə yeniləmə tələb edir.
  • Filtrlər və səhifələmə useState-də. Refresh onları itirir, Back düyməsi onlara məhəl qoymur, linki isə heç kim paylaşa bilmir.
  • Hər düymə basışı qlobal store-da. Hər dəyişiklik bütün abunəçilərin selector-larını işə salır və lokal davranışı qlobal edir. Input state-ini lokal saxla və onu submit zamanı və ya debounce ilə ötür.
  • Bir nəhəng context. Hər dəyişiklikdə hər istehlakçı yenidən render olunur.
  • Səthi müqayisəsiz yeni obyekt quran selector-lar: hər dəyişiklikdə re-render və ya sonsuz dövr.
  • Bir state-i digərinə sinxronlaşdıran effektlər. İkinci dəyəri hesablamaq olursa, hesabla; hadisəyə reaksiyadırsa, onu event handler-də et.
  • State-i dəyişdirib (mutate edib) UI-ın niyə yenilənmədiyinə təəccüblənmək.

Praktik default

Tipik React tətbiqi üçün: lokal olaraq useState və useReducer, paylaşılan hər şey üçün URL, API data-sı üçün server state kitabxanası (və ya Server Components və loader-lər), qalanı üçün isə bir kiçik client store və ya bir-iki fokuslu context. Kitabxananı real ehtiyac yarananda əlavə et: çox sayda komponent tez dəyişən state-in hissələrini oxuyanda, logging və ya persistence kimi middleware lazım olanda, ya da devtools istəyəndə.

SeniorMüsahibə məsləhətləri

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

30 saniyəlik cavab. "Əvvəlcə state-in növünü müəyyən edirəm: lokal UI, ortaq client, server, URL və ya form state-i. Hər birinin təbii yeri var: useState, ortaq valideyn və ya context, server state keşi, URL, form. Hesablana bilən şeyi saxlamıram. Çox komponentin oxuduğu ortaq state üçün useSyncExternalStore üzərində selector-lu xarici store istifadə edirəm ki, komponentlər yalnız öz hissələri dəyişəndə render olunsun."

Gözlənilən suallar

  • Context, yoxsa Redux/Zustand? Context dəyəri aşağı ötürür; o dəyişəndə hər istehlakçı yenidən render olunur. Selector-lu store isə hər komponentə bir hissəyə abunə olmağa imkan verir. Context nadir dəyişən dəyərlər üçündür (tema, hesab, locale).
  • Komponentlərim niyə yenidən render olunur? Səbəbləri bir-bir say: valideyn render olunub, context-in yeni dəyəri (çox vaxt inline obyekt), yeni obyekt qaytaran selector, iki dəfə saxlanıb effektdə sinxronlaşdırılan state.
  • Niyə immutable yeniləmələr? React, memo, dependency array-lər və selector-lar referansları Object.is ilə müqayisə edir. Mutasiya eyni referansı verir, ona görə heç nə yenilənmir; dəyişən yolu kopyalamaq isə dəyişməyən hissələri eyni saxlayır.
  • Tearing nədir və useSyncExternalStore niyə var? Concurrent render fasilə verə bilər; o vaxt dəyişən store bir ekranda iki dəyər göstərir. useSyncExternalStore commit-dən əvvəl snapshot-ı yoxlayır və bloklayan render-ə keçir.
  • API data-sını niyə Redux-da saxlamayaq? Server state-inə keşləmə, deduplikasiya, arxa planda yenidən sorğulama və invalidasiya lazımdır. staleTime (default 0), gcTime (5 dəqiqə) və invalidateQueries-i adlandır.
  • Kiçik store yaz. state saxlayan closure, listener-lərdən ibarət Set, getState, Object.is yoxlaması olan setState, abunəni ləğv edən funksiya qaytaran subscribe və useSyncExternalStore üzərində hook.

Bal itirdən səhvlər

  • memo-nun context re-render-lərini dayandırdığını demək. Dayandırmır.
  • getSnapshot-dan və ya selector-dan səthi bərabərlik olmadan yeni obyekt qaytarmaq.
  • "Qlobal state"-i server, URL və client state-inə ayırmaq əvəzinə bir səbət kimi görmək.
  • State-i təsvir etməzdən əvvəl kitabxana seçmək.

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

Kompromislərlə danış: sinxron store yeniləmələri və transition-lar, provider dəyərinin qiyməti və selector abunələri, hər girişi əhatə edən keş key-ləri, arxitekturanı dəyişməzdən əvvəl re-render problemini React DevTools Profiler ilə necə ölçərdin.

JuniorYoxlama siyahısı

State-i və store-ları review edərkən nəyi yoxlamalı

Yazmadığın state kodunu — komanda yoldaşının, kitabxananın və ya AI assistentin kodunu — review edəndə bu siyahıdan istifadə et. State bug-larının çoxu səhv yerdə və ya səhv formada saxlanan state-dir: uyğunluğunu itirən iki surət, refresh-dən sonra itən filtr, yenilənməyən ekran.

  • Hansısa state hesablana bilən şeyin surətidirmi? Effektlə sinxron saxlanan useState əvvəlcə köhnə data ilə render olunur, hansısa kod yolu onu unudan kimi isə uyğunluğunu itirir; dəyəri render zamanı hesabla. Elementin surətini yox, selectedId saxla, prop-u da useState-ə kopyalama: onun arqumenti yalnız ilk render-də oxunur.
  • State mutasiya olunmadan dəyişdirilirmi? React, memo və selector-lar referansları Object.is ilə müqayisə edir, ona görə state-i push, sort() və ya state.field = … ilə dəyişdirmək ekranı yeniləmir. Dəyişən hər səviyyə yeni obyekt və ya massiv olmalıdır, məsələn, { ...state, lines }.
  • API data-sı client store-da surət kimi yox, server state keşində saxlanırmı? Surət köhnəlir, bir neçə komponent onu ayrı-ayrı sorğulayır, hər mutasiyadan sonra isə əl ilə yenilənməlidir. Query keşində query funksiyasının istifadə etdiyi hər dəyər key-də olmalıdır, yoxsa fərqli sorğular bir girişi bölüşür.
  • Filtrlər, sıralama və səhifə nömrəsi URL-də saxlanırmı? useState-də olanda refresh onları itirir, Back düyməsi onlara məhəl qoymur, linki isə paylaşmaq olmur. Filtr seç, səhifəni yenilə və Back düyməsini bas.
  • Selector-lar və getSnapshot primitiv və ya mövcud referans qaytarırmı? Yeni qurulan obyekt və ya massiv ({ count, total }, .map(…)) hər çağırışda yenidir: komponent store-un hər dəyişikliyində yenidən render olunur, useSyncExternalStore ilə isə sonsuz dövrə girə bilər. Dəyərləri bir-bir seç və ya səthi müqayisə et.

Ö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.

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

  • Quiz

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

    6 sual

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

Buna əsaslanan real kitabxanaların mənbə kodu üzrə bələdçili turlar.