Node.js: Eksiksiz Geliştirici Rehberi ve 15 Pratik Örnek [2026]

# Node.js: Eksiksiz Geliştirici Rehberi ve 15 Pratik Örnek [2026] İnternet dünyasının %85'inden fazlasının JavaScript ile şekillendiği 2026'da, sunucu tarafında da aynı dili konuşabilmek, geliştirme süreçlerini inanılmaz hızlandırıyor. Node.js, bu vizyonu gerçeğe dönüştürerek, web uygulamalarından API'lara, mikroservislerden gerçek zamanlı sistemlere kadar geniş bir yelpazede çözümler sunan, asenkron ve olay tabanlı bir çalışma zamanı ortamı olarak öne çıkıyor. Bu kapsamlı rehberde, Burak Balkı olarak, 2026 itibarıyla Node.js'in temel kavramlarından en ileri seviye tekniklerine, kurulumdan performans optimizasyonuna kadar her yönünü ele alacak, pratik örneklerle bilginizi pekiştirecek ve sizi modern backend geliştirmenin zirvesine taşıyacağız. Hazır mısınız? Hemen başlayalım! ## Node.js Nedir? Node.js, Google Chrome'un V8 JavaScript motoru üzerine inşa edilmiş, sunucu tarafı JavaScript kodu çalıştırmak için kullanılan, açık kaynaklı, çapraz platform bir çalışma zamanı ortamıdır. 2026'da Node.js, özellikle hızlı ve ölçeklenebilir ağ uygulamaları geliştirmek için tercih edilir; asenkron, olay güdümlü mimarisi sayesinde yüksek eş zamanlı bağlantıları verimli bir şekilde yönetebilir. Geliştiricilerin hem ön uçta hem de arka uçta aynı dili kullanmasını sağlayarak tam yığın geliştirme süreçlerini basitleştirir. Node.js, 2026 itibarıyla modern web geliştirmenin temel taşlarından biri haline gelmiştir. Geleneksel sunucu dillerinin aksine, Node.js bir web sunucusu değildir; daha ziyade, JavaScript kodunuzu doğrudan işletim sistemi üzerinde çalıştırmanıza olanak tanıyan bir ortamdır. Bu, geliştiricilere sunucu ve istemci tarafı mantığını tek bir dil (JavaScript) ile yazma esnekliği sunar. Node.js'in temelinde yatan olay döngüsü (event loop) ve non-blocking I/O modeli, onu özellikle I/O yoğun uygulamalar için ideal kılar. Örneğin, dosya okuma/yazma, veritabanı sorguları veya harici API çağrıları gibi işlemler, ana iş parçacığını (main thread) engellemeden arka planda yürütülür, bu da uygulamanın duyarlı kalmasını ve aynı anda binlerce isteği işleyebilmesini sağlar. Bu mimari, 2026'da mikroservisler, gerçek zamanlı sohbet uygulamaları, API ağ geçitleri ve IoT çözümlerinde Node.js'i vazgeçilmez kılmaktadır. ## Neden Node.js Kullanmalısınız? Node.js'in 2026'da bu kadar popüler olmasının arkasında yatan birçok güçlü neden bulunmaktadır. Ekibimizle 2026'da gerçekleştirdiğimiz büyük ölçekli projelerde Node.js'in sağladığı faydaları bizzat deneyimledik: * **Yüksek Performans ve Ölçeklenebilirlik**: Node.js'in non-blocking I/O ve olay tabanlı mimarisi, yüksek eş zamanlı bağlantıları minimum gecikmeyle yönetmesine olanak tanır. Bu, özellikle gerçek zamanlı uygulamalar ve API'lar için kritik öneme sahiptir. 2026'da modern bulut mimarilerinde yatay ölçeklenebilirlik için mükemmel bir uyum sağlar. * **Tek Dil (JavaScript) ile Full-Stack Geliştirme**: Frontend ve backend için aynı dili kullanmak, geliştirme sürecini basitleştirir, kod paylaşımını artırır ve ekip içi iletişimi kolaylaştırır. Bu, özellikle 2026'da hızlı MVP (Minimum Viable Product) geliştiren startup'lar ve çevik ekipler için büyük bir avantajdır. * **Geniş ve Aktif Ekosistem (npm)**: Node Package Manager (npm), dünyanın en büyük yazılım kayıt defteridir ve 2026 itibarıyla milyonlarca açık kaynak paketi barındırır. Bu zengin ekosistem, hemen her ihtiyaca yönelik hazır çözümler sunarak geliştirme süresini önemli ölçüde kısaltır. * **Hızlı Geliştirme Döngüsü**: Node.js'in hafif yapısı, hızlı başlangıç süresi ve modüler mimarisi, prototipleme ve dağıtım süreçlerini hızlandırır. Canlı yeniden yükleme (hot-reloading) gibi araçlarla birlikte, geliştiriciler 2026'da çok daha verimli çalışabilir. * **Büyük Topluluk Desteği**: Node.js, dünya genelinde aktif ve büyüyen bir geliştirici topluluğuna sahiptir. Bu, sorun giderme, öğrenme kaynakları ve sürekli güncellemeler açısından paha biçilmez bir destektir. 2026'da Stack Overflow, GitHub ve çeşitli forumlarda kolayca yardım bulabilirsiniz. * **Mikroservis Mimarileri İçin İdeal**: Hafif ve bağımsız servisler oluşturma yeteneği, Node.js'i mikroservis tabanlı mimariler için doğal bir seçim haline getirir. Her servis kendi Node.js sürecinde çalışabilir, bu da bağımsız dağıtım ve ölçeklendirme sağlar. Kimler için uygun? Gerçek zamanlı veri akışı gerektiren uygulamalar (sohbet, oyun), API servisleri, IoT cihazları, mikroservis tabanlı sistemler ve tek sayfa uygulamalar (SPA) için backend geliştirenler. Kimler için uygun değil? Yoğun CPU hesaplamaları gerektiren işler (video işleme, karmaşık matematiksel simülasyonlar) için Node.js tek başına en iyi seçim olmayabilir, bu tür senaryolarda Go veya Python gibi diller daha uygun olabilir. ## Node.js vs Alternatifler (2026 Karşılaştırması) Node.js'i diğer popüler backend teknolojileriyle karşılaştırmak, hangi senaryo için en uygun seçimi yapacağınızı anlamanıza yardımcı olur. 2026 itibarıyla piyasadaki önde gelen alternatiflerden Python (Flask ile) ve Go (Gin ile) karşılaştıralım: | Özellik | Node.js (Express.js) | Python (Flask) | Go (Gin) | | :----------------- | :-------------------------------------------------------- | :-------------------------------------------------------- | :------------------------------------------------------------ | | **Performans** | Yüksek (asenkron I/O, olay döngüsü) | Orta (senkron, GIL sınırlaması) | Çok Yüksek (derlenmiş, eş zamanlılık) | | **Öğrenme Eğrisi** | Orta (JavaScript bilenler için kolay) | Kolay (basit sözdizimi) | Orta-Zor (eş zamanlılık, güçlü tip sistemi) |\ | **Ekosistem** | Çok Geniş (npm, zengin paketler) | Geniş (PyPI, bilimsel kütüphaneler) | Orta (hızla büyüyor, daha az olgun) |\ | **Topluluk** | Çok Aktif ve Büyük | Çok Aktif ve Büyük | Aktif ve Hızla Büyüyen |\ | **Kurumsal Destek**| Orta-Yüksek (Microsoft, Google gibi firmalar kullanır) | Yüksek (Google, Instagram gibi firmalar kullanır) | Yüksek (Google tarafından geliştirildi) |\ | **Kullanım Alanı** | Gerçek zamanlı uygulamalar, API, mikroservisler, IoT | Veri bilimi, makine öğrenimi, web, otomasyon | Yüksek performanslı servisler, sistem programlama, CLI araçları | **Yorum**: 2026'da Node.js, I/O yoğun ve gerçek zamanlı uygulamalar için mükemmel bir seçenek sunarken, Python veri analizi ve makine öğrenimi alanında liderliğini sürdürüyor. Go ise yüksek performans ve eş zamanlılık gerektiren sistemler için giderek daha fazla tercih ediliyor. Seçiminiz, projenizin spesifik gereksinimlerine ve ekibinizin yetkinliklerine bağlı olacaktır. Full-stack JavaScript geliştirme hedefliyorsanız, Node.js tartışmasız en iyi yoldur. ## Kurulum ve İlk Adımlar (Node.js 2026) Node.js geliştirmeye başlamadan önce sisteminize kurmanız gerekmektedir. 2026 itibarıyla Node.js'in güncel LTS (Uzun Süreli Destek) sürümü v20.x, Current sürümü ise v21.x veya v22.x civarında olacaktır. Bu rehberde, Node.js'in en güncel kararlı sürümünü (LTS) kurma adımlarını göstereceğiz. Kurulum için `nvm` (Node Version Manager) kullanmak, farklı Node.js sürümleri arasında kolayca geçiş yapmanızı sağladığı için şiddetle tavsiye edilir. **Ön Gereksinimler:** * Terminal veya komut istemcisi (Bash, Zsh, PowerShell vb.) * İnternet bağlantısı **1. nvm Kurulumu (Linux/macOS):** `nvm`'i kurmak için aşağıdaki komutu terminalinizde çalıştırın: ```bash curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash # veya wget kullanıyorsanız wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash ``` Kurulumdan sonra terminalinizi kapatıp açın veya `source ~/.bashrc` (ya da `~/.zshrc`, `~/.profile`) komutunu çalıştırarak `nvm`'i etkinleştirin. **2. Node.js Kurulumu (nvm ile):** `nvm`'i kullanarak Node.js'in en güncel LTS sürümünü kurmak için: ```bash nvm install --lts nvm use --lts nvm alias default lts/gallium # veya güncel LTS kod adı ``` Bu komutlar, 2026'daki en son LTS sürümünü kuracak ve onu varsayılan olarak ayarlayacaktır. Yüklü sürümü kontrol etmek için: ```bash node -v npm -v ``` Windows kullanıcıları için `nvm-windows` veya doğrudan Node.js'in resmi web sitesinden (nodejs.org) LTS yükleyicisini indirip kurmaları önerilir. **3. İlk Node.js Uygulamanız (Hello World):** Şimdi basit bir "Hello, Node.js 2026!" uygulaması oluşturalım. Bir `app.js` dosyası oluşturun: ```javascript // app.js console.log('Hello, Node.js 2026! Bu benim ilk Node.js uygulamam.'); const http = require('http'); // HTTP modülünü dahil et const hostname = '127.0.0.1'; const port = 3000; // Bir HTTP sunucusu oluştur const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); res.end('Merhaba Dünya 2026!\ '); }); // Sunucuyu belirtilen portta dinlemeye başla server.listen(port, hostname, () => { console.log(`Sunucu http://${hostname}:${port}/ adresinde çalışıyor.`); console.log('Bu sunucu, 2026 Node.js ile oluşturuldu.'); }); ``` Terminalde bu dosyayı çalıştırın: ```bash node app.js ``` Tarayıcınızda `http://127.0.0.1:3000/` adresine giderek "Merhaba Dünya 2026!" çıktısını görmelisiniz. Tebrikler, ilk Node.js uygulamanızı 2026'da başarıyla çalıştırdınız! ## Temel Kullanım ve Örnekler (Node.js Core) Node.js'in temel modülleri ve günlük geliştirme pratiklerinde sıkça karşılaşılan senaryoları ele alalım. Bu örnekler, 2026'da modern Node.js uygulamalarının nasıl inşa edildiğini anlamanıza yardımcı olacaktır. ### 1. Basit bir REST API Oluşturma (Express.js ile) **Problem**: Hızlıca bir API endpoint'i oluşturmak ve JSON verisi döndürmek. **Çözüm**: Express.js, Node.js için popüler ve minimalist bir web çatısıdır. 2026'da API geliştirmenin vazgeçilmezidir. ```bash mkdir simple-api && cd simple-api npm init -y npm install express ``` `server.js`: ```javascript // server.js const express = require('express'); const app = express(); const port = 3001; app.use(express.json()); // JSON body parsing için let products = [ { id: 1, name: 'Laptop 2026', price: 12000 }, { id: 2, name: 'Mouse 2026', price: 250 } ]; // Tüm ürünleri listele app.get('/api/products', (req, res) => { res.json(products); }); // ID'ye göre ürün getir app.get('/api/products/:id', (req, res) => { const product = products.find(p => p.id === parseInt(req.params.id)); if (!product) return res.status(404).send('Ürün bulunamadı.'); res.json(product); }); // Yeni ürün ekle app.post('/api/products', (req, res) => { const newProduct = { id: products.length + 1, name: req.body.name, price: req.body.price }; products.push(newProduct); res.status(201).json(newProduct); }); app.listen(port, () => { console.log(`Express API sunucusu http://localhost:${port} adresinde çalışıyor. (2026)`) }); ``` Çalıştırmak için: `node server.js` ### 2. Dosya Okuma ve Yazma (Asenkron) **Problem**: Büyük bir dosyayı okumak ve içeriğini başka bir dosyaya yazmak, bu sırada uygulamanın bloke olmamasını sağlamak. **Çözüm**: Node.js `fs` modülü ve asenkron metotlar (`readFile`, `writeFile`). 2026'da `fs/promises` API'si daha çok tercih edilmektedir. ```javascript // file-operations.js const fs = require('fs/promises'); // Promise tabanlı fs modülü async function processFile() { try { const data = await fs.readFile('input.txt', 'utf8'); console.log('Dosya başarıyla okundu (2026).'); const modifiedData = `--- 2026 Veri Başlangıcı ---\ ${data.toUpperCase()}\ --- 2026 Veri Sonu ---`; await fs.writeFile('output.txt', modifiedData); console.log('Dosya başarıyla yazıldı.'); } catch (err) { console.error('Dosya işlemi hatası:', err); } } // input.txt dosyasını oluşturun (örnek içerik) // Bu örnek 2026'da çalışmaktadır. // Merhaba dünya! // Bu bir Node.js dosya okuma örneğidir. processFile(); ``` `input.txt`: ``` Merhaba dünya! Bu bir Node.js dosya okuma örneğidir. 2026'da Node.js çok güçlü. ``` Çalıştırmak için: `node file-operations.js` ### 3. Modül Sistemi (ES Modules 2026) **Problem**: Kodu daha küçük, yeniden kullanılabilir parçalara bölmek. **Çözüm**: Node.js'in yerel ES Module (ESM) desteği, `import`/`export` sözdizimi ile 2026'da standart hale gelmiştir. `package.json` dosyanızda `"type": "module"` ayarlayın. `utils.js`: ```javascript // utils.js (ES Module) export function add(a, b) { return a + b; } export const APP_VERSION = '1.0.0-2026'; export default class Calculator { subtract(a, b) { return a - b; } } ``` `main.js`: ```javascript // main.js (ES Module) import { add, APP_VERSION } from './utils.js'; import Calculator from './utils.js'; console.log(`Uygulama Sürümü: ${APP_VERSION} (2026)`); console.log('Toplama sonucu:', add(5, 3)); const calc = new Calculator(); console.log('Çıkarma sonucu:', calc.subtract(10, 4)); ``` `package.json`'a ekleyin: ```json { "name": "es-module-example", "version": "1.0.0", "description": "Node.js ES Module Example 2026", "main": "main.js", "type": "module", // Bu satır önemli! "scripts": { "start": "node main.js" }, "keywords": [], "author": "Burak Balkı", "license": "ISC" } ``` Çalıştırmak için: `npm start` ### 4. Olay Yayıcıları (Event Emitters) **Problem**: Uygulama içinde özel olaylar tanımlamak ve bu olaylara tepki veren dinleyiciler oluşturmak. **Çözüm**: Node.js `events` modülü, olay tabanlı mimariler için temel sağlar. 2026'da mikroservisler arası iletişimde veya iç sistemlerde sıkça kullanılır. ```javascript // event-emitter-example.js const EventEmitter = require('events'); class MyEmitter extends EventEmitter {} const myEmitter = new MyEmitter(); // Bir dinleyici tanımla myEmitter.on('userLoggedIn', (username, timestamp) => { console.log(`[${timestamp}] ${username} sisteme giriş yaptı! (2026)`); // E-posta gönder, log kaydet vb. işlemler yapılabilir. }); myEmitter.on('dataReceived', (data) => { console.log('Yeni veri alındı:', data); }); // Olayları tetikle myEmitter.emit('userLoggedIn', 'BurakBalki', new Date().toLocaleString('tr-TR', { year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric' })); myEmitter.emit('dataReceived', { message: 'API çağrısından gelen data', status: 'success' }); myEmitter.emit('userLoggedIn', 'GuestUser', new Date().toLocaleString('tr-TR', { year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric' })); console.log('Olaylar tetiklendi, dinleyiciler bekliyor...'); ``` Çalıştırmak için: `node event-emitter-example.js` ## İleri Seviye Teknikler (Node.js 2026) Node.js'in temelini anladıktan sonra, 2026'da production ortamlarında karşılaşacağınız daha karmaşık senaryolar için ileri seviye tekniklere geçelim. Bu teknikler, uygulamanızın daha sağlam, ölçeklenebilir ve yönetilebilir olmasını sağlar. ### 1. Asenkron Akış Kontrolü ve `async/await` (Modern Yaklaşım) **Problem**: Birden fazla asenkron işlemi sırayla veya paralel olarak yönetmek ve callback cehenneminden (callback hell) kaçınmak. **Çözüm**: `async/await` sözdizimi, promise'lar üzerinde okunabilir ve senkron görünümlü asenkron kod yazmayı sağlar. 2026'da bu, standart bir pratik haline gelmiştir. ```javascript // async-await-flow.js const fs = require('fs/promises'); async function fetchData(url) { const response = await fetch(url); // Node.js v18+ ile global fetch API if (!response.ok) { throw new Error(`HTTP hatası! Durum: ${response.status}`); } return response.json(); } async function processDataPipeline() { console.log('Veri işlem hattı başlatıldı (2026)...'); try { // 1. Adım: Bir dosyadan URL listesini oku const urlsText = await fs.readFile('urls.txt', 'utf8'); const urls = urlsText.split('\ ').filter(Boolean); // 2. Adım: Tüm URL'lerden verileri paralel olarak çek console.log('URL\'lerden veri çekiliyor...'); const fetchPromises = urls.map(url => fetchData(url)); const allData = await Promise.all(fetchPromises); // 3. Adım: Çekilen verileri birleştir ve yeni bir dosyaya yaz console.log('Veriler birleştiriliyor ve yazılıyor...'); const combinedData = JSON.stringify(allData, null, 2); await fs.writeFile('combined_data_2026.json', combinedData); console.log('Tüm işlemler başarıyla tamamlandı!'); } catch (error) { console.error('İşlem hattında bir hata oluştu:', error.message); } } // urls.txt dosyasını oluşturun (örnek içerik) // https://jsonplaceholder.typicode.com/todos/1 // https://jsonplaceholder.typicode.com/posts/1 processDataPipeline(); ``` `urls.txt`: ``` https://jsonplaceholder.typicode.com/todos/1 https://jsonplaceholder.typicode.com/posts/1 ``` Çalıştırmak için: `node async-await-flow.js` ### 2. Küme Modülü (Cluster Module) ile Çoklu İş Parçacığı **Problem**: Node.js'in tek iş parçacıklı (single-threaded) yapısından dolayı çok çekirdekli CPU'ları tam olarak kullanamamak. **Çözüm**: `cluster` modülü, uygulamanızın birden fazla kopyasını (worker process) başlatarak her bir CPU çekirdeğini kullanmasını sağlar. Bu, 2026'da Node.js uygulamalarının performansını ve hata toleransını artırmak için kritik bir yöntemdir. `cluster-example.js`: ```javascript // cluster-example.js const cluster = require('cluster'); const http = require('http'); const numCPUs = require('os').cpus().length; if (cluster.isMaster) { // Master process console.log(`Master process ${process.pid} çalışıyor (2026).`); // CPU çekirdeği sayısı kadar worker process oluştur for (let i = 0; i < numCPUs; i++) { cluster.fork(); } cluster.on('exit', (worker, code, signal) => { console.log(`Worker process ${worker.process.pid} öldü. Yeni bir worker başlatılıyor.`); cluster.fork(); // Ölen worker yerine yenisini başlat }); } else { // Worker process // Worker'lar HTTP sunucusunu başlatır http.createServer((req, res) => { res.writeHead(200); res.end(`Hello from Worker ${process.pid} (2026)!\ `); }).listen(8000); console.log(`Worker process ${process.pid} başlatıldı.`); } ``` Çalıştırmak için: `node cluster-example.js` Tarayıcınızda `http://localhost:8000/` adresine her gittiğinizde farklı bir worker'dan yanıt alacaksınız, bu da yük dengelemenin çalıştığını gösterir. ### 3. Worker Threads (CPU Yoğun İşler İçin) **Problem**: Node.js'in tek iş parçacıklı yapısını korurken, CPU yoğun (blocking) işlemleri ana iş parçacığını bloke etmeden gerçekleştirmek. **Çözüm**: `worker_threads` modülü, ayrı JavaScript iş parçacıklarında CPU yoğun görevleri çalıştırmanıza olanak tanır. 2026'da büyük veri işleme veya karmaşık hesaplamalar için idealdir. `worker.js`: ```javascript // worker.js const { parentPort, workerData } = require('worker_threads'); function calculateFactorial(n) { if (n === 0) return 1; let result = 1; for (let i = 1; i <= n; i++) { result *= i; } return result; } const result = calculateFactorial(workerData.num); parentPort.postMessage(result); ``` `main-thread.js`: ```javascript // main-thread.js const { Worker, isMainThread, parentPort, workerData } = require('worker_threads'); if (isMainThread) { console.log('Ana iş parçacığı çalışıyor (2026).'); const numToCalculate = 10; // CPU yoğun işlem console.log(`Faktöriyel ${numToCalculate} hesaplanıyor...`); const worker = new Worker('./worker.js', { workerData: { num: numToCalculate } }); worker.on('message', (result) => { console.log(`Faktöriyel sonucu: ${result}`); }); worker.on('error', (err) => { console.error('Worker hatası:', err); }); worker.on('exit', (code) => { if (code !== 0) { console.error(`Worker ${code} koduyla durdu.`); } console.log('Worker işlemi tamamlandı.'); }); // Ana iş parçacığı bloke olmadan başka işler yapabilir console.log('Ana iş parçacığı devam ediyor, worker arka planda çalışıyor.'); console.log('Bu, 2026'da Node.js ile CPU yoğun işlerin nasıl yönetildiğine dair bir örnek.'); } else { // Bu kısım worker.js tarafından çalıştırılmaz, sadece isMainThread kontrolü için. } ``` Çalıştırmak için: `node main-thread.js` ### 4. Middleware ve Hata Yönetimi (Express.js) **Problem**: Gelen istekleri işlemek, kimlik doğrulama yapmak veya hataları merkezi olarak yönetmek. **Çözüm**: Express.js middleware'leri, istek işleme döngüsünde ara adımlar eklemenizi sağlar. 2026'da bu, API güvenliği ve hata ayıklama için temel bir yapıdır. ```javascript // middleware-error-handling.js const express = require('express'); const app = express(); const port = 3002; // Global middleware - Her istekte çalışır app.use((req, res, next) => { console.log(`[${new Date().toISOString()}] İstek geldi: ${req.method} ${req.url} (2026)`); next(); // Bir sonraki middleware'e veya rota işleyicisine geç }); // Kimlik doğrulama middleware'i (örnek) const authenticate = (req, res, next) => { const authHeader = req.headers.authorization; if (authHeader && authHeader === 'Bearer secret-token-2026') { req.user = { id: 1, username: 'BurakBalki' }; // Kullanıcı bilgisini ekle next(); } else { res.status(401).send('Yetkisiz erişim.'); } }; app.get('/public', (req, res) => { res.send('Bu herkese açık bir sayfa.'); }); app.get('/protected', authenticate, (req, res) => { res.send(`Hoş geldiniz, ${req.user.username}! Bu korumalı bir kaynak.`); }); // Hata fırlatan bir rota app.get('/error', (req, res, next) => { const err = new Error('Bu kasıtlı bir hata!'); err.statusCode = 500; next(err); // Hata işleyici middleware'e gönder }); // Hata işleyici middleware (en sonda tanımlanmalı) app.use((err, req, res, next) => { console.error('Uygulama hatası:', err.stack); // Hata detaylarını logla const statusCode = err.statusCode || 500; res.status(statusCode).json({ error: 'Sunucu hatası oluştu (2026).', message: err.message }); }); app.listen(port, () => { console.log(`Middleware ve hata yönetimi sunucusu http://localhost:${port} adresinde çalışıyor.`); }); ``` Çalıştırmak için: `node middleware-error-handling.js` Test etmek için: * `http://localhost:3002/public` * `http://localhost:3002/protected` (401 hatası verir) * `http://localhost:3002/protected` (Postman/cURL ile `Authorization: Bearer secret-token-2026` başlığı ekleyerek deneyin) * `http://localhost:3002/error` ## Best Practices & Anti-Patterns (Node.js 2026) Production ortamında Node.js uygulamaları geliştirirken, 2026'da edindiğimiz tecrübelere göre bazı en iyi uygulamaları takip etmek ve yaygın hatalardan kaçınmak kritik öneme sahiptir. Bu bölüm, daha sağlam, güvenli ve ölçeklenebilir uygulamalar yazmanıza yardımcı olacaktır. ### ✅ Doğru Yaklaşımlar (Best Practices) 1. **Asenkron Programlamayı Doğru Kullanın**: Callback'ler yerine `async/await` veya Promise'ları tercih edin. Bu, kod okunabilirliğini artırır ve `callback hell`'den kaçınmanızı sağlar. `2026`'da modern JavaScript'in temelidir. 2. **Hata Yönetimini Ciddiye Alın**: Her asenkron işlem için `try...catch` blokları kullanın. Express.js gibi framework'lerde hata işleyici middleware'leri kurun. Beklenmedik hatalar için `process.on('uncaughtException')` ve `process.on('unhandledRejection')` kullanın (ancak bu yakalayıcılar sadece loglama ve temiz kapatma için kullanılmalı, uygulamanın devam etmesi için değil). 3. **Modüler Yapılandırma**: Uygulamanızın yapılandırmasını (veritabanı bağlantıları, API anahtarları, port numaraları) ortam değişkenleri veya özel bir yapılandırma modülü aracılığıyla yönetin. `.env` dosyaları ve `dotenv` paketi 2026'da yaygın olarak kullanılmaktadır. 4. **Günlük Tutma (Logging)**: Uygulamanızın davranışını ve hataları izlemek için kapsamlı günlükleme kullanın. Winston veya Pino gibi kütüphaneler, yapılandırılmış ve performanslı günlük tutma sağlar. Logları merkezi bir log yönetimi sistemine (ELK Stack, Grafana Loki vb.) gönderin. 5. **Güvenlik Odaklı Geliştirme**: XSS, CSRF, SQL Injection gibi yaygın web güvenlik açıklarına karşı önlemler alın. `helmet` gibi middleware'ler HTTP başlıklarını güvenli hale getirir. Parolaları asla düz metin olarak saklamayın, bcrypt gibi güçlü hash algoritmaları kullanın. Rate limiting uygulayın. 6. **Sürüm Kontrolü ve Bağımlılık Yönetimi**: `package.json` dosyasında bağımlılıklarınızın kesin sürümlerini (`~` veya `^` yerine kesin sürüm numaraları) belirtin. `npm audit` veya `yarn audit` ile güvenlik açıklarını düzenli olarak kontrol edin. 2026'da bu, CI/CD süreçlerinin bir parçasıdır. 7. **Test Edilebilirlik**: Birim testleri, entegrasyon testleri ve uçtan uca testler yazın. Jest, Mocha, Supertest gibi araçlar Node.js testleri için popülerdir. Testler, kodunuzun kalitesini ve güvenilirliğini artırır. 8. **Performans İzleme**: Prometheus, Grafana, New Relic gibi araçlarla uygulamanızın CPU, bellek, ağ ve olay döngüsü metriklerini izleyin. Bottleneck'leri tespit etmek ve gidermek için profil oluşturma araçlarını kullanın. ### ❌ Yanlış Yaklaşımlar (Anti-Patterns) 1. **Senkron API Kullanımı**: Node.js'in `fs.readFileSync` gibi senkron metotlarını ana iş parçacığında kullanmaktan kaçının. Bu, sunucuyu bloke eder ve performansı düşürür. Her zaman asenkron versiyonlarını tercih edin. 2. **Global Değişken Bağımlılığı**: Verileri veya yapılandırmayı global değişkenlerde saklamak yerine, modüller arası bağımlılıkları açıkça iletin (dependency injection). Bu, kodun test edilmesini ve yeniden kullanılmasını zorlaştırır. 3. **Callback Cehennemi (Callback Hell)**: Derinlemesine iç içe geçmiş callback'ler, kodun okunmasını ve bakımını imkansız hale getirir. `async/await` veya Promise'lar kullanarak bu durumdan kaçının. 4. **Güvenlik Açıklarını Göz Ardı Etmek**: Güvenlik, sonradan eklenecek bir özellik değildir. Uygulamanın her katmanında güvenlik düşünülmelidir. Varsayılan güvenlik ayarlarını değiştirmeyi unutmayın. 5. **Logları Yeterince Kullanmamak veya Aşırı Kullanmak**: Yetersiz loglama sorun gidermeyi zorlaştırırken, aşırı detaylı ve yapılandırılmamış loglar da değerli bilgileri gizleyebilir. Doğru seviyede, yapılandırılmış loglama esastır. 6. **Test Yazmamak**: Testler olmadan kodunuzun beklenen şekilde çalıştığından emin olamazsınız. Özellikle 2026'da sürekli entegrasyon ve dağıtım ortamlarında testler hayati öneme sahiptir. ## Yaygın Hatalar ve Çözümleri (Node.js Troubleshooting 2026) Node.js geliştirirken karşılaşabileceğiniz bazı yaygın hatalar ve bunların çözümleri, 2026'da edindiğimiz tecrübelerle aşağıda listelenmiştir. ### 1. Hata: `Error: listen EADDRINUSE: address already in use :::3000` * **Sebep**: Belirtilen port (örneğin 3000) zaten başka bir uygulama tarafından kullanılıyor. Genellikle daha önce çalıştırdığınız bir Node.js veya başka bir sunucu uygulaması kapanmamıştır. * **Çözüm**: Portu kullanan süreci sonlandırın. Linux/macOS'ta `lsof -i :3000` komutuyla süreci bulup `kill -9 ` ile sonlandırabilirsiniz. Windows'ta `netstat -ano | findstr :3000` ve `taskkill /PID /F` kullanabilirsiniz. Alternatif olarak, uygulamanız için farklı bir port kullanın. ### 2. Hata: `ReferenceError: require is not defined` veya `ReferenceError: exports is not defined` (ESM kullanırken) * **Sebep**: ES Modules (ESM) ortamında (yani `package.json` dosyanızda `"type": "module"` ayarlıysa) CommonJS (`require`, `exports`) sözdizimini kullanmaya çalışıyorsunuz. * **Çözüm**: ESM kullanıyorsanız `import`/`export` sözdizimine geçin. Eğer CommonJS kullanmaya devam etmek istiyorsanız, `package.json` dosyanızdaki `"type": "module"` satırını kaldırın veya dosya uzantısını `.cjs` olarak değiştirin. ### 3. Hata: `TypeError: Cannot read properties of undefined (reading 'body')` * **Sebep**: Express.js uygulamanızda `req.body`'ye erişmeye çalışıyorsunuz ancak gelen isteğin gövdesi (body) ayrıştırılmamış veya boş. Genellikle POST/PUT isteklerinde JSON veya form verisi beklerken olur. * **Çözüm**: Express.js uygulamanızda `app.use(express.json());` (JSON için) veya `app.use(express.urlencoded({ extended: true }));` (form verisi için) middleware'lerini eklediğinizden emin olun. Bu middleware'ler, gelen isteğin gövdesini ayrıştırır ve `req.body` özelliğini doldurur. 2026'da bu, Express.js uygulamalarının temel bir parçasıdır. ### 4. Hata: `UnhandledPromiseRejectionWarning: Unhandled promise rejection.` * **Sebep**: Bir Promise reddedildi (rejected) ancak bu reddedilme hiçbir `catch` bloğu tarafından yakalanmadı. Bu, uygulamanızda beklenmedik davranışlara veya çökmelere yol açabilir. * **Çözüm**: Tüm Promise'ları `try...catch` blokları veya `.catch()` metotları ile uygun şekilde ele alın. `async/await` kullanıyorsanız, `await` çağrılarını bir `try...catch` bloğu içine alın. 2026'da bu uyarı, geliştirme sırasında göz ardı edilmemesi gereken kritik bir sinyaldir. ## Performans Optimizasyonu (Node.js 2026) 2026'da Node.js uygulamalarınızın yüksek performanslı ve ölçeklenebilir olmasını sağlamak, sadece doğru kod yazmakla kalmaz, aynı zamanda sistem kaynaklarını verimli kullanmayı da gerektirir. İşte kanıtlanmış bazı performans optimizasyon teknikleri: 1. **Asenkron ve Non-Blocking I/O Kullanımı**: Node.js'in temel avantajı olan asenkron I/O'yu her zaman tercih edin. `fs.readFile` yerine `fs.promises.readFile` kullanmak gibi. Bu, uygulamanızın ana iş parçacığını bloke etmesini engeller ve eş zamanlı istekleri daha verimli işlemesini sağlar. Bu sayede `request per second (RPS)` değerlerinde önemli artışlar elde edilebilir. 2. **Önbellekleme (Caching)**: Sık erişilen ancak nadiren değişen veriler için önbellekleme kullanın. Redis veya Memcached gibi in-memory veri depoları, veritabanı sorgularının veya pahalı hesaplamaların tekrar tekrar yapılmasını önleyerek yanıt sür