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.
| İşlem | Maliyet |
|---|---|
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, find | O(n) |
arr.sort() | O(n log n) |
map.get/set/has, set.add/has/delete | ortalama O(1) |
obj[key] | ortalama O(1) |
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 }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.
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');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.
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
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
| Teknik | Ne zaman çalışır | Tipik kullanım |
|---|---|---|
| debounce | olaylar durduktan X ms sonra, bir kez | arama, form doğrulama, otomatik kaydetme |
| throttle | her X ms'de en fazla bir kez | kaydı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.
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
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.
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.
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.
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/Setaraması ortalama O(1), aynı veri üzerinde iç içe döngü O(n²). - Bir dizide tekrar tekrar aramak yerine bir
Setya daMap'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,
WeakMapise anahtarlarını yaşatmaz.