Asenkron Programlama ve Promises Kullanımı

Javascript doğası gereği tek iş parçacıklı (single-threaded) bir programlama dili olduğundan, zaman alan işlemleri (örneğin, dosya okuma, veritabanı sorguları, API çağrıları) bloklamadan gerçekleştirmek için asenkron programlama yöntemlerine ihtiyaç duyar. Node.js gibi platformlarda asenkron işlemler uygulamaların performansını artırmak için kritik bir rol oynar.

Asenkron Programlama Nedir?

Asenkron programlama, işlemlerin başlatıldığı anda tamamlanmasını beklemeden programın diğer işlemlere devam etmesini sağlar. Bu, özellikle I/O işlemleri gibi uzun süren görevlerde kullanılır.

Asenkron Programlamanın Avantajları:

• Ana iş parçacığını (event loop) bloklamadan işlemleri yürütür.
• Yüksek performans sağlar ve verimliliği artırır.
• Kullanıcı deneyimini iyileştirir.

Callback Fonksiyonları

Asenkron programlamanın en temel yöntemlerinden biri callback fonksiyonlarıdır. Callback fonksiyonları, belirli bir işlemin tamamlanmasının ardından çağrılan fonksiyonlardır.

Örnek app.js:

const fs = require('fs');

fs.readFile('dosya.txt', 'utf8', (err, data) => {
    if (err) {
        console.error('Dosya okunamadı:', err);
    } else {
        console.log('Dosya içeriği:', data);
    }
});

console.log('Dosya okuma başlatıldı...');

node app.js ile uygulamayı başlatınca verilecek çıktı:

Dosya okuma başlatıldı...
 Dosya içeriği: Örnek içerik.

Callback Kullanımının Dezavantajları:

• "Callback Hell" olarak adlandırılan iç içe geçmiş fonksiyonların okunabilirliği azaltması.
• Hata yönetiminin zor olması.

Promises Nedir?

Promises, asenkron işlemleri daha yönetilebilir hale getiren bir yapı sunar. Bir işlemin sonucunu temsil eder ve üç farklı duruma sahip olabilir:

• Pending (Beklemede): İşlem hala devam ediyor.
• Fulfilled (Başarılı): İşlem başarıyla tamamlandı.
• Rejected (Reddedildi): İşlem başarısız oldu.

Promise Kullanımı Örneği:

const veriOku = () => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            let veri = true;
            if (veri) {
                resolve('Veri başarıyla okundu.');
            } else {
                reject('Veri okunamadı.');
            }
        }, 2000);
    });
};

veriOku()
    .then((sonuc) => console.log(sonuc))
    .catch((hata) => console.error(hata));

Promise Zincirleme (Chaining)

Promise'leri zincirleme yöntemiyle kullanarak ardışık işlemleri gerçekleştirebilirsiniz.

veriOku()
    .then((sonuc) => {
        console.log(sonuc);
        return 'İkinci işlem tamamlandı';
    })
    .then((mesaj) => console.log(mesaj))
    .catch((hata) => console.error(hata));

Async/Await Kullanımı

async ve await sözcükleri, Promise tabanlı işlemleri daha okunabilir hale getiren modern bir yöntemdir.

const veriOkuAsync = async () => {
    try {
        let sonuc = await veriOku();
        console.log(sonuc);
    } catch (hata) {
        console.error(hata);
    }
};

veriOkuAsync();

Avantajları:

• Kod daha okunabilir ve daha az karmaşıktır.
• Hata yönetimi try-catch blokları ile kolayca yapılabilir.

Promises ile Paralel Çalışma

Birden fazla asenkron işlemi aynı anda başlatmak ve sonuçlarını beklemek için Promise.all yöntemi kullanılabilir.

const islem1 = new Promise((resolve) => setTimeout(() => resolve('İşlem 1 tamamlandı'), 2000));
const islem2 = new Promise((resolve) => setTimeout(() => resolve('İşlem 2 tamamlandı'), 1000));

Promise.all([islem1, islem2])
    .then((sonuclar) => console.log(sonuclar))
    .catch((hata) => console.error(hata));

Çıktı şu şekilde olur: [ 'İşlem 1 tamamlandı', 'İşlem 2 tamamlandı' ]

Farklı Örnekler

Web API üzerine asenkron olarak istek gönderen ve yanıt alan, gelen veriyi işleyen bir örnek:

const fetch = require('node-fetch');

const getUserData = async () => {
    try {
        const response = await fetch('https://**web api linki**/users'); // Örnek link
        if (!response.ok) {
            throw new Error('Ağ isteği başarısız oldu');
        }
        const data = await response.json();
        console.log('Kullanıcı verisi:', data);
    } catch (error) {
        console.error('Hata:', error);
    }
};

getUserData();

MongoDB'ye veri ekleme, silme ve okuma işlemlerini asenkron olarak gerçekleştiren bir örnek:

const express = require('express');
const { MongoClient } = require('mongodb');

const app = express();
app.use(express.json());

const uri = 'mongodb://localhost:27017';
const client = new MongoClient(uri);
const dbName = 'urunDB';

// MongoDB bağlantısı
const connectDB = async () => {
    try {
        await client.connect();
        console.log('MongoDB bağlantısı başarılı');
    } catch (error) {
        console.error('MongoDB bağlantı hatası:', error);
    }
};

// Ürün ekleme metodu
app.post('/add-product', async (req, res) => {
    try {
        const { name, price } = req.body;
        const db = client.db(dbName);
        const result = await db.collection('products').insertOne({ name, price });
        res.status(201).json({ message: 'Ürün eklendi', result });
    } catch (error) {
        res.status(500).json({ message: 'Ürün eklenirken hata oluştu', error });
    }
});

// Ürün listeleme metodu
app.get('/get-products', async (req, res) => {
    try {
        const db = client.db(dbName);
        const products = await db.collection('products').find().toArray();
        res.status(200).json(products);
    } catch (error) {
        res.status(500).json({ message: 'Ürünler alınırken hata oluştu', error });
    }
});

// Ürün silme metodu
app.delete('/delete-product/:id', async (req, res) => {
    try {
        const { id } = req.params;
        const db = client.db(dbName);
        const result = await db.collection('products').deleteOne({ _id: new require('mongodb').ObjectId(id) });
        res.status(200).json({ message: 'Ürün silindi', result });
    } catch (error) {
        res.status(500).json({ message: 'Ürün silinirken hata oluştu', error });
    }
});

app.listen(3000, async () => {
    await connectDB();
    console.log('Sunucu 3000 portunda çalışıyor');
});

Asenkron programlama, özellikle Node.js ortamında yüksek performanslı uygulamalar geliştirmek için kritik bir konudur. Promises ve async/await yapıları sayesinde kod okunabilirliği artırılır ve hata yönetimi daha kolay hale gelir. Geliştiriciler, projelerinde ihtiyaçlarına uygun asenkron yöntemleri seçerek daha verimli uygulamalar oluşturabilirler.