[NODE JS] Promise.any ile Ilk Basarili Sonucu Alma

Silverhand · 13 Tem 2026

[NODE JS] Promise.any ile Ilk Basarili Sonucu Alma

Selam arkadaslar, bugun ES2021 ile gelen Promise.any fonksiyonunu anlatacagim. Bu fonksiyon Promise.race'e benzer ama onemli bir farki var: race ilk sonuclanan Promise'i dondurur (basarisiz olsa bile), any ise ilk BASARILI olan Promise'i dondurur. Yani basarisiz olanları atlar ve ilk basarili sonucu size verir.

Promise.any vs Promise.race

Farki net bir ornekle aciklayayim. Diyelim ki 3 sunucunuz var ve birinden veri almaniz gerekiyor. Birinci sunucu down, ikincisi yavas ama calisiyor, ucuncusu hizli ve calisiyor. Promise.race ile denerseniz, birinci sunucu en hizli sekilde hata donecegi icin race hata ile sonuclanir. Ama Promise.any kullandiginizda, birinci sunucunun hatasini atlar ve calisan sunuculardan ilk cevap verenin sonucunu dondurur. Bu fallback stratejileri icin mukemmel bir arac.

Peki tum Promise'ler reject olursa ne olur? O zaman Promise.any bir AggregateError firlatir. Bu ozel hata tipi, tum hatalari bir dizi icinde tasir. Boylece her bir Promise'in neden basarisiz oldugunu inceleyebilirsiniz.

JavaScript:

// Promise.any temel kullanim
async function temelOrnek() {
    // Ilk basarili sonucu al
    try {
        const sonuc = await Promise.any([
            Promise.reject(new Error('Sunucu 1 down')),
            new Promise(resolve => setTimeout(() => resolve('Sunucu 2 cevap verdi'), 200)),
            new Promise(resolve => setTimeout(() => resolve('Sunucu 3 cevap verdi'), 100))
        ]);

        console.log('Ilk basarili:', sonuc); // Sunucu 3 cevap verdi
    } catch (error) {
        console.error('Hepsi basarisiz:', error.errors);
    }
}

temelOrnek();

// Tum Promise'ler reject olursa
async function hepsiBasa risiz() {
    try {
        await Promise.any([
            Promise.reject(new Error('Hata 1')),
            Promise.reject(new Error('Hata 2')),
            Promise.reject(new Error('Hata 3'))
        ]);
    } catch (error) {
        console.log('\nAggregateError yakalandi!');
        console.log('Hata tipi:', error.constructor.name);
        console.log('Tum hatalar:');
        error.errors.forEach((e, i) => {
            console.log(`  ${i + 1}. ${e.message}`);
        });
    }
}

hepsiBasa risiz();

Gercek Hayat: Fallback Stratejisi

Promise.any'nin en yaygin kullanim alani fallback stratejisidir. Birden fazla kaynagin ayni veriyi sunabildigini durumlarda, hangisi ilk basarili cevap verirse onu kullanirsiniz. Bu yaklasim yuksek erisilebilirlik (high availability) gerektiren sistemlerde cok degerlidir.

Ben bir projede CDN fallback'i icin kullanmistim. Ana CDN'den resim yukleyemezse yedek CDN'yi deniyor, o da olmazsa orijinal sunucudan aliyordu. Promise.any bu senaryoyu tek satirda cozdü.

JavaScript:

// CDN Fallback ornegi
async function resimYukle(resimAdi) {
    const cdnListesi = [
        `https://cdn1.example.com/img/${resimAdi}`,
        `https://cdn2.example.com/img/${resimAdi}`,
        `https://origin.example.com/img/${resimAdi}`
    ];

    try {
        const sonuc = await Promise.any(
            cdnListesi.map((url, index) => {
                return new Promise((resolve, reject) => {
                    const gecikme = (index + 1) * 100;
                    setTimeout(() => {
                        if (Math.random() > 0.5) {
                            resolve({ url, boyut: 1024, sure: gecikme });
                        } else {
                            reject(new Error(`${url} erisim hatasi`));
                        }
                    }, gecikme);
                });
            })
        );

        console.log(`Resim yuklendi: ${sonuc.url} (${sonuc.sure}ms)`);
        return sonuc;
    } catch (error) {
        console.error('Hicbir CDN erisim saglanamadi!');
        console.error('Hatalar:', error.errors.map(e => e.message));
        throw error;
    }
}

// Veritabani fallback
async function veriOku(anahtar) {
    try {
        const sonuc = await Promise.any([
            // Once Redis cache dene
            new Promise((resolve, reject) => {
                setTimeout(() => {
                    const onbellek = { user_1: { ad: 'Ahmet', kaynak: 'redis' } };
                    if (onbellek[anahtar]) {
                        resolve(onbellek[anahtar]);
                    } else {
                        reject(new Error('Cache miss'));
                    }
                }, 10);
            }),

            // Sonra birincil veritabani
            new Promise((resolve, reject) => {
                setTimeout(() => {
                    const vt = { user_1: { ad: 'Ahmet', kaynak: 'primary-db' } };
                    if (vt[anahtar]) {
                        resolve(vt[anahtar]);
                    } else {
                        reject(new Error('Birincil VT bulamadi'));
                    }
                }, 50);
            }),

            // En son yedek veritabani
            new Promise((resolve, reject) => {
                setTimeout(() => {
                    const yedek = { user_1: { ad: 'Ahmet', kaynak: 'replica-db' } };
                    if (yedek[anahtar]) {
                        resolve(yedek[anahtar]);
                    } else {
                        reject(new Error('Yedek VT bulamadi'));
                    }
                }, 100);
            })
        ]);

        console.log(`Veri bulundu (${sonuc.kaynak}):`, sonuc);
        return sonuc;
    } catch (error) {
        console.error('Hicbir kaynaktan veri alinamadi');
        return null;
    }
}

// Kullanim
async function main() {
    console.log('=== CDN Fallback ===');
    await resimYukle('profil.jpg').catch(() => {});

    console.log('\n=== Veritabani Fallback ===');
    await veriOku('user_1');
}

main().catch(console.error);

Promise Metodlari Karsilastirma Tablosu

Simdi ogrendigimiz dort Promise metodunu toparlayalim. Promise.all: tumu basarili olmali, biri fail olursa hepsi fail. Promise.allSettled: tum sonuclari al, basari basarisizlik farketmez. Promise.race: ilk sonuclanan (basarili veya basarisiz). Promise.any: ilk basarili sonuclanan, hepsi fail olursa AggregateError.

Hangisini ne zaman kullanacaginiz tamamen senaryonuza baglidir. Ben genelde su sekilde karar veriyorum: bagimsiz islemler ve hepsinin sonucu lazimsa allSettled, hepsinin basarili olmasi sartsa all, en hizli cevap yeterliyse ve hata da olabilirse race, en hizli basarili cevap lazimsa any. Hadi, sonraki konumuz async/await, en sevdigim konu!

Best Studio · Çarşamba saat 17:21'de

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!

[NODE JS] Promise.any ile Ilk Basarili Sonucu Alma

Silverhand