[NODE JS] async/await ile Hata Yonetimi

[Silverhand]

Türkiye'de ilk Mobil & PC Aynı Anda Metin2 Oyna. Triarchonline kalıcı ve uzun ömürlü yapısı ile 24 Temmuz'da açılıyor. | 1-99 Mobil Metin2 Triarch HEMEN TIKLA!

[NODE JS] async/await ile Hata Yonetimi​

Merhaba arkadaslar, bugun async/await ile hata yonetimini detayli inceleyecegiz. Asenkron kodda hata yonetimi belki de en onemli ve en cok hata yapilan konulardan biri. Ben yillarca bu konuda hatalar yaptim ve production'da crash'ler yasadim. Simdi ogrendigim her seyi sizinle paylasacagim ki ayni hatalara siz dusmeyin.

try/catch ile Hata Yakalama​

async/await'in en buyuk avantajlarindan biri, senkron koddaki gibi try/catch kullanabilmenizdir. await ile bekledigimiz bir Promise reject oldugunda, catch bloguna duser. Bu callback'lerdeki error-first pattern'den veya then/catch zincirinden cok daha dogal ve okunakli bir yaklasim. Bir try blogu icinde birden fazla await kullanabilirsiniz ve herhangi birinde hata olursa catch'e duser.

Ama dikkat edin, try/catch sadece await ile kullanilan Promise'lerdeki hatalari yakalar. Eger await koymadan bir async fonksiyon cagirirsiniz, hatasi catch'e dusmez ve "unhandled promise rejection" olarak ucara gider. Node.js 15'ten itibaren bu uygulamayi durdurur.

const fs = require('fs/promises');
const path = require('path');

// Temel try/catch kullanimi
async function dosyaIsle(dosyaYolu) {
    try {
        const icerik = await fs.readFile(dosyaYolu, 'utf8');
        const veri = JSON.parse(icerik);
        const sonuc = await isleVeKaydet(veri);
        return sonuc;
    } catch (error) {
        // Farkli hata turlerini ayirt et
        if (error.code === 'ENOENT') {
            console.error('Dosya bulunamadi:', dosyaYolu);
        } else if (error instanceof SyntaxError) {
            console.error('JSON parse hatasi:', error.message);
        } else {
            console.error('Beklenmeyen hata:', error.message);
        }
        throw error; // Hatayi yukariya ilet (gerekirse)
    } finally {
        // Temizlik islemleri - her durumda calisir
        console.log('Islem tamamlandi (basarili veya basarisiz)');
    }
}

function isleVeKaydet(veri) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (veri && veri.id) {
                resolve({ ...veri, islendi: true });
            } else {
                reject(new Error('Gecersiz veri formati'));
            }
        }, 100);
    });
}

// Birden fazla async islemde hata yonetimi
async function kullaniciRaporuOlustur(kullaniciId) {
    let kullanici, siparisler;

    try {
        kullanici = await kullaniciBul(kullaniciId);
    } catch (error) {
        throw new Error(`Kullanici bulunamadi: ${error.message}`);
    }

    try {
        siparisler = await siparisGetir(kullaniciId);
    } catch (error) {
        // Siparisler alinamazsa bos dizi kullan, uygulamayi durdurma
        console.warn('Siparisler alinamadi, bos rapor olusturuluyor');
        siparisler = [];
    }

    return {
        kullanici,
        siparisler,
        olusturma: new Date().toISOString()
    };
}

function kullaniciBul(id) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (id > 0) resolve({ id, ad: 'Ahmet' });
            else reject(new Error('Gecersiz ID'));
        }, 50);
    });
}

function siparisGetir(kullaniciId) {
    return new Promise((resolve) => {
        setTimeout(() => resolve([{ id: 1, tutar: 100 }]), 50);
    });
}

// Kullanim
kullaniciRaporuOlustur(1)
    .then(rapor => console.log('Rapor:', JSON.stringify(rapor, null, 2)))
    .catch(hata => console.error('Rapor hatasi:', hata.message));

Ozel Hata Siniflari​

Production seviyesinde uygulamalarda, farkli hata turlerini ayirt etmek icin ozel hata siniflari olusturmak cok onemlidir. Her hata tipi farkli bir HTTP status kodu veya farkli bir log seviyesi gerektirebilir. Ben her projede en az 4-5 ozel hata sinifi olusturuyorum.

// Ozel hata siniflari
class UygulamaHatasi extends Error {
    constructor(mesaj, statusKod = 500) {
        super(mesaj);
        this.name = this.constructor.name;
        this.statusKod = statusKod;
        Error.captureStackTrace(this, this.constructor);
    }
}

class BulunamadiHatasi extends UygulamaHatasi {
    constructor(kaynak, id) {
        super(`${kaynak} #${id} bulunamadi`, 404);
        this.kaynak = kaynak;
        this.kaynakId = id;
    }
}

class DogrulamaHatasi extends UygulamaHatasi {
    constructor(alanlar) {
        super('Dogrulama hatasi', 400);
        this.alanlar = alanlar;
    }
}

class YetkilendirmeHatasi extends UygulamaHatasi {
    constructor(mesaj = 'Erisim yetkisi yok') {
        super(mesaj, 403);
    }
}

// Hata siniflarini kullanan servis
async function siparisOlustur(kullaniciId, urunId, miktar) {
    // Dogrulama
    const hatalar = [];
    if (!kullaniciId) hatalar.push('kullaniciId zorunlu');
    if (!urunId) hatalar.push('urunId zorunlu');
    if (!miktar || miktar < 1) hatalar.push('miktar en az 1 olmali');

    if (hatalar.length > 0) {
        throw new DogrulamaHatasi(hatalar);
    }

    // Kullanici kontrolu
    const kullanici = await kullaniciBul(kullaniciId);
    if (!kullanici) {
        throw new BulunamadiHatasi('Kullanici', kullaniciId);
    }

    return { siparisId: Date.now(), kullaniciId, urunId, miktar };
}

// Express-tarz merkezi hata yonetimi
async function istekIsleyici(req, res) {
    try {
        const siparis = await siparisOlustur(
            req.body.kullaniciId,
            req.body.urunId,
            req.body.miktar
        );
        return { status: 200, veri: siparis };
    } catch (error) {
        if (error instanceof DogrulamaHatasi) {
            return { status: 400, hata: error.message, alanlar: error.alanlar };
        }
        if (error instanceof BulunamadiHatasi) {
            return { status: 404, hata: error.message };
        }
        if (error instanceof YetkilendirmeHatasi) {
            return { status: 403, hata: error.message };
        }
        // Bilinmeyen hata
        console.error('KRITIK HATA:', error);
        return { status: 500, hata: 'Sunucu hatasi' };
    }
}

// Test
async function test() {
    console.log('=== Hata Sinifi Testleri ===\n');

    // Dogrulama hatasi
    try {
        await siparisOlustur(null, null, 0);
    } catch (e) {
        console.log(`${e.name} (${e.statusKod}): ${e.message}`);
        console.log('Alanlar:', e.alanlar);
    }

    // Basarili islem
    try {
        const siparis = await siparisOlustur(1, 'U001', 2);
        console.log('\nBasarili siparis:', siparis);
    } catch (e) {
        console.error(e.message);
    }
}

test();

Global Hata Yakalama​

Son olarak, yakalanmamis hatalari global olarak yakalamak cok onemlidir. Node.js'te iki onemli event var: unhandledRejection ve uncaughtException. Bunlari dinlemezseniz, uygulamaniz sessizce hata yutabilir veya crash edebilir. Production'da mutlaka bu event'leri dinleyin ve loglama yapin.

Benim aliskanaligim su: her projede bir error handler middleware'i ve global hata yakalayicilari kurmak. Bu sayede hicbir hata kaybolmaz ve sorun cikardiginda hemen tespit edebilirim. Unutmayin, bir hatayi bilmemek, o hatayi cozmemekten cok daha tehlikelidir. Neyse, bu kadarlik bu konu. for await...of ile devam edicez!

 

[Best Studio]

Emeğiniz ve katkınız için teşekkür ederiz!
Konunuz gerekli incelemelerden geçerek onaylandı. Topluluğumuza katkılarınızın devamını bekliyoruz.
İyi forumlar!