Performans ve bellek

Kodu hızlı ve tutumlu yap: dizi, `Map` ve `Set` işlemlerinin Büyük O maliyeti, debounce ve throttle, memoization, çöp toplama ve bellek sızıntıları.

  • İleri
  • 22 dk
  • 10 soru
  • Ders 28 / 39

Bu derste öğreneceklerin

  • Dizi, Map ve Set işlemlerinin Büyük O maliyetini tahmin etmek ve doğru veri yapısını seçmek
  • Pahalı fonksiyonların ne sıklıkla çalıştığını debounce, throttle ve memoization ile sınırlamak
  • Çöp toplamayı erişilebilirlik üzerinden açıklamak ve tipik bellek sızıntılarından kaçınmak

Bir arama kutusu her tuş vuruşunda sunucuya istek gönderiyor: on harf, on istek. 50.000 kullanıcılık bir listede “bu e-posta alınmış mı?” kontrolü her seferinde tüm diziyi geziyor. Sayfa takılıyor, telefon ısınıyor. Performans nadiren küçük hilelere bağlıdır; iki şeye bağlıdır: doğru veri yapısını seçmek ve gereksiz iş yapmamak.

Uygulamada Büyük O

Büyük O gösterimi, girdi boyutu n büyüdükçe işin nasıl büyüdüğünü sabit katsayıları hesaba katmadan gösterir. O(1) n'e bağlı değildir; O(log n) ikili aramadır; O(n) tek bir geçiştir; O(n log n) iyi bir sıralamadır; O(n²) aynı veri üzerinde iç içe bir döngüdür. n = 100.000 için O(n) yüz bin adım, O(n²) ise on milyar adım demektir.

İşlemMaliyet
arr[i], arr.push(x), arr.pop()O(1)
arr.shift(), arr.unshift(x)genel durumda O(n): elemanlar kaymak zorunda
arr.includes(x), indexOf, findO(n)
arr.sort()O(n log n)
map.get/set/has, set.add/has/deleteortalama O(1)
obj[key]ortalama O(1)
JavaScript
function hasDuplicatesSlow(items) {
  let steps = 0;
  for (let i = 0; i < items.length; i++) {
    for (let j = i + 1; j < items.length; j++) {
      steps++;
      if (items[i] === items[j]) return { found: true, steps };
    }
  }
  return { found: false, steps };
}

function hasDuplicatesFast(items) {
  const seen = new Set();
  let steps = 0;
  for (const item of items) {
    steps++;
    if (seen.has(item)) return { found: true, steps };
    seen.add(item);
  }
  return { found: false, steps };
}

const ids = Array.from({ length: 2000 }, (_, i) => i);
console.log(hasDuplicatesSlow(ids));
console.log(hasDuplicatesFast(ids));
Beklenen çıktı
{ found: false, steps: 1999000 }
{ found: false, steps: 2000 }
2.000 eleman için iç içe döngü yaklaşık 2 milyon karşılaştırma yapar, Set ise yalnızca 2.000. Veri 10 kat büyürse ilk sürüm 100 kat, ikincisi yalnızca 10 kat yavaşlar.

Optimize etmeden önce ölç. performance.now() milisaniyeyi ondalık kısmıyla verir, DevTools'un Performance paneli ise zamanın nereye gittiğini gösterir. Aşağıdaki kodu çalıştır: sayılar her cihazda farklı olacak, ama oran açıkça görünür.

JavaScript
const n = 20000;
const list = Array.from({ length: n }, (_, i) => i);
const set = new Set(list);

let start = performance.now();
for (let i = 0; i < n; i++) list.includes(i);
console.log('Array.includes:', Math.round(performance.now() - start), 'ms');

start = performance.now();
for (let i = 0; i < n; i++) set.has(i);
console.log('Set.has:', Math.round(performance.now() - start), 'ms');
Sonuç cihaza bağlıdır; bu yüzden burada beklenen çıktı verilmedi.

Okumaya devam etmek için ücretsiz kaydol

Dersin geri kalan bölümleri, test ve notlar Educora hesabıyla açılır. Kayıt bir dakika sürer; ilerlemen tüm cihazlarında saklanır.

Debounce ve throttle

Bazı olaylar çok sık tetiklenir: input her harfte, scroll ve resize saniyede onlarca kez. Debounce, olaylar X ms boyunca durana kadar bekler ve sonra fonksiyonu bir kez çağırır: arama kutusu, otomatik kaydetme. Throttle ise fonksiyonu her X ms'de en fazla bir kez çağırır: kaydırma konumu, art arda basılan bir düğme.

JavaScript
function debounce(fn, delay) {
  let timer;
  return (...args) => {
    clearTimeout(timer);
    timer = setTimeout(() => fn(...args), delay);
  };
}

const search = debounce((text) => console.log('Searching for:', text), 200);

search('j');
search('ja');
search('jav');
setTimeout(() => search('javascript'), 500);
Beklenen çıktı
Searching for: jav
Searching for: javascript
Dört çağrıdan yalnızca ikisi çalıştı: her “patlamanın” sonuncusu. Her yeni çağrı eski zamanlayıcıyı iptal eder.
JavaScript
function throttle(fn, interval) {
  let waiting = false;
  return (...args) => {
    if (waiting) return;
    fn(...args);
    waiting = true;
    setTimeout(() => {
      waiting = false;
    }, interval);
  };
}

const handleScroll = throttle((y) => console.log('scroll handled at', y), 100);

[0, 30, 60, 90].forEach((y) => handleScroll(y));
setTimeout(() => [150, 180].forEach((y) => handleScroll(y)), 150);
Beklenen çıktı
scroll handled at 0
scroll handled at 150
TeknikNe zaman çalışırTipik kullanım
debounceolaylar durduktan X ms sonra, bir kezarama, form doğrulama, otomatik kaydetme
throttleher X ms'de en fazla bir kezkaydırma, pencere boyutu, oyunda ateş etme

Memoization

Memoization, saf bir fonksiyonun sonuçlarını argümanlarına göre hatırlamaktır: aynı argümanla ikinci çağrı saklanan cevabı hemen döndürür. Bellekten verip hız kazanmaktır. Yalnızca saf fonksiyonlarda çalışır ve sınırı olmayan bir önbellek sonsuza kadar büyüyebilir.

JavaScript
function memoize(fn) {
  const cache = new Map();
  return (n) => {
    if (cache.has(n)) return cache.get(n);
    const result = fn(n);
    cache.set(n, result);
    return result;
  };
}

let calls = 0;
const slowFib = (n) => {
  calls++;
  return n < 2 ? n : slowFib(n - 1) + slowFib(n - 2);
};
console.log(slowFib(25), 'calls:', calls);

calls = 0;
const fastFib = memoize((n) => {
  calls++;
  return n < 2 ? n : fastFib(n - 1) + fastFib(n - 2);
});
console.log(fastFib(25), 'calls:', calls);
console.log(fastFib(25), 'calls:', calls);
Beklenen çıktı
75025 calls: 242785
75025 calls: 26
75025 calls: 26
Önbelleksiz sürüm aynı değerleri yüz binlerce kez yeniden hesaplar; memoization ile her n yalnızca bir kez hesaplanır.

Çöp toplama ve bellek sızıntıları

JavaScript belleği kendisi yönetir: çöp toplayıcı (garbage collector), “köklerden”, yani global değişkenlerden, mevcut çağrı yığınından ve etkin closure'lardan artık erişilemeyen nesneleri siler. Modern motorlar “işaretle ve süpür” (mark-and-sweep) yöntemini kullanır: köklerden ulaşılabilen her şey işaretlenir, gerisi temizlenir. Çöp toplayıcıyı sen çağırmazsın; yalnızca gereksiz referansları tutmaman gerekir.

  • Unutulan zamanlayıcılar: hiç durdurulmayan bir setInterval, closure'ını ve tüm verilerini yaşatır.
  • Kaldırılmış öğelerde kalan olay dinleyicileri ve DOM'dan çıkarılıp hâlâ değişkenlerde tutulan öğeler.
  • Yalnızca büyüyen global önbellekler ve diziler.
JavaScript
const visits = new WeakMap();

function track(user) {
  visits.set(user, (visits.get(user) ?? 0) + 1);
}

let user = { name: 'Elvin' };
track(user);
track(user);
console.log(visits.get(user), visits.has(user));

user = null;

const timer = setInterval(() => console.log('tick'), 1000);
clearInterval(timer);
console.log('Interval cleared: nothing keeps the callback alive');
Beklenen çıktı
2 true
Interval cleared: nothing keeps the callback alive
user = null sonrasında nesneye erişilemez ve çöp toplayıcı onu WeakMap kaydıyla birlikte silebilir; tam anı motor belirler. WeakMap anahtarları yalnızca nesne olabilir ve bir WeakMap gezilemez.

Alıştırma

memoize(fn) fonksiyonunu bir Map ile yaz; slowSquare her argüman için yalnızca bir kez çalışsın. Şu anki sürümde önbellek yok; bu yüzden gerçek çağrı sayısı 2 yerine 4.

Alıştırma · JavaScript
let calls = 0;
const slowSquare = (n) => {
  calls++;
  return n * n;
};

function memoize(fn) {
  // add a cache
  return (n) => fn(n);
}

const fastSquare = memoize(slowSquare);
console.log(fastSquare(9), fastSquare(9), fastSquare(4), fastSquare(9));
console.log('real calls:', calls);
Beklenen çıktı
81 81 16 81
real calls: 2

Alıştırma

debounce(fn, delay) fonksiyonunu tamamla: döndürülen fonksiyon fn'i son çağrıdan delay ms sonra yalnızca bir kez çağırmalı. Şu an hiç beklemiyor ve her harfi kaydediyor.

Alıştırma · JavaScript
function debounce(fn, delay) {
  // wait `delay` ms after the last call, then call fn once
  return fn;
}

const save = debounce((text) => console.log('Saved:', text), 300);

save('H');
save('He');
save('Hel');
setTimeout(() => save('Hello'), 100);
setTimeout(() => save('Hello!'), 700);
Beklenen çıktı
Saved: Hello
Saved: Hello!

Unutma

  • Büyük O, işin veriyle nasıl büyüdüğünü gösterir: dizide arama O(n), Map/Set araması ortalama O(1), aynı veri üzerinde iç içe döngü O(n²).
  • Bir dizide tekrar tekrar aramak yerine bir Set ya da Map'i bir kez kur ve onu kullan; optimize etmeden önce ölç.
  • Debounce olaylar durduktan sonra bir kez, throttle ise her aralıkta en fazla bir kez çalışır.
  • Memoization saf fonksiyonların sonuçlarını önbelleğe alır: bellekle ödenen hız.
  • Çöp toplayıcı erişilemeyen nesneleri siler; sızıntılar unutulan zamanlayıcılardan, dinleyicilerden ve büyüyen önbelleklerden doğar, WeakMap ise anahtarlarını yaşatmaz.
Bu derste bir hata ya da yanlışlık mı gördün?

Kendini test et

10 soru. Her doğru cevap XP kazandırır.

Soru 1 / 10

Soru 1 / 10. Hangi arama ortalama O(1)'dir?