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

Brauzer və performans

Siyahı virtualizasiyası

Minlərlə DOM node-unun səhifəni niyə ləngitdiyi və windowing-in uzun siyahıları necə sürətli saxladığı: sabit hündürlüklü sətirlərin riyaziyyatından və sonsuz scroll-dan ölçülən hündürlüklərə, scroll anchoring-ə, əlçatanlığın qiymətinə və alternativlərə qədər.

MiddleSeniorYenilə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 Middle səviyyəsindən başlayır.

MiddleKonsepsiya

Minlərlə DOM node-u niyə yavaşdır

Ekrandakı bir sətir arxasındakı datadan qat-qat baha başa gəlir. JavaScript-də 10 000 obyekti filtrləmək bir neçə millisaniyə çəkir, onları 10 000 cədvəl sətrinə çevirmək isə yox. Hər element bir neçə mərhələdə "ödəniş" edir və bu xərc istifadəçinin gördüyü sətirlərin yox, bütün sətirlərin sayı ilə artır:

  1. Yaradılma. React hər sətir komponentini çağırır, onun elementlərini və fiber-lərini, sonra da DOM node-larını yaradır.
  2. Style. Brauzer hər element üçün selector-ları uyğunlaşdırır və style-ları hesablayır.
  3. . Hər qutu ölçü və mövqe alır. Default table-layout: auto ilə sütunların eni hər xananın məzmunundan asılıdır, ona görə də cədvəl sütunlarını ölçmək üçün bütün sətirlərin layout-unu hesablayır.
  4. Yaddaş. Sətirlər mövcud olduqca DOM node-ları, hesablanmış style-lar, layout obyektləri və React-in fiber-ləri yaddaşda qalır.
  5. Hər yeniləmə. Siyahının valideyni yenidən render olunanda — məsələn, axtarış qutusuna yazılan hər hərfdə — React bütün sətir komponentlərini yenidən çağırır və brauzer növbəti kadrı çəkməzdən əvvəl hər sətrin nəticəsini müqayisə edir.

Paint istisnadır: brauzer əsasən viewport-a yaxın olanı çəkir, ona görə də ekrandan kənar sətirlərin xərci azdır, amma yuxarıdakı bütün digər xərclər qalır.

JSX
function TransactionsTable({ transactions }) {
  return (
    <table className="transactions">
      <tbody>
        {transactions.map((t) => (
          <tr key={t.id}>
            <td>{t.date}</td>
            <td>{t.merchant}</td>
            <td>{t.category}</td>
            <td>{t.card}</td>
            <td>{t.amount}</td>
            <td>{t.status}</td>
          </tr>
        ))}
      </tbody>
    </table>
  );
}

Təsəvvür et: hər sətrində altı xana olan 10 000 tranzaksiyalıq cədvəl — 70 000 və daha çox element. Onlar səhifə açılanda bir uzun task-da yaradılır, filtr qutusuna yazılan hər hərfdə isə yenidən render olunur, halbuki scroll sahəsində bəlkə də cəmi on-on iki sətir görünür. Bir neçə yüz test qeydi ilə bunu heç kim hiss etmir; production datası ilə isə hər interaksiya saniyələr çəkir — INP məhz bunu ölçür.

Problemi necə tanımaq olar

  • Performance panelində -də uzun task: vaxtın çoxunu scripting (React sətirləri render edir), "Recalculate style" və "Layout" tutur.
  • Konsolda document.querySelectorAll("*").length. Lighthouse body-də təxminən 800-dən çox node olanda xəbərdarlıq edir, 1 400-dən çox olanda isə xəta göstərir (Lighthouse 13-dən bu yoxlama "Optimize DOM size" insight-ının içindədir).
MiddleKonsepsiya

Windowing: yalnız görünəni render et

Windowing (başqa adı virtualizasiya) bütün datanı yaddaşda saxlayır, amma yalnız viewport-un içindəki sətirləri, üstəlik yuxarıda və aşağıda bir neçə əlavə sətri render edir — buna overscan deyilir. Siyahıda 300 element olsa da, 300 000 olsa da, DOM-un ölçüsü dəyişmir.

Quruluş üç hissədən ibarətdir: sabit hündürlüklü və overflow-y: auto olan viewport; scrollbar düzgün ölçüdə və aralıqda olsun deyə bütün siyahı qədər hündür spacer; və öz yerinə sürüşdürülmüş, render olunan sətirlərdən ibarət pəncərə:

HTML
<div class="viewport" style="height: 400px; overflow-y: auto">
  <div class="spacer" style="position: relative; height: 40000px">
    <div class="window" style="transform: translateY(880px)">
      <div class="row" style="height: 40px">Row 22</div>
      <div class="row" style="height: 40px">Row 23</div>
      <div class="row" style="height: 40px">Row 24</div>
    </div>
  </div>
</div>

(Kitabxanalar adətən hər sətri ayrıca absolute mövqeləndirir; <table>-da isə render olunan sətirlərdən yuxarıda və aşağıda bir boş spacer sətri qoyaraq cədvəl semantikasını saxlaya bilərsən.)

Sabit hündürlüklü sətirlərin riyaziyyatı

Bütün sətirlər eyni hündürlükdədirsə, mövqe vurma ilə, görünən aralıq isə bölmə ilə tapılır:

JavaScript
function getRange({ scrollTop, viewportHeight, rowHeight, count, overscan }) {
  const first = Math.floor(scrollTop / rowHeight);
  const last = Math.ceil((scrollTop + viewportHeight) / rowHeight);
  const start = Math.max(0, first - overscan);
  const end = Math.min(count, last + overscan);
  return { start, end, offset: start * rowHeight, total: count * rowHeight };
}

getRange({ scrollTop: 1010, viewportHeight: 400, rowHeight: 40, count: 1000, overscan: 3 });
// { start: 22, end: 39, offset: 880, total: 40000 }
  • first yuxarı kənarın kəsdiyi sətirdir, last aşağı kənarın kəsdiyi sətirdən bir sonrakıdır. Deməli, end aralığa daxil deyil və birbaşa items.slice(start, end)-ə uyğun gəlir.
  • scrollTop 1010 olanda 25–35-ci sətirlər görünür; overscan 3 ilə pəncərədə 22–38-ci sətirlər olur: 1000 yox, 17 sətir.
  • Hər iki ucu məhdudlaşdır. Overscan 0-dan aşağı düşməməli və count-u keçməməlidir. Axtarış siyahını qısaldanda isə köhnə scrollTop yeni sondan xeyli aşağıda qala bilər: əvvəlcə scrollTop-u total - viewportHeight ilə məhdudlaşdır, yoxsa pəncərə boş qalacaq, nəhəng spacer isə səhifəni boş göstərəcək.

Overscan-ı necə seçmək

Scroll adətən compositor-da, main thread-dən irəlidə gedir, ona görə də sürətli scroll hələ render olunmamış sətirlərə çata bilər və bir-iki kadr boş yer görünər. Böyük overscan bunu gizlədir, kiçik overscan isə hər render-i ucuz saxlayır. Bir neçə sətirdən bir ekran hündürlüyünə qədər dəyər geniş yayılıb.

MiddleFramework

React-də və kitabxanalarla windowing

React-də əl ilə yazılan versiya scrollTop-u və viewport-un hündürlüyünü state-də saxlayan, aralığı render zamanı hesablayan və items.slice(start, end)-i render edən komponentdir. Scroll yalnız bu komponenti və onun 20–30 sətrini yenidən render edir. Burada üç detal vacibdir:

  • Sətirlərə key-i elementin id-si ilə ver, kəsikdəki mövqe ilə yox. Id ilə React pəncərədə qalan sətirləri saxlayır və yalnız yeni girənləri mount edir; kəsik indeksi ilə isə hər sətrin state-i və DOM-u başqa elementə keçərdi.
  • State-i yalnız aralıq dəyişəndə yenilə. scroll saniyədə dəfələrlə baş verir; aralığı saxlamaq (və ya scrollTop-u tam sətrə yuvarlaqlaşdırmaq) hər piksel üçün render-in qarşısını alır.
  • Viewport-u ölç — useLayoutEffect-də (ölçüsü dəyişə bilirsə, həm də ResizeObserver ilə). Belə olanda ilk paint artıq düzgün sətirləri göstərir.

Təkcə useDeferredValue və ya memo DOM-u kiçiltmir: yazmaq bir az rahatlaşa bilər, amma hər sətir yenə mövcuddur və ilk render yenə hamısını yaradır.

TanStack Virtual

Real layihədə dəstəklənən kitabxanadan istifadə et. TanStack Virtual headless-dır: aralıqları və offset-ləri hesablayır, öz markup-ını render etmir.

JSX
import { useRef } from "react";
import { useVirtualizer } from "@tanstack/react-virtual";

function TransactionList({ transactions }) {
  const scrollRef = useRef(null);
  const virtualizer = useVirtualizer({
    count: transactions.length,
    getScrollElement: () => scrollRef.current,
    estimateSize: () => 40,
    overscan: 8,
    getItemKey: (index) => transactions[index].id,
  });

  return (
    <div ref={scrollRef} className="viewport">
      <div style={{ position: "relative", height: virtualizer.getTotalSize() }}>
        {virtualizer.getVirtualItems().map((row) => (
          <TransactionRow
            key={row.key}
            transaction={transactions[row.index]}
            style={{
              position: "absolute",
              top: 0,
              width: "100%",
              height: row.size,
              transform: `translateY(${row.start}px)`,
            }}
          />
        ))}
      </div>
    </div>
  );
}

Hər virtual elementin index, key, start, size və end sahələri var. Default overscan 1-dir, default key isə indeksdir, ona görə də getItemKey ötür. useWindowVirtualizer eyni işi səhifə ilə birgə scroll olunan siyahı üçün görür, scrollToIndex() isə istənilən elementə keçir.

react-window (2.x) isə hazır komponentlər verir: rowComponent, rowCount, rowHeight və rowProps qəbul edən List, iki ölçü üçün Grid və hündürlüyü əvvəlcədən bilinməyən sətirlər üçün useDynamicRowHeight. Ehtiyaca görə seç: markup üzərində tam nəzarət lazımdırsa (cədvəl, masonry, sticky sətirlər) TanStack, hazır komponent yetərlidirsə react-window.

MiddleNümunə

IntersectionObserver ilə sonsuz scroll

Sonsuz scroll istifadəçi sona yaxınlaşanda növbəti səhifəni yükləyir. scroll-a qulaq asıb hər hadisədə scrollTop-u scrollHeight ilə müqayisə etmə: bu, main thread-də saniyədə dəfələrlə layout oxumaq deməkdir. Son elementdən sonra boş sentinel elementi qoy və onun viewport-a yaxınlaşdığını sənə IntersectionObserver desin. O, Baseline widely available-dır (2019-cu ilin martından).

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

function useLoadMore(loadMore, enabled) {
  const sentinelRef = useRef(null);

  useEffect(() => {
    if (!enabled) return;
    const observer = new IntersectionObserver(
      (entries) => {
        if (entries[0].isIntersecting) loadMore();
      },
      { rootMargin: "0px 0px 800px 0px" },
    );
    observer.observe(sentinelRef.current);
    return () => observer.disconnect();
  }, [loadMore, enabled]);

  return sentinelRef;
}

function Feed({ posts, hasNextPage, isFetching, fetchNextPage }) {
  const sentinelRef = useLoadMore(fetchNextPage, hasNextPage && !isFetching);
  return (
    <div role="feed" aria-busy={isFetching} aria-label="News">
      {posts.map((post, i) => (
        <Post key={post.id} post={post} posInSet={i + 1} />
      ))}
      <div ref={sentinelRef} />
    </div>
  );
}
  • rootMargin: "0px 0px 800px 0px" root-u aşağıdan 800 px böyüdür, ona görə də növbəti səhifə sona hələ xeyli qalmış yüklənməyə başlayır. Siyahı öz konteynerinin içində scroll olunursa, həmin elementi root kimi ötür.
  • Səhifə yüklənərkən observer söndürülür, ona görə də eyni səhifə iki dəfə istənmir. Yenidən yaradılanda observe() cari vəziyyətlə ilk callback-i çağırır: sentinel hələ də yaxındırsa, növbəti səhifə də yüklənir, qısa ilk səhifə isə ekranı özü doldurur.
  • Xəta vəziyyətini və ehtiyat variant kimi görünən "Daha çox yüklə" düyməsini saxla. Unutma ki, sonsuz siyahının altındakı footer-ə çatmaq çətindir.
  • ARIA feed şablonu: role="feed", hər post aria-posinset və aria-setsize (ümumi say bilinmirsə -1) olan article, yükləmə zamanı aria-busy="true". APG-yə görə Page Down və Page Up fokusu article-lar arasında hərəkət etdirir.

Sonsuz scroll windowing deyil

Hər səhifə DOM-a yeni postlar əlavə edir, ona görə də uzun sessiyanın sonunda yenə minlərlə node yığılır. İkisini birləşdir: yüklənmiş postları virtualizasiya et, növbəti səhifəni isə aralığa görə yüklə (son render olunan indeks count-a bir neçə element qalmış yaxınlaşanda), çünki virtualizasiya olunmuş siyahıda DOM-un sonu siyahının sonu deyil.

SeniorVeb platforma

Dəyişən hündürlüklər: təxmin et, ölç, düzəlt

Real sətirlərin hündürlüyü nadir hallarda eyni olur: postlarda şəkil var, mətn hər ekranda fərqli sınır, sətir açılıb genişlənir. Onda i-ci sətrin offset-i artıq i * rowHeight yox, özündən əvvəlki bütün ölçülərin cəmidir.

Prefiks cəmlər və binary search

offsets[i] = i-ci sətrin başlanğıcı saxla (offsets[0] = 0, offsets[i + 1] = offsets[i] + size[i]). Ümumi hündürlük offsets[count]-dur, ilk görünən sətir isə offsets[i] <= scrollTop şərtini ödəyən ən böyük i üçün binary search ilə tapılır — hər scroll-da siyahını gəzmək əvəzinə O(log n). Bir ölçü dəyişəndə ondan sonrakı bütün offset-lər dəyişir, ona görə də kitabxanalar offset-ləri ilk dəyişən indeksdən başlayaraq lazım olduqca yeniləyir.

Əvvəlcə təxmin, sonra ölçmə

Sətir render olunana qədər ölçüsü bilinmir, ona görə virtualizer:

  1. Ölçülməmiş hər sətir üçün təxmini ölçü götürür (TanStack-da estimateSize; onun sənədləri dinamik ölçmədə ehtimal olunan ən böyük ölçünü yazmağı tövsiyə edir).
  2. Pəncərəni render edir, sonra render olunan sətirləri ölçür. TanStack-ın measureElement ref-i və react-window-un useDynamicRowHeight-i ResizeObserver-dən istifadə edir; o, sonrakı dəyişiklikləri də tutur, məsələn, şəklin yüklənib qurtarmasını.
  3. Ölçülmüş dəyəri indeksə yox, key-ə görə cache-də saxlayır ki, sıralama və ya filtr ölçüləri itirməsin, sonra offset-ləri yenidən hesablayır.

Ölçü dəyişəndə anchoring

Viewport-dan yuxarıdakı sətir təxmin ediləndən 20 px qısa çıxsa, ondan aşağıdakı hər şey 20 px yuxarı qalxır və istifadəçinin baxdığı məzmun sıçrayır. Həll yolu kadr çəkilməzdən əvvəl scrollTop-u eyni fərq qədər sürüşdürməkdir:

JavaScript
const measured = new Map();

const observer = new ResizeObserver((entries) => {
  let shift = 0;
  for (const entry of entries) {
    const key = entry.target.dataset.key;
    const size = entry.borderBoxSize[0].blockSize;
    const old = measured.get(key) ?? ESTIMATE;
    if (size === old) continue;
    measured.set(key, size);
    if (startOf(key) < viewport.scrollTop) shift += size - old;
  }
  if (shift !== 0) viewport.scrollTop += shift;
  scheduleRender();
});

Burada startOf sətrin offset-ini prefiks cəmlərdən oxuyur, render olunan hər sətir isə observer.observe(row) ilə izlənir. Resize müşahidələri paint-dən əvvəl çatdırılır, ona görə də düzəliş eyni kadra düşür. TanStack Virtual bunu sənin yerinə edir: default olaraq düzəlişi yalnız istifadəçi geriyə scroll etmədikdə tətbiq edir, shouldAdjustScrollPositionOnItemSizeChange isə bu qaydanı dəyişməyə imkan verir.

Tələlər

  • Style yazan dövrün içində getBoundingClientRect() ilə ölçmək səbəb olur.
  • İzlədiyi elementin ölçüsünü dəyişən callback "ResizeObserver loop completed with undelivered notifications" xətasını yaradır: qalan bildirişlər növbəti kadra qalır, layout titrəyir.
  • Təxmini ölçülər real ölçülərlə əvəzləndikcə scrollbar-ın sürgüsü ölçüsünü dəyişir; yaxşı təxmin bunu minimuma endirir.
SeniorVeb platforma

Scroll mövqeyini saxlamaq: bərpa və əvvələ əlavə

Uzun siyahıda istifadəçinin yerini iki vəziyyət pozur: siyahıya geri qayıtmaq və oxuduğu yerin yuxarısında yeni elementlərin peyda olması.

Naviqasiyadan sonra bərpa

Brauzer back və forward zamanı sənədin scroll mövqeyini özü bərpa edir (history.scrollRestoration default olaraq "auto"-dur). Virtual siyahı çox vaxt buna mane olur: o, öz konteynerinin içində scroll olunur, datası asinxron gəlir, təxmini hündürlüklər üzündən isə brauzer bərpa edən anda hələ kifayət qədər hündür olmur.

  • Pikselləri yox, anchor-u saxla: ilk görünən elementin key-i və viewport-un yuxarı kənarının onun içində nə qədər aşağıda olduğu. Piksel offset-i yalnız eyni təxminlər və ölçmələr üçün doğrudur.
  • Onu hər history qeydi üçün ayrıca saxla (history.state-də və ya qeydə görə açarlanan map-də), scrollToIndex() ilə bərpa et, sonra offset-i əlavə et.
  • Datanı cache-də saxla ki, istifadəçi qayıdanda eyni elementlər yerində olsun; bərpanı öz kodun edirsə, history.scrollRestoration = "manual" yaz.

Siyahının əvvəlinə əlavə

Köhnə mesajları yükləyən chat və ya yuxarıya "12 yeni post" əlavə edən lent viewport-dan yuxarıda hündürlük artırır, nəticədə oxunan məzmun aşağı sürüşür. Adi axında brauzerlər scroll anchoring edir: görünən sahədə bir anchor element seçir və ondan yuxarıdakı məzmun dəyişəndə scroll mövqeyini düzəldir. Bu, default olaraq açıqdır, overflow-anchor: none isə ondan imtina edir; MDN onu Baseline 2026 kimi göstərir (Chrome 56, Firefox 66, Safari 27).

Virtualizer sətirləri özü mövqeləndirir, deməli, düzəlişi də özü etməlidir: brauzer çəkməzdən əvvəl əlavə olunan elementlərin hündürlüyünü scrollTop-a əlavə et. React-də yeniləmədən əvvəl ölç, useLayoutEffect-də düzəlt:

JSX
const heightBefore = useRef(0);

async function loadOlder() {
  const older = await fetchOlderMessages(messages[0].id);
  heightBefore.current = viewportRef.current.scrollHeight;
  setMessages((list) => [...older, ...list]);
}

useLayoutEffect(() => {
  const viewport = viewportRef.current;
  if (heightBefore.current === 0) return;
  viewport.scrollTop += viewport.scrollHeight - heightBefore.current;
  heightBefore.current = 0;
}, [messages]);
  • Virtualizasiya olunmamış scroller-də düzəlişi əl ilə edirsənsə, ona overflow-anchor: none ver, yoxsa həm brauzer, həm də sənin kodun düzəliş edəcək və siyahı əks tərəfə sıçrayacaq.
  • Key-lər sabit id olmalıdır: virtualizer əvvələ əlavəni sona əlavədən məhz belə ayırır. TanStack Virtual-da chat, log və tərs lentlər üçün anchorTo: "end" var, followOnAppend isə yeni elementlərin ardınca yalnız istifadəçi artıq sonda olanda gedir — tarixçəni oxuyan adamı aşağı dartmır.
SeniorTipik səhvlər

Windowing-in qiyməti: səhifədə axtarış, ekran oxuyucular, fokus

Windowing sətirləri DOM-dan çıxarır və DOM üzərində işləyən hər şey də onları itirir. Windowing-in pulsuz sürət yox, trade-off olmasının səbəbi məhz bu xərclərdir.

Səhifədə axtarış

Ctrl+F / Cmd+F yalnız render olunan sətirləri tapır. İstifadəçiyə datanın özü üzrə axtarış ver (məsələn, bütün massivi filtrləyən axtarış qutusu) və onu asan tapılan yerdə saxla. content-visibility: auto əks trade-off-dur: render-i ötürülən məzmun axtarışda tapılır.

Ekran oxuyucular

Assistiv texnologiyalar DOM-dan qurulan accessibility tree-ni oxuyur, yəni 10 000 sətirlik cədvəlin təxminən otuz sətrini görür. Ona real ölçünü de:

HTML
<table aria-rowcount="5001">
  <thead>
    <tr aria-rowindex="1">
      <th scope="col">Date</th>
      <th scope="col">Merchant</th>
    </tr>
  </thead>
  <tbody>
    <tr aria-hidden="true" style="height: 880px"></tr>
    <tr aria-rowindex="24">
      <td>2026-11-02</td>
      <td><a href="#/transactions/t-4023">Coffee Corner</a></td>
    </tr>
    <tr aria-rowindex="25">
      <td>2026-11-02</td>
      <td><a href="#/transactions/t-4024">City Books</a></td>
    </tr>
  </tbody>
</table>
  • table/grid üzərindəki aria-rowcount bütöv cədvəldəki sətirlərin sayıdır, başlıq sətri də daxil; -1 sayın bilinmədiyini bildirir.
  • Render olunan hər sətirdəki aria-rowindex onun bütöv cədvəldəki mövqeyidir və 1-dən başlayır. Burada 22 sətir ötürülüb (sətri 40 px olmaqla 880 px spacer), ona görə də render olunan ilk data sətri başlıqdan sonra 24-cü sətirdir.
  • Siyahılarda, option-larda və feed article-larında hər elementə aria-setsize və aria-posinset yaz.
  • Spacer elementlərini aria-hidden="true" ilə gizlət.

Klaviatura fokusu

İstifadəçi Tab ilə 40-cı sətirdəki linkə keçir, sonra təkərlə scroll edir. 40-cı sətir pəncərədən çıxıb unmount olur, fokuslanmış element yox olur və fokus <body>-yə düşür: növbəti Tab yenidən səhifənin başından başlayır. Həll yolları:

  • Fokuslanmış sətri aralıqdan kənarda olsa da render etməyə davam et (TanStack-ın rangeExtractor-u onun indeksini əlavə edə bilər).
  • Və ya grid şablonundan istifadə et: cədvəl üçün bir Tab dayanacağı, aktiv sətri ox düymələri dəyişir, kod isə həmin sətri fokuslamazdan əvvəl onu görünən sahəyə gətirir (scrollToIndex).

Yalnız DOM-u görən digər şeylər

#order-123 kimi səhifədaxili linklər, çap, crawler-lər və testlər: jsdom-da layout yoxdur, viewport-un hündürlüyü 0-dır və virtual siyahı heç nə render etməyə bilər. Ölçünü mock et və ya aralıq məntiqini ayrıca test et.

SeniorVeb platforma

Alternativlər: səhifələmə, content-visibility, daha az data

Windowing "node-lar həddən çoxdur" probleminin cavablarından yalnız biridir. Ona əl atmazdan əvvəl istifadəçinin nəyə ehtiyacı olduğunu soruş.

Daha az yüklə və daha az render et

  • Filtr, sıralama və axtarışı serverdə et. Brauzerdə filtrləmək üçün bütün qeydləri yükləmək render başlamamış şəbəkəyə, yaddaşa və parse-a xərc çıxarır; limitli server sorğusu yalnız istifadəçinin baxa biləcəyini göndərir.
  • Səhifələmə. Kiçik DOM, sabit URL-lər (?page=3 və ya cursor), səhifədə axtarış həmin səhifə daxilində işləyir, back düyməsi lazımi yerə qaytarır. Qiyməti: hər şeyi fasiləsiz gözdən keçirmək olmur. Bəzi məhsullara isə bir fasiləsiz siyahı lazımdır və onda səhifələmə seçim deyil.
  • Daha ucuz sətirlər. Sətir başına daha az sarğı elementi, sadə selector-lar, sütun enləri hər xanadan asılı olmasın deyə table-layout: fixed.

content-visibility: auto

CSS
.post {
  content-visibility: auto;
  contain-intrinsic-size: auto 320px;
}

Brauzer istifadəçi üçün aktual olmayan (ekrandan kənar) elementlərin məzmunu üçün style, layout və paint işini ötürür və onlar yaxınlaşanda render edir. Windowing-dən fərqli olaraq elementlər DOM-da və accessibility tree-də qalır: səhifədə axtarış, Tab sırası və fokus adi qaydada işləyir. contain-intrinsic-size: auto 320px ötürülən elementlərə yer tutan ölçü verir; auto ilə brauzer element bir dəfə render olunandan sonra onun real ölçüsünü yadda saxlayır və scrollbar sıçramağı dayandırır.

Dəstək: content-visibility Baseline 2024-dür, 2024-cü ilin sentyabrından newly available (Chrome 85, Firefox 125, Safari 18); contain-intrinsic-size isə widely available-dır.

Onun aradan qaldırmadığı şeylər: DOM node-ları yenə yaradılır və yaddaşda qalır, React də hər yeniləmədə hər elementi render edib müqayisə edir. O, uzun sənədlər və orta ölçülü lentlər üçün uyğundur; on minlərlə elementi hər hərfdə yenidən render olunan cədvələ isə kömək etmir.

Praktik qayda

  • Bir neçə yüz sadə sətir: hamısını render et, sonra ölç.
  • Yuxarıdan aşağı oxunan uzun səhifə: content-visibility: auto.
  • Minlərlə sətir, tez-tez yeniləmə və ya sonsuz böyüyən siyahı: windowing, üstəlik əvvəlki bölmədəki əlçatanlıq işi.
  • İstifadəçi mövqeyə görə gəzir və ya nəticələrə link paylaşır: səhifələmə.
  • Hər halda: göstərməyəcəyin datanı yükləmə.
SeniorMüsahibə məsləhətləri

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

30 saniyəlik cavab. "Hər DOM node-unun yaradılma, style, layout və yaddaş xərci var, React-də isə hər sətir yeniləmələrdə yenidən render olunur. Windowing yalnız viewport-dakı sətirləri və overscan-ı bütün siyahı qədər hündür spacer-in içində render edir, ona görə də DOM-un ölçüsü sabit qalır. Sabit hündürlükdə aralıq floor(scrollTop / h)-dan ceil((scrollTop + height) / h)-a qədərdir; dəyişən hündürlükdə isə təxmin edirsən, ölçürsən, key-ə görə cache-də saxlayırsan və scroll mövqeyini düzəldirsən."

Gözlənilən suallar

  • Virtual siyahı yaz. Overscan və məhdudlaşdırma ilə aralıq riyaziyyatını, spacer-i yaz, sətirlərə id ilə key ver. Viewport-u ölçməyi və state-i yalnız aralıq dəyişəndə yeniləməyi qeyd et.
  • Sətirlərin hündürlüyü fərqlidir. Prefiks cəmlər və binary search, təxmini ölçülər, key-ə görə cache-lənən ResizeObserver ölçmələri və viewport-dan yuxarıdakı sətirlər üçün scroll düzəlişi.
  • Sonsuz lent dizayn et. rootMargin-li IntersectionObserver sentinel-i, cursor ilə səhifələmə, uzun sessiyalar üçün virtualizasiya, role="feed", geri qayıdanda scroll-un bərpası.
  • Bu cədvəl niyə yavaşdır? Əvvəlcə ölç: Performance paneli, DOM ölçüsü, React Profiler. Datanın emalına olduğu kimi render-ə də baxdığını göstər.

Bal itirdən səhvlər

  • 50 elementlik siyahını virtualizasiya etmək və ya nə qədər data yüklədiyini yoxlamadan ona əl atmaq.
  • Görünən kəsikdəki indeksi key kimi istifadə etmək.
  • Əlçatanlığın qiymətini unutmaq: səhifədə axtarış, aria-rowcount/aria-rowindex və ya aria-setsize/aria-posinset, unmount olan sətirlərdəki fokus.
  • content-visibility ilə windowing-i eyni şey saymaq: biri DOM-u saxlayıb render işini ötürür, digəri node-ları silir.
  • Siyahı qısalandan sonra aralığı məhdudlaşdırmamaq.

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

Trade-off-lar və rəqəmlərlə danış: hansı DOM büdcəsini qoyduğunu, onu CI-da necə yoxladığını (yükləmədən sonra element sayı, yazarkən uzun task-lar), bu məhsul üçün niyə səhifələmə yox, windowing seçdiyini, axtarışı, ekran oxuyucuları və back düyməsini necə işlək saxladığını izah et.

Platformada məşq

"Sifarişlər cədvəli donur" (orders-unvirtualized) insidenti, həmçinin "Sonsuz xəbər lenti" (infinite-feed) və "Analitika dashboard-u" (analytics-dashboard) dizayn tapşırıqları.

MiddleYoxlama siyahısı

Virtual siyahını review edərkən nəyi yoxlamalı

Bu yoxlama siyahısı sənin yazmadığın virtual siyahını (komanda yoldaşının pull request-ini, kitabxananın nümunəsini və ya AI assistentin təklifini) review edəndə lazımdır. Onun xətaları kiçik test datasının arxasında gizlənir və production-da üzə çıxır: başqa elementin state-ini göstərən sətirlər, boş viewport, sıçrayan məzmun, itən fokus.

  • Sətirlərin key-i indeks yox, elementin sabit id-sidirmi? İndeks key-i ilə pəncərə sürüşdükcə sətrin state-i və DOM-u başqa elementə keçir. TanStack Virtual-da default key indeksdir, ona görə getItemKey-i axtar.
  • DOM həqiqətən kiçik qalırmı? Aralıq viewport-un hündürlüyündən hesablanır, ona görə scroll konteynerinə sabit hündürlük və overflow-y: auto lazımdır (ya da siyahı useWindowVirtualizer ilə səhifə ilə birgə scroll olunmalıdır). document.querySelectorAll("*").length-i siyahının əvvəlində və xeyli aşağıda müqayisə et: rəqəm demək olar ki, dəyişməməlidir.
  • Siyahı qısalanda aralıq məhdudlaşdırılırmı? Sona qədər scroll et, sonra filtrlə cəmi bir neçə sətir saxla: viewport boş qalırsa, köhnə scrollTop məhdudlaşdırılmayıb.
  • Dəyişən hündürlükdə sətirlər ResizeObserver ilə (TanStack-da measureElement) ölçülür və key-ə görə cache-lənirmi? Style yazan dövrün içində getBoundingClientRect() hər sətir üçün bir yaradır. Viewport-dan yuxarıdakı sətrin ölçüsü dəyişəndə scrollTop da həmin fərq qədər sürüşməlidir, yoxsa məzmun sıçrayır.
  • Scroll zamanı klaviatura fokusu qalırmı? Tab ilə linkə keç, təkərlə onun sətrini görünən sahədən çıxar, yenidən Tab bas. Fokus səhifənin başından başlayırsa, sətir unmount olub; onu render etməyə davam et (TanStack-ın rangeExtractor-u).
  • Ekran oxuyucular və axtarış bütün siyahıya çata bilirmi? aria-rowcount və aria-rowindex (siyahılarda aria-setsize və aria-posinset) və aria-hidden spacer-lər olmalıdır. Ctrl+F yalnız render olunan sətirləri tapır, ona görə datanın özü üzrə axtarış təklif 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.