
Bu içerikte JavaScript kodunun browser içinde nasıl çalıştığı, JavaScript engine yapısı, call stack mantığı, event loop döngüsü, task queue ve microtask queue farkı, DOM API, fetch, async/await ve browser API'lerinin bir web uygulamasındaki rolü detaylı ve anlaşılır örneklerle açıklanır. Özellikle kullanıcı etkileşimi, ağ istekleri, zamanlayıcılar ve arayüz güncellemeleri üzerinden JavaScript'in tek iş parçacıklı yapısının pratikte nasıl yönetildiği ele alınır.
JavaScript ile çalışan bir web uygulaması geliştirirken çoğu geliştirici ilk aşamada sözdizimine, framework kullanımına ve API çağrılarına odaklanır. Ancak uygulama büyüdükçe, performans sorunları, beklenmeyen sıralama hataları ve asenkron akış problemleri ortaya çıkar. Bu noktada JavaScript'in browser içinde gerçekten nasıl yürütüldüğünü anlamak büyük fark yaratır.
JavaScript tek iş parçacıklı bir dil olarak çalışır, ama browser ortamı sadece JavaScript motorundan ibaret değildir. Arka planda browser API'leri, event loop, task queue, microtask queue, render süreci ve ağ işlemleri birlikte hareket eder. Bu yazıda JavaScript engine, call stack, DOM API, fetch, async/await ve browser API'lerinin bir web uygulaması bağlamında nasıl bir araya geldiğini adım adım inceleyeceğiz.
JavaScript engine, yazdığınız JavaScript kodunu yorumlayan ve çalıştıran motorun adıdır. Chrome tarafında V8, Firefox tarafında SpiderMonkey, Safari tarafında JavaScriptCore gibi farklı motorlar bulunur. Bu motorların görevi kaynak kodu parse etmek, optimize etmek ve çalıştırılabilir hale getirmektir. Kısacası, yazdığınız komutların gerçekten işlemci üzerinde çalışabilmesi JavaScript engine sayesinde olur.
Ancak engine tek başına browser deneyimini açıklamaz. Çünkü JavaScript motoru doğrudan DOM'u çizmez, HTTP isteğini kendi başına göndermez ve zamanlayıcıları tek başına yönetmez. Bunlar browser tarafından sağlanan ek yeteneklerdir. JavaScript motoru kodu çalıştırırken, ihtiyaç duyduğu çevresel servisleri browser API'leri üzerinden kullanır.
Bir web uygulamasında bu ayrımı bilmek önemlidir. Örneğin document.querysElector, settImeout veya fetch gibi yapılar JavaScript dilinin çekirdek parçası değil, browser ortamının sunduğu yeteneklerdir. Bu yüzden aynı JavaScript dili farklı ortamlarda farklı davranış alanlarına sahip olabilir. Node.js ortamında DOM olmaması, ama dosya sistemi API'lerinin bulunması bunun en net örneklerinden biridir.
Call stack, JavaScript'in hangi fonksiyonu şu anda çalıştırdığını takip ettiği yapıdır. Bir fonksiyon çağrıldığında stack üzerine eklenir, işi bitince stack'ten çıkarılır. Bu yapı son giren ilk çıkar mantığıyla çalışır. Yani en son çağrılan fonksiyon önce tamamlanır.
Basit bir örnek düşünelim. Bir fonksiyon başka bir fonksiyonu çağırdığında, önce ikinci fonksiyon stack'e girer ve tamamlanır. Sonrasında kontrol tekrar ilk fonksiyona döner. Bu mekanizma senkron çalışan kodların neden satır satır ve belirli bir sırayla ilerlediğini açıklar.
JSfunction a() { console.log("A başladı"); b(); console.log("A bitti"); } function b() { console.log("B çalıştı"); } a();
Bu örnekte önce a stack'e girer. a içinden b çağrılınca b stack'in üstüne eklenir ve çalışır. b bittikten sonra stack'ten çıkar, sonra a kaldığı yerden devam eder. JavaScript'in senkron yürütme mantığını anlamak için call stack temel yapı taşıdır.
Bir web uygulamasında call stack'in dolu kalması ciddi bir problemdir. Çünkü JavaScript tek iş parçacıklı çalıştığı için stack boşalmadan başka bir JavaScript işi başlayamaz. Ağır hesaplamalar, uzun döngüler veya bloklayan işlemler kullanıcı arayüzünün donmuş gibi görünmesine neden olabilir. Sayfanın tıklamaya cevap vermemesi çoğu zaman bu tek iş parçacıklı doğanın sonucudur.
JavaScript dili kendi başına oldukça sınırlı bir çekirdeğe sahiptir. Değişkenler, fonksiyonlar, nesneler, promise yapıları ve kontrol mekanizmaları dilin parçasıdır, ama web sayfası ile etkileşim kurmak için bunlar yetmez. İşte burada browser API'leri devreye girer. Browser, JavaScript'e çevresel yetenekler sunarak web uygulamalarını mümkün hale getirir.
DOM API, Timer API, Fetch API, History API, Local Storage, Geolocation ve benzeri yetenekler browser tarafından sağlanır. Örneğin bir butonun metnini değiştirmek istediğinizde DOM API kullanırsınız. Belirli bir süre sonra bir işlemi başlatmak istediğinizde settImeout kullanırsınız. Uzak bir sunucudan veri çekmek için fetch çağrısı yaparsınız. Bunların tümü browser ortamının sağladığı imkanlardır.
Bu ayrımı doğru anlamak hata ayıklama sürecinde çok işe yarar. Çünkü bazen sorun JavaScript sözdiziminden değil, kullanılan browser API'sinin davranışından kaynaklanır. Örneğin fetch çağrısının promise tabanlı olması, ama ağ işleminin arka planda browser tarafından yürütülmesi önemli bir detaydır. JavaScript kodu sadece bu süreci başlatır ve sonucu uygun anda işler.
DOM, yani Document Object Model, browser'ın HTML dokümanını programatik olarak temsil ettiği ağaç yapıdır. JavaScript, DOM API aracılığıyla bu yapıya erişir, düğüm ekler, siler, günceller ve olay dinleyicileri tanımlar. Bir web uygulamasında gördüğünüz butonlar, formlar, kartlar ve metin alanları aslında DOM düğümleridir. JavaScript bu düğümler üzerinden arayüzü canlı hale getirir.
Örneğin kullanıcı bir butona tıkladığında browser bu kullanıcı etkileşimini algılar. Daha önce addeVentlIstener ile tanımladığınız callback fonksiyonu uygun anda çalıştırılmak üzere sıraya alınır. Stack boşaldığında bu callback call stack'e girer ve JavaScript tarafında işlenir. Böylece tıklama, klavye girişi, mouse hareketi veya form gönderimi gibi etkileşimler uygulamanızın mantığına bağlanmış olur.
JSconst button = document.querySelector("#loadButton"); const output = document.querySelector("#output"); button.addEventListener("click", () => { output.textContent = "Veri yükleniyor..."; });
Bu örnekte querysElector ve addeVentlIstener browser tarafından sağlanan DOM API parçalarıdır. Kullanıcı butona tıkladığında callback doğrudan o anda stack'in ortasına girmez. Önce browser olayı yakalar, callback'i uygun kuyruğa yerleştirir ve JavaScript motoru stack müsait olduğunda bu fonksiyonu çalıştırır. Bu detay event loop mantığını anlamak için kritik önemdedir.
DOM güncellemeleri her zaman ekranda anında görünmeyebilir. JavaScript kodu çalışırken browser render için genellikle bekler. Yani çok yoğun JavaScript çalışıyorsa siz DOM metnini güncellemiş olsanız bile kullanıcı bunu hemen görmeyebilir. Çünkü browser, render ve layout gibi işleri çoğu zaman JavaScript stack'i boşaldıktan sonra yapar.
Event loop, JavaScript'in tek iş parçacıklı yapısına rağmen asenkron işlemleri yönetmesini sağlayan koordinasyon mekanizmasıdır. En temel haliyle event loop, call stack boş mu diye kontrol eder. Stack boşsa uygun kuyruktaki görevlerden birini alır ve çalıştırılmak üzere stack'e taşır. Böylece JavaScript aynı anda birden fazla işi gerçekten paralel yürütmese bile, çok sayıda işlemi sıralı ve verimli şekilde yönetebilir.
Bu yapı olmasaydı settImeout, kullanıcı tıklamaları, ağ cevapları veya promise sonuçları güvenli bir sırayla işlenemezdi. Event loop, browser API'lerinden dönen işleri doğru zamanda JavaScript tarafına geri sokar. Yani asenkron kodun görünürde akıcı çalışmasını sağlayan ana orkestrasyon katmanıdır.
Bir web uygulamasında kullanıcı butona tıklayabilir, aynı anda veri isteği gönderilebilir, ayrıca bir animasyon veya zamanlayıcı da çalışıyor olabilir. Event loop tüm bu kaynaklardan gelen işleri koordine eder. Bu yüzden JavaScript çalışma mantığını anlamak isteyen bir geliştirici için event loop sadece teorik bir konu değil, günlük hata ayıklamanın merkezindeki kavramlardan biridir.
Asenkron işlemler tek bir kuyruğa atılmaz. Browser ortamında özellikle iki önemli kuyruk türü vardır: task queue ve microtask queue. Task queue, settImeout, setiNterval, DOM event callback'leri gibi daha genel görevleri içerir. Microtask queue ise promise çözülmeleri, queuemIcrotask ve mUtationoBserver gibi daha yüksek öncelikli işleri taşır.
Önemli fark şudur: event loop, stack boşaldığında önce microtask queue'yu olabildiğince tüketir. Yani mevcut tur içinde bekleyen tüm microtask'ler çalıştırılır. Ancak microtask kuyruğu boşaldıktan sonra task queue'dan yeni bir görev alınır. Bu nedenle promise callback'leri genellikle settImeout(..., 0) çağrılarından önce çalışır.
Aşağıdaki örnek bu farkı net biçimde gösterir:
JSconsole.log("1"); setTimeout(() => { console.log("2"); }, 0); Promise.resolve().then(() => { console.log("3"); }); console.log("4");
Çıktı sırası 1, 4, 3, 2 olur. Çünkü önce senkron kod çalışır. Sonra promise içindeki then callback'i microtask queue'dan gelir. En son settImeout callback'i task queue'dan alınır. Bu sıra, özellikle async akış yazarken neden bazı callback'lerin beklediğinizden önce veya sonra çalıştığını anlamanızı sağlar.
Web uygulamalarında bu fark performans ve veri tutarlılığı açısından önemlidir. Örneğin bir state güncellemesinden hemen sonra promise zinciriyle başka bir iş yaptığınızda, o microtask aynı event loop turu içinde çalışabilir. Buna karşılık settImeout ile ertelediğiniz iş bir sonraki uygun task aşamasını bekler. Bu da kullanıcıya gösterilen arayüz ile uygulamanın iç durumu arasında ince zamanlama farkları yaratabilir.
Birçok geliştirici settImeout(fn, 0) ifadesini gördüğünde fonksiyonun anında çalışacağını düşünür. Oysa bu doğru değildir. settImeout sadece callback'in en erken ne zaman kuyruğa alınabileceğini söyler. Callback yine doğrudan çalışmaz, önce browser timer sürecini tamamlar, sonra ilgili görev task queue'ya düşer, ardından stack boş olursa event loop tarafından işlenir.
Bu nedenle call stack uzun süre meşgulse zamanlayıcı süresi dolmuş olsa bile callback bekler. Aynı durum kullanıcı olayları için de geçerlidir. Kullanıcı ekrana tıklasa bile o tıklamaya karşılık gelen JavaScript callback'i stack doluyken çalışamaz. Bu yüzden uzun süren hesaplamalar kullanıcı deneyimini ciddi biçimde bozar.
JSsetTimeout(() => { console.log("zamanlayıcı bitti"); }, 0); for (let i = 0; i < 1e9; i++) {} console.log("döngü tamamlandı");
Bu örnekte zamanlayıcı sıfır milisaniye olsa bile önce uzun döngü tamamlanır. Ardından senkron log yazılır, stack boşalınca zamanlayıcı callback'i çalışır. Buradan çıkarılacak ders şudur: JavaScript'te asenkron kod yazmak, işlemin her koşulda anında gerçekleşeceği anlamına gelmez. Önce yürütme sırası ve stack durumu belirleyici olur.
fetch, browser'ın sunduğu modern ağ isteği API'sidir. Bir URL'ye HTTP isteği gönderir ve sonucu promise olarak döndürür. Buradaki önemli nokta, ağ isteğinin JavaScript motoru tarafından satır satır işlenmediğidir. JavaScript sadece fetch çağrısını başlatır, esas ağ işlemini browser arka planda yürütür.
İstek gönderildikten sonra JavaScript kodu bloklanmaz ve sonraki satırlara geçer. Sunucudan cevap geldiğinde browser, bu sonucun bağlı olduğu promise'i çözümler. Promise çözülünce ilgili then callback'leri veya await sonrasındaki devam akışı microtask olarak planlanır. Böylece ağ cevabı uygun zamanda JavaScript tarafına geri döner.
JSconsole.log("istek öncesi"); fetch("/api/products") .then(response => response.json()) .then(data => { console.log("veri geldi", data); }); console.log("istek sonrası");
Burada önce istek öncesi, sonra istek sonrası yazılır. Çünkü fetch non-blocking çalışır. Ağ isteği tamamlanınca promise zinciri devreye girer ve callback'ler microtask mantığıyla işlenir. Büyük web uygulamalarında veri yükleme ekranları, hata yönetimi ve kullanıcı geri bildirimi tasarımı bu davranışa göre yapılır.
fetch ile ilgili bir başka önemli konu da response.json() çağrısının da promise döndürmesidir. Yani sadece ağ cevabını almak değil, cevabın parse edilmesi de asenkron bir akışın parçası olabilir. Bu nedenle birden fazla promise adımı arka arkaya çalışır ve her adım event loop ile koordine edilir.
Promise, gelecekte tamamlanacak bir işlemin sonucunu temsil eden yapıdır. pending, fulfilled ve rejected olmak üzere temel durumları vardır. Promise sayesinde callback iç içeliği azaltılır ve asenkron akış daha yönetilebilir hale gelir. Ama promise'in sihirli biçimde ayrı bir thread oluşturmadığını bilmek gerekir. O sadece asenkron sonucu modellemenin daha düzenli yoludur.
async/await ise promise tabanlı kodu daha senkron görünümlü yazmanızı sağlar. Bir fonksiyona async dediğinizde bu fonksiyon promise döndürür. await kullandığınızda JavaScript ilgili promise çözülene kadar tüm uygulamayı durdurmaz. Sadece o fonksiyonun devamını erteler, kontrolü event loop'a geri bırakır.
JSasync function loadProducts() { console.log("yükleme başladı"); const response = await fetch("/api/products"); const products = await response.json(); console.log("ürünler", products); } loadProducts(); console.log("fonksiyon çağrıldı");
Bu örnekte loadpRoducts çağrılır, içindeki ilk log çalışır. await fetch(...) noktasında fonksiyonun devamı beklemeye alınır, ama global akış durmaz. Bu yüzden fonksiyon çağrıldı mesajı ağ cevabından önce görünebilir. Promise çözüldüğünde await sonrasındaki bölüm microtask olarak devam eder.
Bu davranışı iyi anlamak özellikle form gönderimi, veri listeleme, giriş işlemi ve adım adım kullanıcı akışlarında önemlidir. await kullanıyor olmak, kodu tamamen senkron hale getirmez. Sadece okunabilirliği artırır ve promise zincirlerini daha sade gösterir. Alttaki event loop ve microtask mekanizması ise aynı şekilde çalışmaya devam eder.
Browser sadece JavaScript çalıştırmaz, aynı zamanda stilleri hesaplar, layout oluşturur, boyama yapar ve ekranı günceller. Bu nedenle JavaScript yürütmesi ile render süreci birbirine bağlıdır. Eğer JavaScript uzun süre call stack'i meşgul ederse browser render işlerini geciktirir. Sonuç olarak kullanıcı yükleniyor metnini bile geç görebilir.
Örneğin siz bir butona basıldığında DOM'da "Yükleniyor..." yazısı gösterip hemen ardından çok ağır bir işlem başlatırsanız, kullanıcı bu metni anında görmeyebilir. Çünkü browser çoğunlukla DOM değişikliklerini JavaScript işi bittikten sonra çizime yansıtır. Bu durum geliştiricilerin neden bazen "metni değiştirdim ama ekranda görünmedi" diye düşündüğünü açıklar.
Performans odaklı web uygulamalarında uzun işlemleri parçalara bölmek önemlidir. Gerekirse işi küçük görevlere ayırmak, Web Worker kullanmak veya hesaplama yükünü sunucuya taşımak gerekir. Çünkü event loop ne kadar sağlıklı dönerse kullanıcı etkileşimi de o kadar akıcı olur. Özellikle büyük tablolar, filtreleme işlemleri, grafik çizimleri ve yoğun liste güncellemeleri bu açıdan dikkat ister.
Aşağıdaki tablo temel kavramların rolünü özetler:
Browser içinde kod yürütme sürecinde hangi bileşenin ne iş yaptığını hızlıca karşılaştırın.
| Bileşen | Temel Görev | Örnek |
|---|---|---|
| JavaScript Engine | Kodu parse eder ve çalıştırır | V8, SpiderMonkey |
| Call Stack | Aktif fonksiyon çağrılarını tutar | Bir fonksiyonun diğerini çağırması |
| Browser API | Çevresel yetenekler sağlar | DOM, fetch, setTimeout |
| Task Queue | Genel asenkron görevleri bekletir | timer callback, click event |
| Microtask Queue | Yüksek öncelikli kısa görevleri taşır | Promise then, await devamı |
| Event Loop | Stack ve kuyruklar arasında koordinasyon kurar | Uygun görevi stack'e taşır |
| Render Pipeline | Görsel güncellemeyi ekrana yansıtır | layout, paint, composite |
Şimdi tüm kavramları tek bir örnek akışta birleştirelim. Kullanıcı bir ürün listeleme sayfasında "Ürünleri Getir" butonuna tıklasın. Browser tıklama olayını algılar ve ilgili event callback'ini task olarak uygun sırada JavaScript'e iletir. Stack boşaldığında callback çalışır, DOM üzerinden yükleniyor mesajı güncellenir ve fetch ile veri isteği başlatılır.
fetch çağrısı browser tarafında arka plana devredilir, JavaScript ise bloklanmadan devam eder. Sunucu yanıt verdiğinde ilgili promise çözülür. Promise çözülmesi microtask queue üzerinden ele alınır ve callback veya await sonrası kod çalışır. Bu aşamada ürün verisi alınır, DOM güncellenir ve browser uygun anda yeni arayüzü render eder.
JSconst button = document.querySelector("#productsBtn"); const list = document.querySelector("#productList"); const status = document.querySelector("#status"); button.addEventListener("click", async () => { status.textContent = "Ürünler yükleniyor..."; try { const response = await fetch("/api/products"); const products = await response.json(); list.innerHTML = ""; for (const product of products) { const li = document.createElement("li"); li.textContent = product.name; list.appendChild(li); } status.textContent = "Ürünler yüklendi"; } catch (error) { status.textContent = "Bir hata oluştu"; console.error(error); } });
Bu örnekte gördüğünüz şey modern frontend'in günlük çalışma modelidir. Kullanıcı olayı browser API üzerinden gelir, callback task mantığıyla yürütülür, ağ isteği fetch ile başlar, cevap promise olarak döner, await ile devam eden akış microtask mantığında işler ve sonuçta DOM güncellenir. Aslında büyük framework'ler de bu temel mekanizmanın üzerine inşa edilir. React, Vue veya benzeri araçlar size daha iyi soyutlama sunar, ama alttaki browser çalışma modeli değişmez.
JavaScript'in browser içinde nasıl çalıştığını öğrenmek sadece teorik bilgi edinmek anlamına gelmez. Bu bilgi sayesinde neden bazı log'ların beklenmedik sırada geldiğini, neden kullanıcı arayüzünün donduğunu, neden await kullandığınız halde bazı işlemlerin geciktiğini ve neden promise callback'lerinin timer'lardan önce çalıştığını anlayabilirsiniz. Bu da hem hata ayıklama hem de performans iyileştirme açısından sizi çok daha güçlü hale getirir.
Özellikle gerçek dünya projelerinde DOM güncellemeleri, veri çekme süreçleri, kullanıcı etkileşimleri ve asenkron akışlar sürekli iç içedir. Browser API'leri, event loop, task queue ve microtask queue mantığını bilen bir geliştirici daha öngörülebilir kod yazar. Ayrıca UI gecikmeleri, yarış durumları ve yanlış zamanlanmış işlemler gibi sorunları daha hızlı çözer.
Sonuç olarak JavaScript'i gerçekten öğrenmek istiyorsanız sadece dilin sözdizimine değil, çalıştığı ortama da hakim olmanız gerekir. Bundan sonraki adım olarak kendi küçük deneylerinizi yapın, console.log ile sıra testleri kurun, settImeout, promise ve async/await davranışlarını karşılaştırın. Browser içindeki yürütme modelini içselleştirdikçe, yazdığınız her web uygulaması daha sağlam, daha hızlı ve daha öngörülebilir hale gelecektir.