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

React və render

Reconciliation və re-render

React komponentinin nə vaxt render olunduğu, React-in element ağaclarını necə müqayisə edib nəyi saxlayacağına necə qərar verdiyi və lazımsız re-render-ləri necə dayandırmaq: key-lərdən və state-in mövqeyindən memo-ya, context-ə, batching-ə və React Compiler-ə qədər.

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

İlkin şərt yoxdur.

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

JuniorKonsepsiya

Render nədir və onu nə işə salır

React-də render React-in sənin komponentini çağırması deməkdir — nəyi göstərməli olduğunu öyrənmək üçün funksiyanı icra etməsi. Bu, səhifəni dəyişmək demək deyil: -a sonra və yalnız fərq olan yerlərdə toxunulur.

Komponent bu səbəblərdən biri ilə render olunur:

  1. İlk render — createRoot(container).render(<App />) ilə başlayır.
  2. Öz state-i dəyişib — useState-in set funksiyası və ya useReducer-in dispatch-i render-i növbəyə qoyub.
  3. Valideyni render olunub. Default olaraq komponent render olunanda React onun qaytardığı bütün komponentləri ən aşağıya qədər render edir — props-ları dəyişib-dəyişməməsindən asılı olmayaraq.
  4. Oxuduğu context dəyişib: ən yaxın provider fərqli value alanda həmin context-i oxuyan hər komponent render olunur.

"Props-u dəyişib" bu siyahıda yoxdur: props yalnız valideyn render olunduğu üçün dəyişir, bu da 3-cü səbəbdir.

JSX
import { useState } from "react";

function App() {
  const [count, setCount] = useState(0);
  console.log("render App", count);
  return (
    <>
      <button onClick={() => setCount(count + 1)}>Clicked {count} times</button>
      <Hint />
    </>
  );
}

function Hint() {
  console.log("render Hint");
  return <p>Press the button</p>;
}

Hər klik yeni sayla render App, həm də render Hint çap edir. Hint-in props-u yoxdur və eyni mətni göstərir, amma valideyni render olunduğu üçün React onu yenidən çağırır. Sonra React nəticəni əvvəlki ilə müqayisə edir: düymənin mətni dəyişib, ona görə React həmin bir mətn node-unu yeniləyir; <p> isə eynidir, onun DOM node-una toxunulmur.

Bu niyə adətən problem deyil

Kiçik funksiyanı çağırmaq ucuzdur; baha olan DOM işi, layout və paint-dir. Eyni nəticə verən re-render heç bir DOM işi görmür. Re-render-lər ağacın yuxarısındakı komponent tez-tez yenilənəndə (hər hərfdə, scroll-da, taymerin hər tikində) və altındakı ağac böyük və ya ləng render olunanda problemə çevrilir. Mövzunun qalan hissəsi məhz bu barədədir.

Başlanğıc üçün iki vərdiş

  • Render təmiz olmalıdır: eyni props, state və context xarici dəyişənləri və DOM-u dəyişmədən eyni nəticəni verməlidir. Development-də Strict Mode təmiz olmayan komponentləri üzə çıxarmaq üçün onları iki dəfə çağırır, ona görə render-dəki console.log iki dəfə görünə bilər.
  • Düzəltməzdən əvvəl öyrən. React DevTools Profiler hansı komponentlərin və niyə render olunduğunu yazır, DevTools-un "Highlight updates when components render" ayarı isə render olunan hər komponenti işıqlandırır.
JuniorKonsepsiya

Render və commit: elementlər təsvirdir

react.dev-in təsvirinə görə ekranın hər yenilənməsi üç addımdan keçir: trigger (ilk render və ya state yeniləməsi), render (React komponentlərini çağırır) və commit (React DOM-u dəyişir). Commit-dən sonra brauzer ekranı çəkir.

Elementlər: UI-ı təsvir edən adi obyektlər

JSX funksiya çağırışlarına kompilyasiya olunur və onlar element qaytarır — təlimat yox, nəyin göstərilməli olduğunu deyən kiçik obyektlər:

JSX
const heading = <h1 className="title">Hello</h1>;
console.log(heading.type, heading.props);
// h1 { className: 'title', children: 'Hello' }

const profile = <Profile userId={7} />;
console.log(profile.type === Profile, profile.props);
// true { userId: 7 }

Elementin type-ı ("h1" kimi teq adı və ya sənin komponent funksiyan), props-u və key-i var. <Profile userId={7} /> yaratmaq Profile-ı çağırmır; React onu sonra, render zamanı ağacda bu elementə rast gələndə çağırır.

Render: növbəti ağacı qurmaq

React yenilənməli olan komponenti çağırır, qaytardığı elementləri götürür, onların içindəki komponentləri çağırır və belə davam edir. Yeni elementləri əvvəlki dəfə render etdikləri ilə müqayisə edir — bu müqayisə reconciliation adlanır — və dəyişiklikləri müəyyənləşdirir: hansı DOM node-larını yaratmaq, hansı atributları və mətni yeniləmək, hansı node-ları silmək lazımdır. Nəyin render olunduğunu yadda saxlamaq, hər komponentin state-ini və hook-larını saxlamaq üçün React öz fiber ağacını (hər komponent nüsxəsi və ya host element üçün bir fiber) saxlayır.

Render zamanı hələ görünən heç nə baş vermir. React 18 və sonrakı versiyalarda React təcili olmayan render-i (transition) dayandıra və ya atıb yenidən başlaya bilər; bu da render-in təmiz olmalı olmasının daha bir səbəbidir.

Commit: minimal dəyişiklikləri tətbiq etmək

Commit zamanı React dəyişikliklər siyahısını DOM-a tətbiq edir, ref-ləri bağlayır və layout effektlərini icra edir; useEffect effektləri bundan sonra, adətən brauzer ekranı çəkəndən sonra işləyir. İlk render-də React bütün ağacı appendChild() ilə əlavə edir. Sonrakı render-lərdə isə React yalnız fərqlənən DOM node-larını dəyişir: react.dev-in nümunəsində saat hər saniyə <h1>-i yeniləyir, yanındakı <input> isə istifadəçinin yazdığını saxlayır, çünki React input-u heç vaxt əvəz etmir.

Zehni model

  • setState → React həmin komponentin render-ini planlaşdırır.
  • Render → funksiyaların icra olunur və element qaytarır; React onları əvvəlki ağacla müqayisə edir.
  • Commit → DOM-a yalnız fərqlər çatır; sonra brauzer layout və edir.

Platformadakı Mini React build layihəsində bu pipeline-ı özün yazırsan: createElement, DOM-a render, reconciliation və key-lər, funksional komponentlər, useState, batching və useEffect.

MiddleVeb platforma

React ağacları necə müqayisə edir: tip, mövqe, key

İki ixtiyari ağacı optimal müqayisə etmək çox yavaşdır — ümumi alqoritmlər O(n³)-dür. React isə köhnə React sənədlərində açıq yazılmış iki fərziyyəyə əsaslanan O(n) evristikasından istifadə edir: fərqli tipli elementlər fərqli ağaclar yaradır, key-lər isə hansı uşaq elementlərin render-lər arasında eyni qaldığını React-ə bildirir.

Eyni mövqedə eyni tip: saxla və yenilə

Mövqedəki elementin type-ı əvvəlki dəfə ilə eynidirsə, React DOM node-unu və ya komponent nüsxəsini saxlayır və yalnız dəyişəni — atributları, mətni, props-u — yeniləyir. Komponent öz state-ini saxlayır.

JSX
function Scoreboard({ isFancy, isPaused }) {
  if (isPaused) return <p>See you later!</p>;
  return isFancy ? <Counter fancy /> : <Counter />;
}

isFancy-ni dəyişmək Counter-in sayını saxlayır: hər iki budaqda o, eyni yerdə duran Counter-dir. React JSX sətirlərinə baxmır; vacib olan render olunmuş ağacdakı mövqedir, ona görə də if-in fərqli budaqlarındakı iki <Counter /> eyni slota düşürsə, "eyni sayğac" sayılır.

Fərqli tip: bütün alt ağacı yenidən mount et

isPaused true olanda slotda Counter yox, <p> olur. React Counter-i unmount edir (effektləri təmizlənir, state-i itir), onun DOM-unu silir və <p>-ni sıfırdan qurur. Geri keçəndə 0-dan başlayan təzə Counter mount olunur. Eyni şey bir səviyyə yuxarıda da baş verir: eyni Counter-i bir render-də <section>-a, növbətisində <div>-ə bükmək içindəki hər şeyi sıfırlayır, çünki valideynin tipi dəyişib.

Bunun izah etdiyi bug: komponent içində təyin olunan komponentlər

JSX
function SignupForm() {
  const [email, setEmail] = useState("");

  function EmailField() {
    return <input value={email} onChange={(e) => setEmail(e.target.value)} />;
  }

  return <EmailField />;
}

SignupForm-un hər render-i yeni EmailField funksiyası yaradır, ona görə də React eyni mövqedə fərqli tip görür və hər hərfdə input-u yenidən mount edir. Input hər hərfdən sonra fokusu itirir. Komponentləri modulun üst səviyyəsində elan et, heç vaxt başqa komponentin içində yox.

State-i key ilə qəsdən sıfırlamaq

key mövqenin bir hissəsinə çevrilir. Bunu render etmək

JSX
<Chat key={contact.id} contact={contact} />

hər kontakta öz Chat-ini verir: kontakt dəyişəndə köhnəsi unmount, yenisi mount olunur, yarımçıq yazılmış mesaj səhv adama getmir. Key-lər yalnız qardaş elementlər arasında unikal olmalıdır, qlobal yox.

MiddleTipik səhvlər

Siyahılarda key-lər və indeks key-lərinin bug-ları

Siyahıda React yeni uşaq elementləri köhnələri ilə uyğunlaşdırmalıdır. Key olmasa, yalnız mövqeyə görə uyğunlaşdıra bilər: birinci uşağı birinci ilə və s. Sona əlavə etmək problem deyil, amma əvvələ əlavə edəndə hər mövqedə başqa element olur və React bütün uşaqları yeniləyir. Key-lər React-ə uşaqları kimliyə görə uyğunlaşdırmağa imkan verir: yeri dəyişən, əlavə olunan və ya silinən element öz DOM node-unu və state-ini saxlayır.

İndeks key-ləri state-i səhv elementə köçürür

JSX
function ShoppingList({ items }) {
  return (
    <ul>
      {items.map((item, index) => (
        <li key={index}>
          {item.name} <input placeholder="Note" />
        </li>
      ))}
    </ul>
  );
}

İstifadəçi Milk-in yanındakı qeydə "2 l" yazır. Sonra siyahının başına element əlavə olunur. key={index} ilə Eggs 0 key-ini alır — Milk-in key-ini — ona görə də React Milk-in <li>-ni və <input>-unu Eggs üçün istifadə edir: "2 l" qeydi artıq səhv elementin yanındadır, digər sətirlər də sürüşür. Sıralamadan və ya silmədən sonra da eyni şey olur. key={item.id} ilə React başda yeni key görür, bir yeni sətir yaradır və başqa heç nəyi yerindən oynatmır.

İndeks key-i yalnız siyahı heç vaxt sıralanmırsa, ortasına element əlavə və ya oradan silinmirsə və elementlərin öz state-i yoxdursa (idarə olunmayan input-lar və fokus da daxil) təhlükəsizdir. Key verməsən, React indeksdən istifadə edir və çatışmayan key barədə xəbərdarlıq edir.

Digər key səhvləri

  • Render zamanı yaradılan key-lər — map-in içində key={Math.random()} və ya crypto.randomUUID(). Key-lər render-lər arasında heç vaxt üst-üstə düşmür, ona görə React hər render-də bütün sətirləri və onların DOM-unu yenidən yaradır: yavaşdır və sətirlərdəki input itir. Id-ləri data render olunanda yox, yaradılanda yarat.
  • Qardaş elementlər arasında təkrarlanan key-lər: React xəbərdarlıq edir, yeniləmədə elementlər təkrarlana və ya itə bilər.
  • key-i prop kimi gözləmək. Komponent key-i almır; id-ni ayrıca ötür: <Row key={id} id={id} />.
  • Key-i səhv elementə yazmaq: key map-dən qaytarılan ən xarici elementə yazılır, onun içindəki nəyəsə yox.

Key-lər həm də alətdir

Dəyişən key "başqa element" demək olduğu üçün alt ağacı qəsdən sıfırlaya bilərsən: <Form key={user.id} /> state-i "sinxronlaşdıran" effekt olmadan hər istifadəçi üçün təzə forma açır.

MiddleNümunə

Re-render kaskadları və onları memo-suz dayandırmaq

State yeniləməsi state-in sahibi olan komponenti və ondan aşağıdakı hər şeyi yenidən render edir. Həmin state ağacın yuxarısında yaşayırsa və tez-tez dəyişirsə, ardınca render-lər kaskadı gəlir. memo-ya əl atmazdan əvvəl strukturu düzəlt — react.dev də əvvəlcə bunları tövsiyə edir.

State-i aşağı köçür

Tutaq ki, foto səhifəsi şərh qutusunun mətnini öz state-ində, 200 fotoluq qalereyanın yanında saxlayır: hər hərf səhifəni və bütün qalereyanı yenidən render edir. Mətn yalnız textarea-ya lazımdır, ona görə ona ayrıca komponent ver:

JSX
function CommentBox() {
  const [comment, setComment] = useState("");
  return <textarea value={comment} onChange={(e) => setComment(e.target.value)} />;
}

function PhotoPage({ photos }) {
  return (
    <>
      <PhotoGrid photos={photos} />
      <CommentBox />
    </>
  );
}

İndi yazmaq yalnız CommentBox-u yenidən render edir. PhotoGrid state sahibinin uşağı yox, qardaşıdır.

Məzmunu yuxarı qaldır: JSX-i children kimi ötür

Bəzən state məhz baha hissəni əhatə etməlidir — məqalənin ətrafında oxuma göstəricisi, formanın ətrafında modal:

JSX
function ReadingProgress({ children }) {
  const [progress, setProgress] = useState(0);
  return (
    <div className="reader" onScroll={(e) => setProgress(scrolledShare(e.currentTarget))}>
      <ProgressBar value={progress} />
      {children}
    </div>
  );
}

function ArticlePage({ article }) {
  return (
    <ReadingProgress>
      <Article article={article} />
    </ReadingProgress>
  );
}

Scroll progress-i yeniləyir və ReadingProgress-i yenidən render edir, amma <Article />-i render olunmamış ArticlePage yaradıb. children əvvəlki dəfəki eyni element obyektidir, ona görə də React Article alt ağacını ötürür. State komponentə, məzmun isə onun valideyninə məxsusdur.

Baha işi əlaqəsiz render-lərdən kənarda saxla

Gövdəsində yüzlərlə elementi sıralayan və ya filtrləyən komponent bu işi hər state dəyişikliyində təkrarlayır — siyahı ilə heç bir əlaqəsi olmayan dəyişikliklərdə də, məsələn, yanındakı toggle və ya mətn sahəsi dəyişəndə. Həmin əlaqəsiz state-i ayrıca komponentə köçür (yenə state-i aşağı salmaq) və ya nəticəni cache-lə: useMemo(() => sortProducts(products, sortKey), [products, sortKey]) yalnız girişləri dəyişəndə yenidən sıralayır.

Yoxlama siyahısı

  1. Ən tez-tez hansı state dəyişir və onun sahibi hansı komponentdir?
  2. Bu state onu oxuyan yeganə hissənin yanında, daha aşağıda yaşaya bilərmi?
  3. Baha hissəni children və ya başqa JSX prop-u kimi ötürmək olarmı?
  4. Render-də dəyişən şeydən asılı olmayan baha hesablama varmı?

Yalnız cavablar "yox" olanda — state həqiqətən yuxarıda lazımdır və uşaqlar bahadır — memoizasiya alətə çevrilir.

SeniorFramework

memo, useMemo, useCallback — və onlar nə vaxt boşa gedir

React-də girişlər eyni olanda əvvəlki nəticəni təkrar istifadə etmək deməkdir.

  • memo(Component) hər prop əvvəlki dəfə ilə Object.is müqayisəsinə görə bərabər olanda re-render-i ötürür.
  • useMemo(fn, deps) hesablanmış dəyəri asılılıq dəyişənə qədər render-lər arasında cache-də saxlayır.
  • useCallback(fn, deps) funksiyanı cache-də saxlayır; o, useMemo(() => fn, deps)-dir.
JSX
import { memo, useCallback, useMemo, useState } from "react";

const ProductRow = memo(function ProductRow({ product, onSelect }) {
  return <li onClick={() => onSelect(product.id)}>{product.name}</li>;
});

function ProductList({ products, query }) {
  const [selectedId, setSelectedId] = useState(null);
  const visible = useMemo(
    () => products.filter((product) => product.name.includes(query)),
    [products, query],
  );
  const handleSelect = useCallback((id) => setSelectedId(id), []);

  return (
    <>
      <p>Selected: {selectedId ?? "none"}</p>
      <ul>
        {visible.map((product) => (
          <ProductRow key={product.id} product={product} onSelect={handleSelect} />
        ))}
      </ul>
    </>
  );
}

Məhsul seçmək ProductList-i yenidən render edir, amma heç bir sətir render olunmur: hər sətrin product-u və onSelect-i əvvəlki kimidir, filtr də yenidən işləmir, çünki products və query dəyişməyib. useCallback olmasaydı, onSelect hər render-də yeni funksiya olardı və bütün sətirlər onsuz da render olunardı.

Memoizasiya nə vaxt boşa gedir

  • Hər render-də yeni olan props — inline style={{ … }}, onClick={() => …}, JSX children: memo müqayisə edir, fərq tapır və yenə render edir.
  • Ucuz komponentlər: props-u müqayisə etmək render qədər baha başa gələ bilər.
  • Komponentin öz state-indən və ya context-dən gələn render-lər: memo yalnız props-a baxır.
  • Sürətli hesablamalar: react.dev console.time ilə ölçməyi və təxminən 1 ms-dən başlayaraq memoizasiya etməyi təklif edir.
  • Düzgünlük: useMemo zəmanət yox, performans ipucudur və React cache-i ata bilər. Səhv dependency array isə, məsələn, useCallback(fn, []), ilk render-in dəyərlərini dondurur — bu, -dur.

React Compiler

React Compiler 1.0 7 oktyabr 2025-dən stabildir: Rules of React-ə əməl edən və komponentləri və hook-ları avtomatik memoizasiya edən build-time alətdir (babel-plugin-react-compiler), hətta early return-dən sonra da — əl ilə yazılan hook-ları orada çağırmaq olmur. React 17 və sonrakı versiyaları dəstəkləyir (17 və 18 üçün react-compiler-runtime lazımdır); yalnız komponentlərin və hook-ların içində memoizasiya edir və cache-ləri komponentlər arasında bölüşmür.

Compiler ilə memo adətən lazım olmur. Yeni kodda ona güvən, useMemo/useCallback-i isə escape hatch kimi saxla, məsələn, effekt asılılığı olan dəyər üçün. Mövcud kodda react.dev əl ilə yazılmış memoizasiyanı yerində saxlamağı və ya silməzdən əvvəl diqqətlə test etməyi məsləhət görür, çünki bu, kompilyasiya nəticəsini dəyişə bilər.

SeniorFramework

Context: bir dəyişiklik niyə bütün consumer-ləri yenidən render edir

Context dəyəri props olmadan provider-dən aşağıdakı hər komponentə ötürür. Performans qaydası qısadır: provider fərqli value alanda (Object.is-ə görə), həmin context-i oxuyan hər komponent provider-dən başlayaraq yenidən render olunur. memo bunu dayandırmır — o, yalnız props-u müqayisə edir.

Bir böyük context

Tutaq ki, dashboard paylaşdığı hər şeyi bir dəyərdə saxlayır: dil, bildirişlər siyahısı (yeniləri bir neçə saniyədən bir gəlir) və bildirişi bağlayan funksiya:

JSX
function AppProvider({ locale, children }) {
  const [notifications, setNotifications] = useState([]);
  const dismiss = (id) => setNotifications((list) => list.filter((n) => n.id !== id));

  return (
    <AppContext value={{ locale, notifications, dismiss }}>
      {children}
    </AppContext>
  );
}
  1. value hər render-də yeni obyektdir, ona görə də provider hər dəfə render olunanda bütün consumer-lər yenidən render olunur.
  2. Onu useMemo-ya bükəndə də hər yeni bildiriş dəyəri dəyişir və bütün consumer-lər yenidən render olunur — rəqəmləri formatlamaq üçün yalnız dilə ehtiyacı olan onlarla widget da daxil.

Birlikdə dəyişənlərə görə böl

JSX
function AppProvider({ locale, children }) {
  const [notifications, setNotifications] = useState([]);
  const dismiss = useCallback(
    (id) => setNotifications((list) => list.filter((n) => n.id !== id)),
    [],
  );

  return (
    <LocaleContext value={locale}>
      <NotificationActionsContext value={dismiss}>
        <NotificationsContext value={notifications}>{children}</NotificationsContext>
      </NotificationActionsContext>
    </LocaleContext>
  );
}

function RevenueWidget({ total }) {
  const locale = useContext(LocaleContext);
  return <p>{new Intl.NumberFormat(locale).format(total)}</p>;
}
  • Hər provider render-lər arasında sabit qalan dəyər alır: primitiv, state dəyəri və ya useCallback-dən gələn funksiya.
  • Consumer-lər yalnız lazım olanı oxuyur. RevenueWidget yalnız dil dəyişəndə dəyişən LocaleContext-i oxuyur, ona görə də yeni bildiriş widget-ləri artıq yenidən render etmir.
  • Yalnız bir komponentə lazım olan state (mətn sahəsindəki qaralama) ümumiyyətlə context-ə aid deyil: onu həmin komponentdə saxla.

react.dev-in state üçün bir, dispatch üçün başqa context şablonu yaxşı başlanğıcdır; state-in hissələri fərqli tezliklə dəyişirsə, daha da böl.

Daha az seçmək

Context-in daxili selector-u yoxdur: consumer bir sahədən istifadə etsə də, dəyər dəyişəndə yenidən render olunur. Çoxlu komponent tez dəyişən datanın fərqli hissələrini oxuyursa, selector-lu store-dan istifadə et: useSyncExternalStore ilə oxunan store-lar (Zustand və Redux belə işləyir) komponenti yalnız onun seçdiyi hissə dəyişəndə yenidən render edir.

React 19-dan context birbaşa öz provider-i kimi render olunur (<LocaleContext value={locale}>), yuxarıdakı kodda olduğu kimi.

SeniorVeb platforma

Batching və setState-in içində nə baş verir

set funksiyası əlindəki dəyişəni dəyişmir — o, yeniləməni növbəyə qoyur və React-dən yenidən render etməyi xahiş edir. Cari render-in count-u növbəti render-ə qədər eyni qalır; react.dev state-i snapshot adlandırır.

Avtomatik batching

React event handler-dəki bütün kod icra olunana qədər gözləyir, sonra bütün yeniləmələr üçün bir dəfə render edir — bu, -dir. React 18-dən (createRoot ilə) yeniləmələr hər yerdə batch olunur: event handler-lərdə, timeout-larda, promise callback-lərində və native event listener-lərində. React 18-dən əvvəl yalnız React event handler-lərinin içindəki yeniləmələr batch olunurdu. React ayrı-ayrı qəsdən edilən hadisələri birləşdirmir: hər klik ayrıca emal olunur.

Yeniləmə növbəsi

JSX
function handleClick() {
  setNumber(number + 5);
  setNumber((n) => n + 1);
  console.log(number);
}

Bu render-də number 0-dır. Növbədə "5 ilə əvəz et", sonra n => n + 1 var. Handler 0 çap edir, növbəti render-də isə React növbəni ardıcıllıqla emal edir: 5, sonra 6. Adi dəyər özündən əvvəl növbəyə qoyulanları əvəz edir; updater funksiya isə əvvəlki yeniləmənin nəticəsini alır. Buna görə də setCount(c => c + 1) üç dəfə 3 əlavə edir, setCount(count + 1) üç dəfə isə 1.

Yeni dəyər cari state ilə eynidirsə (Object.is), React komponenti və onun uşaqlarını yenidən render etmir. Bəzən uşaqları ötürməzdən əvvəl komponenti bir dəfə çağırmalı olur; bu, gözlənilən davranışdır.

İmtina: flushSync

Nadir hallarda DOM-un dərhal yenilənməsi lazımdır, məsələn, yeni elementə scroll etmək üçün:

JSX
import { flushSync } from "react-dom";

function handleAdd(todo) {
  flushSync(() => {
    setTodos((list) => [...list, todo]);
  });
  listRef.current.lastChild.scrollIntoView();
}

flushSync callback-in içindəki yeniləməni sinxron render və commit edir. O, bahadır və main thread-i bloklayır — yalnız belə hallarda istifadə et.

React-in içində

Platformadakı "React: useState necə işləyir" (react-use-state, React v19.3.0) source tour-u bunu React-in kodu boyunca izləyir: useState cari dispatcher-dən soruşur, renderer isə onu mount və update arasında dəyişir; hər komponentin hook-ları onun fiber-indəki linked list-dir və çağırış sırasına görə tapılır (Rules of Hooks-un səbəbi budur); set çağırışı update yaradır, Object.is ilə erkən bailout edə bilər, onu hook-un update queue-suna əlavə edir, fiber-i və valideynlərini prioritet lane-i ilə işarələyir və neçə yeniləmə gəlməsindən asılı olmayaraq bir render planlaşdırır. Növbəti render növbəni ardıcıllıqla təkrar emal edir. Eyni ideyanın minimal versiyası yeniləmələri toplayır və onları bir birlikdə emal edir.

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

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

30 saniyəlik cavab. "Render React-in element — UI-ın təsviri — almaq üçün komponentlərini çağırmasıdır. Komponent mount olanda, state-i dəyişəndə, valideyni render olunanda və ya oxuduğu context dəyişəndə render olunur. React yeni elementləri əvvəlki ağacla müqayisə edir — eyni mövqedə eyni tip state-i saxlayır, fərqli tip yenidən mount olunur, key-lər siyahı elementlərini tanıdır — və DOM-a yalnız fərqləri commit edir."

Gözlənilən suallar

  • Re-render DOM-u yeniləyirmi? Xeyr: render komponentləri çağırır, commit olunan yalnız fərqlərdir.
  • Key-lər niyə vacibdir? Niyə indeks yox? Kimliyə görə və mövqeyə görə uyğunlaşdırma; input-un səhv sətrə keçməsini göstər.
  • Bu state niyə sıfırlandı? Eyni mövqedə fərqli tip, dəyişən sarğı element, başqa komponentin içində təyin olunan komponent və ya dəyişən key.
  • Səhifə yazarkən ləngiyir — nə edirsən? Əvvəlcə profil çıxar. Sonra state-i aşağı köçür, məzmunu children kimi ötür, sabit props ilə memoizasiya et, context-i böl, React Compiler-i nəzərdən keçir. Məşq üçün platformadakı çağırışları qeyd et: perf-typing-lag, perf-slow-filter, perf-context-storm.
  • Bu handler neçə render-ə səbəb olur? Batching: hər hadisəyə bir render, React 18-dən timeout-larda və promise-lərdə də; updater funksiyalar və adi dəyərlər.

Bal itirdən səhvlər

  • "React props dəyişəndə komponenti yenidən render edir" demək. O, valideyn render olunanda yenidən render edir; dəyişən props bunun nəticəsidir.
  • "Re-render DOM-u yenidən yaratmaq deməkdir" demək.
  • "Hər ehtimala qarşı" hər şeyi memo/useMemo-ya bükmək və ya memo-nun context yeniləmələrini blokladığını düşünmək.
  • Dəyişən siyahı üçün key kimi Math.random()-dan və ya indeksdən istifadə etmək.
  • React-in "virtual DOM-u real DOM ilə" müqayisə etdiyini demək. O, yeni elementləri canlı DOM ilə yox, özünün əvvəlki ağacı (fiber-lər) ilə müqayisə edir.

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

Trade-off-ları profildən götürülmüş rəqəmlərlə izah et; struktur düzəlişlərinin (state-i aşağı salmaq, children) niyə memoizasiyadan əvvəl gəldiyini, React Compiler-in bu tövsiyəni necə dəyişdiyini və state-in fiber-lərdə yeniləmələr növbəsi kimi necə yaşadığını bil.

JuniorYoxlama siyahısı

Key-ləri və re-render-ləri review edərkən nəyi yoxlamalı

Yazmadığın React komponentlərini — komanda yoldaşının, kitabxananın və ya AI assistentin kodunu — review edəndə bu siyahıdan istifadə et. Onsuz sıfırlanan və ya səhv sətrə düşən state, itən fokus və lazımsız re-render-lər gözdən qaçır.

  • Siyahı key-ləri indeksdən və ya Math.random()-dan yox, data-dan (item.id) götürülürmü? İndeks key-ləri element əlavə olunandan və ya siyahı sıralanandan sonra yazılmış mətni və fokusu səhv sətrə köçürür; təsadüfi key-lər isə hər render-də bütün sətirləri yenidən yaradır. Bir sətrə nəsə yaz, sonra siyahının başına element əlavə et: mətn öz elementinin yanında qalmalıdır.
  • Hansısa komponent başqa komponentin içində elan olunubmu? Hər render yeni funksiya, yəni React üçün yeni tip yaradır və komponent yenidən mount olunur: state itir, input isə hər hərfdən sonra fokusu itirir.
  • State-i olan komponent JSX dəyişəndə öz tipini və mövqeyini saxlayırmı? Başqa sarğı element (<section> əvəzinə <div>) və ya həmin slotda başqa element onu state-i ilə birlikdə unmount edir; sıfırlama lazımdırsa, state-i təmizləyən effekt yox, key olmalıdır, məsələn, <Form key={user.id} />.
  • Tez-tez dəyişən state böyük alt ağacın üstündə dayanırmı? Hər yeniləmə state-in sahibindən aşağıdakı hər şeyi yenidən render edir: state aşağı enə bilərmi, baha hissə children kimi ötürülə bilərmi? Nəyin və niyə render olunduğunu React DevTools Profiler göstərir.
  • memo-nun və context-in müqayisə etdiyi dəyərlər sabitdirmi? memo hər prop-u Object.is ilə yoxlayır, ona görə inline obyekt, funksiya və ya JSX children olanda komponent yenə render olunur; render zamanı qurulan value={{ … }} isə provider hər dəfə render olunanda bütün consumer-ləri yenidən render edir.

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

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