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

JavaScript-in dərinlikləri

Yaddaş sızmaları və garbage collection

JavaScript nəyi təmizləyəcəyinə necə qərar verir — əlçatanlıq, köklər, mark-and-sweep və V8-in nəsilləri; veb tətbiqlər buna baxmayaraq listener, taymer, ayrılmış node və keşlər üzündən niyə sızır və sızmanı heap snapshot ilə necə tapmaq 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.

Başlamazdan əvvəl

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

JuniorKonsepsiya

Əlçatanlıq: garbage collector nəyi saxlayır

JavaScript-də free() yoxdur. Obyekt, massiv, sətir və closure yaradanda yaddaş ayrılır, onu geri qaytarmaq isə mühərrikin işidir. Onun qaydası sadədir: obyekt əlçatan qaldıqca — hansısa kökdən ona aparan istinad zənciri olduqca — saxlanılır, belə zəncir qalmayanda isə zibilə çevrilir.

Köklər collector-un həmişə "canlı" saydığı başlanğıc nöqtələridir:

  • qlobal obyekt (globalThis, brauzerdə window) və onun saxladığı hər şey;
  • hazırda olan funksiyaların lokal dəyişənləri və arqumentləri;
  • host-un sənin əvəzinə saxladığı istinadlar: sənəddəki DOM node-ları, qeydə alınmış event listener-lər, gözləyən taymerlər və promise callback-ləri, açıq bağlantılar.
JavaScript
let user = { name: "Ada", avatar: new Uint8Array(1_000_000) };
const session = { user };

user = null;

session.user = null;

user = null heç nəyi azad etmədi: o, yalnız bir yolu sildi, obyekt isə session.user vasitəsilə hələ də əlçatan idi. Yalnız ikinci mənimsətmədən sonra ona heç nə aparmır və collector onu təmizləyə bilər. delete obj.key də eyni cür işləyir: istinadı silir, yaddaşı dərhal boşaltmır. Collector-un nə vaxt işə düşəcəyinə mühərrik özü qərar verir, səhifənin kodu onu çağıra bilməz.

Dövri istinadlar problem deyil

Köhnə reference counting collector-ları dövrləri sızdırırdı: bir-birinə istinad edən iki obyektin sayğacı heç vaxt sıfıra düşmürdü. Müasir mühərriklər isə köklərdən başlayıb istinadları izləyir, ona görə də təcrid olunmuş dövr sadəcə əlçatmaz olur:

JavaScript
function link() {
  const a = {};
  const b = { a };
  a.b = b;
}

link();

link() qayıtdıqdan sonra a və b hələ də bir-birinə istinad edir, amma onlara heç nə aparmır, ona görə hər ikisi təmizlənə bilər. MDN qeyd edir ki, heç bir müasir JavaScript mühərriki artıq garbage collection üçün reference counting istifadə etmir. Yəni "dövri istinadlar sızma yaradır" məsləhəti adi JavaScript obyektləri üçün köhnəlib.

Əsas məqamlar

  • Yaddaş obyekti "silməklə" yox, istinadları buraxmaqla azad olunur.
  • Əlçatan "yenə istifadə olunacaq" demək deyil, "kökə bağlıdır" deməkdir. Bir daha toxunmayacağın obyekt də, uzunömürlü bir şey ona istinad edirsə, yaddaşda qalır.
  • Məhz bu boşluq — əlçatandır, amma artıq lazım deyil — adlanır.
JuniorKonsepsiya

Garbage collection olan dildə sızma nədir

JavaScript-də proqramın artıq ehtiyac duymadığı, amma hələ də istinad etdiyi yaddaşdır: collector onu saxlamağa məcburdur. Burada collector səhv etmir — o sənin niyyətini görmür, yalnız əlçatanlığı görür.

Sızma səhifəni bir dəqiqəyə çökdürmür. O, yavaş-yavaş yığılır: istifadəçi hər dəfə dialoq açanda, single-page tətbiqdə görünüşü dəyişəndə və ya WebSocket mesajı alanda bir az daha yaddaş geridə qalır. Tipik əlamətlər:

  • JS heap hər təkrarlanan əməliyyatla böyüyür və heç vaxt ilkin səviyyəsinə qayıtmır;
  • uzun sessiyada tətbiq yavaşlayır: işarələnməli canlı obyekt çoxaldıqca üzərində GC işi də uzanır və tezləşir;
  • yan təsirlər təkrarlanır: dublikat sorğular, iki dəfə işləyən handler — sızan kod çox vaxt hələ də işləyir;
  • ən pis halda tab-ın yaddaşı bitir və brauzer onu bağlayır.

Hər böyümə sızma deyil. 50 MB data yükləyib onu göstərən səhifə çox yaddaş işlədir, amma sızdırmır. Sızma təkrarla bağlı böyümədir: eyni işi on dəfə görürsən, yaddaş da on pillə qalxır.

JavaScript
const seen = [];

export function onMessage(message) {
  seen.push(message);
  render(message);
}

Modul səviyyəsindəki bu massiv səhifə yaşadıqca əlçatandır, ona görə də indiyədək gələn hər mesaj yaddaşda qalır. Qısa testdə heç nə görünmür, bir günlük axından sonra isə massiv yüz meqabaytlarla yaddaş tuta bilər.

Yaddaş və davranış

Real həyatda tez-tez rast gəlinən mənzərə: ekran serverə polling sorğuları göndərməyə başlayır və heç vaxt dayanmır. İstifadəçi onu hər açanda daha bir poller başlayır. Uzun sessiyadan sonra səhifə lazım olduğundan dəfələrlə çox sorğu göndərir, hər köhnə poller isə çoxdan silinmiş komponentin state-ini yaşadır. Bu mənzərə tipikdir: sızma həm yaddaşda, həm də davranışda özünü göstərir.

Verilməli sual

Hər uzunömürlü istinad üçün soruş: onu kim silir və nə vaxt? Cavab "heç kim"dirsə, sızma namizədi tapmısan. Mövzunun qalan hissəsi bu suala adətən hansı cavabların verildiyindən və onları necə yoxlamaqdan bəhs edir.

JuniorTipik səhvlər

Tipik mənbələr: listener-lər, taymerlər və qlobal dəyişənlər

Veb tətbiqlərdəki sızmaların çoxu eyni sxemlə yaranır: uzunömürlü bir şey (window, document, qlobal store, brauzerin taymer siyahısı) qısaömürlü bir şeyə (dialoq, komponent, sorğu) istinad edir və bu istinadı heç kim silmir.

Unudulmuş event listener-lər

JavaScript
function openSearchDialog() {
  const results = new Array(10_000).fill(null);
  function onKeyDown(event) {
    if (event.key === "Escape") closeDialog(results);
  }
  document.addEventListener("keydown", onKeyDown);
}

Hər çağırış yeni funksiya qeydə alır, document onların hamısını saxlayır, hər listener-in isə öz results massivini. Dialoqu on dəfə aç: on listener, on massiv və eyni anda işləyən on Escape handler-i. Listener-i dialoq bağlananda sil və bunu eyni funksiya referansı ilə et — removeEventListener-ə təzə yazılmış arrow funksiya ötürsən, heç nə silinməyəcək.

Özü silinib unudulmuş elementin listener-i isə sızma deyil: element də, onun listener-ləri də birlikdə əlçatmaz olur. Təhlükə funksionallıqdan uzun yaşayan hədəflərə bağlanmış listener-lərdədir.

Təmizlənməyən taymerlər

Brauzer setInterval callback-inə clearInterval çağırılana qədər, gözləyən setTimeout-a isə o işə düşənə qədər istinad edir. Özünü yenidən planlaşdıran setTimeout üzərində qurulmuş polling dövrü, zənciri kimsə qırmasa, əbədi yaşayır:

JavaScript
function startPolling(load) {
  let timer;
  let stopped = false;
  const tick = async () => {
    await load();
    if (!stopped) timer = setTimeout(tick, 5000);
  };
  tick();
  return () => {
    stopped = true;
    clearTimeout(timer);
  };
}

stopped bayrağı vacibdir: dayandırma funksiyası load() hələ icra olunarkən çağırıla bilər və bayraq olmasa, növbəti taymer yenə də planlaşdırılacaq.

Təsadüfi qlobal dəyişənlər

Sloppy mode skriptlərində elan olunmamış ada dəyər mənimsətmək qlobal obyektdə xassə yaradır, bu xassə isə kökdür:

JavaScript
function cacheResponse(data) {
  lastResponse = data;
}

lastResponse artıq səhifə qədər yaşayır. ES modulları və strict mode kodu bunun əvəzinə ReferenceError atır — modullarla yazmağın daha bir səbəbi. Bilərəkdən yaradılmış qlobal dəyişənlər və modul səviyyəsindəki dəyişənlər də kökdür: onların saxladığı hər şey bütün sessiya boyu yaşayır.

Konsola yazılan obyektlər

DevTools açıq olanda console.log-a ötürülən obyektlər, sonradan açıb baxa biləsən deyə, saxlanıla bilər; heap snapshot-larda hətta konsolun saxladığı obyektlər üçün ayrıca filtr var. Bunu öz kodundakı sızma ilə qarışdırma və dövr içində böyük obyektləri log edən kodu production-a çıxarma.

MiddleVeb platforma

Mark-and-sweep və V8-in nəsilləri

Bütün müasir mühərriklər mark-and-sweep ailəsindən olan izləyici (tracing) collector işlədir:

  1. Mark. Köklərdən başla, hər istinadı izlə və çatdığın hər obyekti işarələ.
  2. Sweep. İşarəsiz qalan hər şey zibildir; onun yaddaşı yeni ayrılmalar üçün boş yer siyahılarına (free list) qaytarılır.
  3. Compact (məcburi deyil). Sağ qalan obyektləri bir yerə yığ ki, boş yaddaş xırda "deşiklərə" bölünməsin.

Alqoritm sadədir, əsas mühəndislik isə onu səhifəni dondurmadan icra etməkdədir. V8 (Chrome, Edge, Node.js, Deno) öz collector-unu — Orinoco-nu — V8 blogunda təsvir edir. Aşağıda həmin təsvir verilib; detallar versiyadan versiyaya dəyişir.

Nəsil ideyası

Nəsil hipotezinə görə obyektlərin çoxu gənc ölür: müvəqqəti massivlər, dövrdə qurulan sətirlər, event obyektləri, aralıq nəticələr. Ona görə V8 heap-i hissələrə bölür:

  • Gənc nəsil (young generation). Yeni obyektlər burada yaradılır. O, kiçikdir və Scavenger (minor GC) tərəfindən tez-tez təmizlənir. Gənc nəsil iki semi-space-ə bölünüb: canlı obyektlər dolu yarıdan boş yarıya köçürülür, geridə qalan hər şey isə tərifə görə zibildir. Xərc nə qədər yaddaş ayrıldığından yox, sağ qalanların sayından asılıdır — qısaömürlü obyektlərin ucuz olmasının səbəbi budur. Bir scavenge-dən sağ çıxan obyekt gənc nəslin aralıq hissəsinə keçir, ikincisindən də sağ çıxan isə köhnə nəslə köçürülür (promotion).
  • Köhnə nəsil (old generation). Uzunömürlü obyektlər. Onu major GC (mark-compact) təmizləyir: bütün heap-i işarələyir, sweep edir və ən çox parçalanmış səhifələri sıxlaşdırır.

Yalnız gənc nəsli təmizləyə bilmək üçün V8 hansı köhnə obyektlərin gənc obyektlərə istinad etdiyini bilməlidir. Bu istinadları write barrier-lər qeydə alır, scavenger isə onları əlavə kök kimi götürür.

Pauzaları qısa saxlamaq

Böyük heap-in stop-the-world təmizlənməsi uzun müddət bloklayardı. Orinoco üç üsulu birləşdirir: paralel (pauza zamanı köməkçi thread-lər işi bölüşür), inkremental (iş JavaScript tapşırıqlarının arasında kiçik hissələrlə görülür) və konkurent (işarələmə və sweep JavaScript işləyərkən fon thread-lərində gedir). Chrome həmçinin collector-a kadrlar arasındakı boş vaxtı verə bilir.

Bu sənə niyə lazımdır

  • Sızan obyektlər hər scavenge-dən sağ çıxıb köhnə nəslə düşür, orada isə hər major GC onları yenidən işarələməlidir. Yaddaş böyüyür, onunla birlikdə GC işi də.
  • Durmadan böyüyən heap daha tez-tez major GC deməkdir. Bu işin çoxu main thread-dən kənarda gedir, amma hamısı yox, ona görə də zəif cihazlarda sızma çox vaxt ilk növbədə kadr itkisi (jank) kimi görünür.

Səhifənin kodu GC-ni məcburi işə sala bilməz. Node.js --expose-gc ilə gc() funksiyasını açır, DevTools-da isə "Collect garbage" düyməsi var: bunlar ölçmə alətləridir, production üçün deyil.

MiddleTipik səhvlər

DOM-dan ayrılmış node-lar, limitsiz keşlər və tutulan data

DOM-dan ayrılmış node-lar

Sənəddən silinmiş node detached (ayrılmış) olur. JavaScript ona hələ də istinad edirsə, o təmizlənə bilməz. Hər node öz valideyninə və uşaqlarına istinad etdiyi üçün (parentNode, childNodes) bircə istinad bütün ayrılmış ağacı əlçatan saxlayır.

JavaScript
const rowsById = new Map();

function renderTable(items) {
  const table = document.createElement("table");
  for (const item of items) {
    const row = table.insertRow();
    row.insertCell().textContent = item.name;
    rowsById.set(item.id, row);
  }
  return table;
}

function showItems(container, items) {
  container.replaceChildren(renderTable(items));
}

showItems səhifədəki köhnə cədvəli yenisi ilə əvəz edir, təkrarlanan id-lər üçün isə map-ə yeni sətirlər yazılır. Amma artıq göstərilməyən item-lərin yazıları heç vaxt silinmir və həmin köhnə sətirlərin hər biri bütöv köhnə cədvəli yaşadır. Render-dən əvvəl rowsById.clear() çağır və ya axtarışın istiqamətini dəyiş: sətirdən item-ə aparan WeakMap sətirlərin öz cədvəli ilə birlikdə getməsinə imkan verir.

Limitsiz keşlər

Keş kimi işlədilən Map xoş niyyətli sızmadır: yazılar daxil olur, heç nə çıxmır.

JavaScript
const productCache = new Map();

function getProduct(id) {
  if (!productCache.has(id)) {
    productCache.set(id, fetch(`/api/products/${id}`).then((r) => r.json()));
  }
  return productCache.get(id);
}

Uzun sessiyada bu map istifadəçinin indiyədək gördüyü bütün məhsulları saxlayır. Hər keşin siyasəti olmalıdır:

  • ölçü limiti — ən çoxdan istifadə olunmayan yazını çıxar. Map yazıları əlavə olunma sırası ilə gəzir, ona görə hər oxunuşda açarı silib yenidən əlavə etməklə kiçik LRU alınır;
  • yaşama müddəti (TTL) — vaxt damğası saxla və köhnəlmiş yazıları at;
  • əhatə dairəsi — logout zamanı və ya funksionallıq unmount olanda keşi təmizlə.

Açar ömrünü sənin idarə etmədiyin obyektdirsə, WeakMap yazını açarla birlikdə buraxır. Limit də real olmalıdır: 10 000 böyük yazı məhduddur, amma yenə də çoxdur — retained size-ı heap snapshot-da yoxla.

Böyük datanı tutan closure-lar

öz mühitini əlçatan saxlayır. Mühərriklər yalnız closure-ların həqiqətən istifadə etdiyi dəyişənləri saxlayır, ona görə də uzunömürlü callback götürüldüyü böyük obyektə yox, ehtiyac duyduğu kiçik dəyərə istinad etməlidir:

JavaScript
function attachDownload(button, report) {
  const { id } = report;
  button.addEventListener("click", () => downloadReport(id));
}

Click handler yalnız id-dən istifadə edir, ona görə də report onun üçün saxlanmır. Amma V8-də eyni scope-da yaranan closure-lar bir ortaq kontekst bölüşür: attachDownload-ın içindəki başqa bir funksiya report-dan istifadə etsəydi, handler da onu yaşadardı (closure-lar mövzusuna bax). Ağır datanı uzunömürlü callback-lər yaradan scope-lardan kənarda saxla.

MiddleVeb platforma

WeakMap, WeakSet, WeakRef və FinalizationRegistry

Adi istinad öz hədəfini yaşadır. Zəif (weak) istinad isə yox: o, obyektə data bağlamağa imkan verir, amma obyektin yaddaşda qalması üçün səbəbə çevrilmir.

WeakMap və WeakSet

JavaScript
const metadata = new WeakMap();

function track(node) {
  metadata.set(node, { clicks: 0, firstSeen: performance.now() });
}

Map öz açarlarını zəif saxlayır: node-a başqa heç nə istinad etmədikdə yazı dəyəri ilə birlikdə təmizlənə bilər. Buna görə o, "mənə məxsus olmayan obyektlər haqqında əlavə data" üçün düzgün alətdir: DOM node-ları, kitabxanadan gələn obyektlər, sorğu obyektləri. WeakSet eyni işi üzvlük üçün görür ("bu obyekti artıq emal etmişəmmi?").

Qaydalar bu kolleksiyaların nəyi üzə çıxarmamalı olduğundan irəli gəlir:

  • Açar obyekt və ya qeydiyyatsız symbol olmalıdır. "user-1" kimi sətir açarını istənilən an yenidən yaratmaq olar, deməli o, heç vaxt "yox ola" bilməz. Symbol.for() ilə qeydə alınmış symbol-lar da eyni səbəbdən qəbul edilmir.
  • size yoxdur, iterasiya yoxdur, clear() yoxdur. Yazıların siyahısını görmək collector-un nə vaxt işlədiyini müşahidə etməyə imkan verərdi, mühərriklər isə bunu açmamalıdır.

WeakMap dəyərlər üçün keş deyil. O, açarları zəif, dəyərləri isə — açar yaşadıqca — güclü saxlayır. Sətir id-lərindən böyük obyektlərə aparan map-ə WeakMap yox, ölçü limiti lazımdır. Öz açarına istinad edən dəyər isə açarı yaşatmır: WeakMap yazıları adi güclü istinad deyil, ephemeron-dur.

WeakRef və FinalizationRegistry

JavaScript
const registry = new FinalizationRegistry((key) => {
  console.log("collected " + key);
});

function remember(report) {
  registry.register(report, report.id);
  return new WeakRef(report);
}

const ref = remember(loadReport());
const report = ref.deref();

deref() hədəfi qaytarır, hədəf təmizləndikdən sonra isə undefined. Təzəcə WeakRef yaratdığın və ya deref() ilə aldığın hədəf cari job bitənə qədər yaşayır, yəni sinxron kodun ortasında yoxa çıxmır. FinalizationRegistry qeydə alınmış obyekt təmizləndikdən bir müddət sonra callback çağırır və ona obyektin özünü yox, held value-nu (burada report.id) ötürür.

Hər ikisi 2021-ci ilin aprelindən Baseline-dır (geniş əlçatandır), MDN isə imkan daxilində onlardan qaçmağı məsləhət görür. Spesifikasiya demək olar ki, heç bir zəmanət vermir: hədəf heç vaxt təmizlənməyə bilər, cleanup callback-i gec çağırıla və ya ümumiyyətlə çağırılmaya bilər — məsələn, tab bağlananda. Ona görə də mütləq baş verməli olan iş üçün heç vaxt finalizer-ə güvənmə: listener-ləri silmək, taymerləri təmizləmək, socket-ləri bağlamaq, datanı saxlamaq. Bunlar açıq cleanup tələb edir. Finalizer ən yaxşı halda optimallaşdırmadır, məsələn, boşalmış WeakRef-i keş map-indən silmək üçün — hətta onda da callback yazının bu arada əvəz olunmadığını yoxlamalıdır.

SeniorFramework

Komponentlərdə cleanup

Single-page tətbiqdə komponent dəfələrlə mount və unmount olur, ona görə də onun mount zamanı başlatdığı və unmount zamanı unutduğu hər şey yığılıb qalır:

JSX
function PricePanel({ symbol }) {
  const [quotes, setQuotes] = useState([]);
  const [width, setWidth] = useState(window.innerWidth);

  useEffect(() => {
    setInterval(async () => {
      setQuotes(await fetchQuotes(symbol));
    }, 5000);
    window.addEventListener("resize", () => setWidth(window.innerWidth));
  }, [symbol]);

  return <QuoteTable quotes={quotes} compact={width < 600} />;
}

Hər mount-da və symbol-un hər dəyişməsində daha bir interval başlayır və daha bir resize listener-i əlavə olunur, onları isə heç nə dayandırmır. N ziyarətdən sonra səhifə hər beş saniyədə N dəfə sorğu göndərir, sızan hər interval isə öz closure-unu, onunla birlikdə də çoxdan unmount olmuş komponentlərin state setter-lərini yaşadır. Development rejimində Strict Mode-un əlavə setup + cleanup dövrü elə ilk mount-dan iki poller yaradır — bu, cleanup-ın çatışmadığına qəsdən verilən işarədir.

Həll setup-ın başlatdığı hər şeyi geri qaytaran cleanup-dır:

JSX
useEffect(() => {
  const controller = new AbortController();
  const { signal } = controller;

  const id = setInterval(async () => {
    try {
      const response = await fetch(`/api/quotes/${symbol}`, { signal });
      setQuotes(await response.json());
    } catch (error) {
      if (error.name !== "AbortError") console.error(error);
    }
  }, 5000);

  window.addEventListener("resize", () => setWidth(window.innerWidth), { signal });

  return () => {
    clearInterval(id);
    controller.abort();
  };
}, [symbol]);

Bir AbortController ömürləri bir-birinə bağlayır. abort() çağırışı onun signal-ı ilə qeydə alınmış bütün listener-ləri silir — ona görə də anonim resize handler-inin referansını ayrıca saxlamaq lazım deyil — və icrada olan fetch-i ləğv edir, o da AbortError ilə reject olur. Hələ gəlməkdə olan cavab gövdəsinin oxunması da ləğv olunur, beləliklə gecikən cavab heç vaxt setQuotes-a çatmır.

Hər abunəliyin sahibi olmalıdır

Eyni qayda komponentin abunə olduğu hər şeyə aiddir: store listener-ləri, WebSocket-lər, ResizeObserver və IntersectionObserver (disconnect()), media query listener-ləri, üçüncü tərəf vidjetləri (destroy()). Abunəlik API-lərinin çoxu unsubscribe funksiyası qaytarır; onu effektdən qaytarmaq elə cleanup-ın özüdür. Xarici store-dan dəyər oxumaq üçün isə useSyncExternalStore abunə olmağı da, abunəlikdən çıxmağı da sənin yerinə edir.

İncident-in yoxlamaları da məhz bunu ölçür: səhifədən çıxdıqdan sonra intervalların və qlobal listener-lərin sayı ilkin səviyyəyə qayıtmalı, sorğu tezliyi isə bir poller səviyyəsində qalmalıdır.

SeniorVeb platforma

Chrome DevTools ilə sızmaları tapmaq

Təxmin etmə, ölç. Etibarlı iş axını belədir:

  1. Trendi təsdiqlə. Performance panelində Memory checkbox-unu aç və şübhəli əməliyyatı təkrarlayarkən (dialoqu on dəfə aç-bağla) yazını başlat. Əvvəldə və sonda Collect garbage düyməsini bas. JS heap, DOM node və listener sayğacları ilkin səviyyəyə qayıtmalıdır; heç vaxt enməyən pilləkən sızmadır. Chrome-un Task Manager-i (More tools > Task manager, JavaScript memory sütunu aktiv olmaqla) tez baxmaq üçün canlı rəqəm verir.
  2. Heap snapshot götür. Memory panelində Heap snapshot seç. Snapshot götürmək həmişə garbage collection ilə başlayır, ona görə gördüyün hər şey həqiqətən əlçatandır. Üç snapshot götür: ilkin vəziyyət, əməliyyatı bir neçə dəfə təkrarladıqdan sonra və onu geri qaytardıqdan (görünüşü bağladıqdan) sonra.
  3. Müqayisə et. Comparison görünüşü hər konstruktor üzrə iki snapshot arasında neçə obyektin əlavə olunduğunu və silindiyini, həmçinin fərqi (# Delta sütunu) göstərir. Əməliyyatı on dəfə təkrarla və on vahid artan sayları axtar. Summary görünüşündə Objects allocated between Snapshot 1 and Snapshot 2 filtri oxşar suala cavab verir.
  4. Retainers zəncirini izlə. Şübhəli obyekti seç: Retainers paneli onu yaşadan istinad zəncirini kökə doğru göstərir. Sızma adətən gözləmədiyin ilk halqadır — Window listener-i, taymer, modul səviyyəsindəki Map. Shallow size-a (obyektin öz ölçüsü) yox, Retained size-a (obyektlə birlikdə azad olunacaq yaddaş) görə sırala.
  5. Ayrılmış node-ları axtar. Class filter-ə Detached yaz və ya Objects retained by detached nodes filtrini seç; Chrome-un yeni versiyalarında Memory panelində ayrıca Detached elements profili də var.

Allocations on timeline yaddaş ayrılmalarını zaman üzrə yazır: mavi zolaqlar yazının sonunda hələ canlı olan obyektlərdir, boz zolaqlar isə artıq təmizlənib. Hər təkrarda yaranan mavi zolaqlar sızan obyektləri yaradan koda işarə edir. Allocation sampling ayrılmaları az əlavə yüklə funksiyalar üzrə bölüşdürür, bu da uzun yazılar üçün əlverişlidir.

performance.memory sızma detektoru deyil

performance.memory (usedJSHeapSize, totalJSHeapSize, jsHeapSizeLimit) qeyri-standartdır, deprecated-dir və yalnız Chromium əsaslı brauzerlərdə var. MDN onun rəqəmlərini etibarsız sayır: səhifələr bir heap-i bölüşə bilər, worker-lər və cross-site iframe-lər isə ayrıca heap-də olur. Onu əvəz etməli olan performance.measureUserAgentSpecificMemory() eksperimentaldır, Baseline deyil və yalnız secure, cross-origin isolated səhifədə işləyir. Bunlardan real istifadəçilərdən gələn təxmini trendlər üçün istifadə et, sızmanın sübutu kimi yox.

Node.js-də də eyni alətlər var: DevTools-u --inspect ilə qoş və ya koddan v8.writeHeapSnapshot() ilə snapshot yaz və onu Memory panelində aç.

Platformadakı watchlist-leak incident-i bu iş axınını işləyən tətbiqdə məşq etməyə imkan verir.

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

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

30 saniyəlik cavab. "JavaScript köklərdən əlçatmaz olan obyektləri təmizləyir; köklər qlobal obyekt, call stack və host-un saxladığı şeylərdir, məsələn, listener-lər və taymerlər. Sızma hələ əlçatan, amma artıq lazım olmayan yaddaşdır: window üzərindəki listener-lər, heç kimin təmizləmədiyi intervallar, DOM-dan ayrılmış node-lar, yalnız böyüyən keşlər. Sızmanı heap snapshot-larla təsdiqləyirəm və hər abunəliyə cleanup verməklə düzəldirəm."

Gözlənilən suallar

  • JavaScript-də garbage collection necə işləyir? Köklərdən əlçatanlıq, mark-and-sweep və dövri istinadların niyə problem olmadığı. Senior vəzifə üçün nəsilləri də əlavə et: gənc obyektlər üçün Scavenger, köhnələr üçün mark-compact, pauzaları qısaltmaq üçün inkremental və konkurent işarələmə.
  • Garbage collection olan dildə sızma ola bilərmi? Bəli. İki konkret mənbə və onların həllini de.
  • Map, yoxsa WeakMap? Zəif açarlar, yalnız obyekt (və ya qeydiyyatsız symbol) açarlar, iterasiya və size yoxdur — çünki təmizlənmə müşahidə oluna bilməməlidir. Ondan nə vaxt istifadə etməyəcəyini də de: sətir açarları, dəyərlər üçün keş.
  • Tətbiq bir saatdan sonra yavaşlayır. Necə araşdırarsan? Performance panelində trend → üç snapshot → Comparison → Retainers. Development-də Strict Mode-un əlavə effekt dövrünün çatışmayan cleanup-ları erkən üzə çıxardığını da qeyd et.
  • Bağlantıları FinalizationRegistry callback-ində bağlayardınmı? Xeyr: callback-in çağırılacağına zəmanət yoxdur.

Bal itirdən səhvlər

  • "Dəyişənə null mənimsətmək yaddaşı azad edir." Bu, yalnız bir istinadı silir; obyekti collector sonra təmizləyir, həm də yalnız ona başqa heç nə çatmırsa.
  • "Dövri istinadlar sızma yaradır." İzləyici (tracing) collector-larda yox.
  • "Silinmiş elementlər listener-lərini həmişə sızdırır." Yalnız elementə hələ də nəsə istinad edirsə və ya listener elementdən uzun yaşayan hədəfə bağlıdırsa.
  • performance.memory-ni və ya Task Manager-dəki rəqəmi sübut saymaq. Sübut snapshot müqayisəsi və retainer zənciridir.

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

Yalnız API-lərdən yox, ömürlərdən danış: hər abunəliyin sahibi kimdir, hər keşi nə məhdudlaşdırır və komanda reqressiyaları necə tutur. Məsələn, bir axını təkrarlayıb intervalların, listener-lərin və DOM node-larının sayının ilkin səviyyəyə qayıtdığını yoxlayan end-to-end test.

JuniorYoxlama siyahısı

Kodu yaddaş sızmaları baxımından review edərkən nəyi yoxlamalı

Bu siyahını yazmadığın kodu review edəndə işlət: komanda yoldaşının pull request-i, kitabxananın issue tracker-indəki snippet və ya AI assistentin təklifi. Hər uzunömürlü istinad üçün soruş: onu kim silir və nə vaxt? Cavab "heç kim"dirsə, yaddaş hər təkrarla artacaq, köhnə handler-lər isə işləməyə davam edəcək.

  • Setup-ın başlatdığı hər şeyin uyğun dayandırılması varmı? window və ya document üzərindəki hər addEventListener, setInterval, özünü yenidən planlaşdıran setTimeout, abunəlik və ya observer üçün uyğun removeEventListener, clearInterval, clearTimeout, unsubscribe və ya disconnect() olmalıdır. React-də bunun yeri effektin cleanup-ıdır; development-də Strict Mode-un əlavə setup + cleanup dövrü çatışmayan cleanup-ı üzə çıxarır.
  • Listener eyni funksiya referansı ilə silinirmi? removeEventListener-ə təzə yazılmış arrow funksiya ötürsən, heç nə silinmir. Saxlanmış funksiya və ya { signal } ilə controller.abort() gözlə.
  • Modul səviyyəsindəki massiv, Map və ya keş yalnız böyüyürmü? Siyasət tələb et: ölçü limiti, yaşama müddəti (TTL) və ya logout zamanı təmizləmə. WeakMap yalnız obyekt açarlarına uyğundur.
  • Kod DOM-dan silinmiş node-lara istinad saxlayırmı? Dəyişəndə və ya Map-də qalan bircə istinad bütün ayrılmış ağacı yaşadır.
  • Uzunömürlü callback bir sahə üçün böyük obyekti tuturmu? istinad etdiyi şeyləri əlçatan saxlayır; kiçik dəyəri əvvəlcədən ayrıca götür, məsələn, const { id } = report.
  • Mütləq baş verməli olan cleanup FinalizationRegistry-yə həvalə olunubmu? Onun callback-i gec çağırıla və ya heç çağırılmaya bilər, ona görə də listener-lər, taymerlər və socket-lər açıq cleanup tələb edir.
  • Sızma təxminlə yox, ölçü ilə təsdiqlənirmi? Əməliyyatı on dəfə təkrarla və DevTools-un Memory panelində heap snapshot-ları müqayisə et: sayı on vahid artan konstruktor ipucudur, onun Retainers siyahısı isə onu nəyin yaşatdığını göstərir.

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

İnsident simulyatoru

Həftəlik çağırışlar