JavaScripti Samaaegsuse Valdamine: Süvaülevaade Paralleelsest Promise'ide Töötlemisest

Tänapäevase veebiarenduse maastikul ei ole jõudlus mitte funktsioon, vaid fundamentaalne nõue. Kasutajad üle maailma ootavad, et rakendused oleksid kiired, reageerivad ja sujuvad. Selle jõudluse väljakutse keskmes, eriti JavaScriptis, peitub asünkroonsete operatsioonide tõhusa haldamise kontseptsioon. Alates andmete hankimisest API-st kuni faili lugemise või andmebaasipäringuni – paljud ülesanded ei lõpe koheselt. See, kuidas me neid ooteaegu haldame, võib teha vahet aeglase rakenduse ja meeldivalt sujuva kasutajakogemuse vahel.

JavaScript on oma olemuselt ühelõimeline keel. See tähendab, et see suudab korraga täita ainult ühte koodijuppi. See võib kõlada piiranguna, kuid JavaScripti sündmuste tsükkel (event loop) ja mitteblokeeriv I/O mudel võimaldavad tal käsitleda asünkroonseid ülesandeid uskumatult tõhusalt. Selle mudeli kaasaegne nurgakivi on Promise – objekt, mis esindab asünkroonse operatsiooni lõplikku õnnestumist (või ebaõnnestumist).

Siiski ei taga lihtsalt Promise'ide või nende elegantse `async/await` süntaksi kasutamine automaatselt optimaalset jõudlust. Arendajate tavaline lõks on mitme sõltumatu asünkroonse ülesande järjestikune käsitlemine, mis loob tarbetuid kitsaskohti. Siin tulebki mängu samaaegne promise'ide töötlemine. Käivitades mitu asünkroonset operatsiooni paralleelselt ja oodates nende kõigi lõppu ühiselt, saame drastiliselt vähendada kogu täitmisaega ja ehitada palju tõhusamaid rakendusi.

See põhjalik juhend viib teid sügavale JavaScripti samaaegsuse maailma. Uurime keelde sisseehitatud tööriistu – `Promise.all()`, `Promise.allSettled()`, `Promise.race()` ja `Promise.any()` – et aidata teil orkestreerida paralleelseid ülesandeid nagu professionaal. Olenemata sellest, kas olete nooremarendaja, kes alles tutvub asünkroonsusega, või kogenud insener, kes soovib oma mustreid täiustada, varustab see artikkel teid teadmistega, et kirjutada kiiremat, vastupidavamat ja keerukamat JavaScripti koodi.

Esmalt kiire selgitus: Samaaegsus vs. Paralleelsus

Enne kui jätkame, on oluline selgitada kahte terminit, mida kasutatakse sageli sünonüümidena, kuid millel on arvutiteaduses erinev tähendus: samaaegsus ja paralleelsus.

• Samaaegsus (Concurrency) on mitme ülesande haldamise kontseptsioon teatud ajaperioodi jooksul. See on paljude asjadega korraga tegelemine. Süsteem on samaaegne, kui see suudab alustada, käitada ja lõpetada rohkem kui ühe ülesande, ootamata eelmise lõppu. JavaScripti ühelõimelises keskkonnas saavutatakse samaaegsus sündmuste tsükli kaudu, mis võimaldab mootoril ülesannete vahel vahetada. Sel ajal kui üks pikaajaline ülesanne (nagu võrgupäring) ootab, saab mootor tegeleda muude asjadega.
• Paralleelsus (Parallelism) on mitme ülesande samaaegse täitmise kontseptsioon. See on paljude asjade tegemine korraga. Tõeline paralleelsus nõuab mitmetuumalist protsessorit, kus erinevad lõimed saavad joosta erinevatel tuumadel täpselt samal ajal. Kuigi veebitöötajad (web workers) võimaldavad brauseripõhises JavaScriptis tõelist paralleelsust, puudutab siin käsitletav peamine samaaegsuse mudel ühte peamist lõime.

I/O-ga seotud operatsioonide (nagu võrgupäringud) puhul annab JavaScripti samaaegne mudel paralleelsuse *efekti*. Saame algatada mitu päringut korraga. Sel ajal kui JavaScripti mootor ootab vastuseid, on see vaba tegema muud tööd. Operatsioonid toimuvad väliste ressursside (serverid, failisüsteemid) vaatenurgast 'paralleelselt'. See on võimas mudel, mida me kasutama hakkame.

Järjestikune lõks: Levinud vale muster

Alustame levinud vea tuvastamisest. Kui arendajad esimest korda `async/await`-i õpivad, on süntaks nii puhas, et on lihtne kirjutada koodi, mis näeb välja sünkroonne, kuid on tahtmatult järjestikune ja ebaefektiivne. Kujutage ette, et peate armatuurlaua ehitamiseks hankima kasutaja profiili, tema hiljutised postitused ja tema teated.

Naiivne lähenemine võib välja näha selline:

Näide: Ebaefektiivne järjestikune päring

            
async function fetchDashboardDataSequentially(userId) {
    console.time('sequentialFetch');

    console.log('Kasutajaprofiili hankimine...');
    const userProfile = await fetchUserProfile(userId); // Ootab siin

    console.log('Kasutaja postituste hankimine...');
    const userPosts = await fetchUserPosts(userId); // Ootab siin

    console.log('Kasutaja teadete hankimine...');
    const userNotifications = await fetchUserNotifications(userId); // Ootab siin

    console.timeEnd('sequentialFetch');
    return { userProfile, userPosts, userNotifications };
}

// Kujutage ette, et nende funktsioonide lahendamine võtab aega
// fetchUserProfile -> 500ms
// fetchUserPosts -> 800ms
// fetchUserNotifications -> 1000ms

            

              
                Copy
              
            
          

Mis sellel pildil valesti on? Iga `await` võtmesõna peatab `fetchDashboardDataSequentially` funktsiooni täitmise, kuni promise laheneb. `userPosts` päring ei alga isegi enne, kui `userProfile` päring on täielikult lõpule viidud. `userNotifications` päring ei alga enne, kui `userPosts` on tagasi. Need kolm võrgupäringut on üksteisest sõltumatud; pole mingit põhjust oodata! Kogu kuluv aeg on kõigi üksikute aegade summa:

Koguaeg ≈ 500ms + 800ms + 1000ms = 2300ms

See on tohutu jõudluse kitsaskoht. Me saame teha palju, palju paremini.

Jõudluse vabastamine: Samaaegse täitmise jõud

Lahendus on algatada kõik asünkroonsed operatsioonid korraga, ilma neid kohe ootamata. See võimaldab neil joosta samaaegselt. Saame salvestada ootel Promise-objektid muutujatesse ja seejärel kasutada Promise'ide kombinaatorit, et oodata nende kõigi lõpulejõudmist.

Näide: Efektiivne samaaegne päring

            
async function fetchDashboardDataConcurrently(userId) {
    console.time('concurrentFetch');

    console.log('Kõigi päringute algatamine korraga...');
    const profilePromise = fetchUserProfile(userId);
    const postsPromise = fetchUserPosts(userId);
    const notificationsPromise = fetchUserNotifications(userId);

    // Nüüd ootame, kuni need kõik on lõpule jõudnud
    const [userProfile, userPosts, userNotifications] = await Promise.all([
        profilePromise,
        postsPromise,
        notificationsPromise
    ]);

    console.timeEnd('concurrentFetch');
    return { userProfile, userPosts, userNotifications };
}

            

              
                Copy
              
            
          

Selles versioonis kutsume kolm päringufunktsiooni välja ilma `await`-ita. See käivitab kohe kõik kolm võrgupäringut. JavaScripti mootor annab need üle aluseks olevale keskkonnale (brauser või Node.js) ja saab tagasi kolm ootel Promise'i. Seejärel kasutatakse `Promise.all()`, et oodata kõigi kolme promise'i lahenemist. Kogu kuluv aeg määratakse nüüd kõige kauem kestva operatsiooni, mitte summa järgi.

Koguaeg ≈ max(500ms, 800ms, 1000ms) = 1000ms

Oleme just oma andmete hankimise aega vähendanud rohkem kui poole võrra! See on paralleelse promise'ide töötlemise põhiprintsiip. Nüüd uurime võimsaid tööriistu, mida JavaScript pakub nende samaaegsete ülesannete orkestreerimiseks.

Promise'ide kombinaatorite tööriistakast: `all`, `allSettled`, `race` ja `any`

JavaScript pakub `Promise` objektil nelja staatilist meetodit, mida tuntakse promise'ide kombinaatoritena. Igaüks neist võtab sisendiks itereeritava objekti (nagu massiiv) promise'idest ja tagastab uue üksiku promise'i. Selle uue promise'i käitumine sõltub sellest, millist kombinaatorit te kasutate.

1. `Promise.all()`: Kõik-või-mitte-midagi lähenemine

`Promise.all()` on ideaalne tööriist, kui teil on rühm ülesandeid, mis on kõik järgmise sammu jaoks kriitilised. See esindab loogilist "JA" tingimust: Ülesanne 1 JA Ülesanne 2 JA Ülesanne 3 peavad kõik õnnestuma.

• Sisend: Itreeritav objekt promise'idest.
• Käitumine: See tagastab ühe promise'i, mis täitub, kui kõik sisend-promise'id on täitunud. Täidetud väärtus on massiiv sisend-promise'ide tulemustest, samas järjekorras.
• Tõrkerežiim: See lükkub tagasi kohe, kui mõni sisend-promise tagasi lükatakse. Tagasilükkamise põhjus on esimese tagasi lükatud promise'i põhjus. Seda nimetatakse sageli "fail-fast" käitumiseks.

Kasutusjuhtum: Kriitiliste andmete agregeerimine

Meie armatuurlaua näide on ideaalne kasutusjuhtum. Kui te ei saa kasutaja profiili laadida, ei pruugi tema postituste ja teadete kuvamine olla mõttekas. Kogu komponent sõltub kõigi kolme andmepunkti olemasolust.

            
// Abifunktsioon API-kõnede simuleerimiseks
const mockApiCall = (value, delay, shouldFail = false) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (shouldFail) {
                reject(new Error(`API-kõne ebaõnnestus: ${value}`));
            } else {
                console.log(`Lahendatud: ${value}`);
                resolve({ data: value });
            }
        }, delay);
    });
};

async function loadCriticalData() {
    console.log('Kasutades Promise.all kriitiliste andmete jaoks...');
    try {
        const [profile, settings, permissions] = await Promise.all([
            mockApiCall('userProfile', 400),
            mockApiCall('userSettings', 700),
            mockApiCall('userPermissions', 500)
        ]);
        console.log('Kõik kriitilised andmed laaditi edukalt!');
        // Nüüd renderda kasutajaliides profiili, seadete ja õigustega
    } catch (error) {
        console.error('Kriitiliste andmete laadimine ebaõnnestus:', error.message);
        // Näita kasutajale veateadet
    }
}

// Mis juhtub, kui üks ebaõnnestub?
async function loadCriticalDataWithFailure() {
    console.log('\nDemonstreerides Promise.all ebaõnnestumist...');
    try {
        const results = await Promise.all([
            mockApiCall('userProfile', 400),
            mockApiCall('userSettings', 700, true), // See ebaõnnestub
            mockApiCall('userPermissions', 500)
        ]);
    } catch (error) {
        console.error('Promise.all lükati tagasi:', error.message);
        // Märkus: 'userProfile' ja 'userPermissions' kõned võisid lõpule jõuda,
        // kuid nende tulemused on kadunud, sest kogu operatsioon ebaõnnestus.
    }
}

loadCriticalData();
// Pärast viivitust kutsu välja ebaõnnestumise näide
setTimeout(loadCriticalDataWithFailure, 2000);


            

              
                Copy
              
            
          

`Promise.all()`-i lõks

Peamine lõks on selle "fail-fast" olemus. Kui te hangite andmeid kümnele erinevale, sõltumatule vidinale lehel ja üks API ebaõnnestub, lükkab `Promise.all()` tagasi ja te kaotate ülejäänud üheksa eduka kõne tulemused. Siin tulebki appi meie järgmine kombinaator.

2. `Promise.allSettled()`: Vastupidav koguja

ES2020-s tutvustatud `Promise.allSettled()` oli vastupidavuse seisukohast mängumuutja. See on mõeldud olukordadeks, kus soovite teada iga promise'i tulemust, olenemata sellest, kas see õnnestus või ebaõnnestus. See ei lükka kunagi tagasi.

• Sisend: Itreeritav objekt promise'idest.
• Käitumine: See tagastab ühe promise'i, mis alati täitub. See täitub, kui kõik sisend-promise'id on lahenenud (kas täitunud või tagasi lükatud). Täidetud väärtus on objektide massiiv, millest igaüks kirjeldab promise'i tulemust.
• Tulemuse formaat: Igal tulemusobjektil on `status` omadus.
  • Kui täitunud: `{ status: 'fulfilled', value: theResult }`
  • Kui tagasi lükatud: `{ status: 'rejected', reason: theError }`

Kasutusjuhtum: Mittekriitilised, sõltumatud operatsioonid

Kujutage ette lehte, mis kuvab mitut sõltumatut komponenti: ilmavidin, uudisvoog ja aktsiaindeks. Kui uudisvoo API ebaõnnestub, soovite siiski kuvada ilma ja aktsiainfot. `Promise.allSettled()` on selleks ideaalne.

            
async function loadDashboardWidgets() {
    console.log('\nKasutades Promise.allSettled sõltumatute vidinate jaoks...');
    const results = await Promise.allSettled([
        mockApiCall('Ilmaandmed', 600),
        mockApiCall('Uudisvoog', 1200, true), // See API on maas
        mockApiCall('Aktsiaindeks', 800)
    ]);

    console.log('Kõik promise\'id on lahenenud. Tulemuste töötlemine...');
    
    results.forEach((result, index) => {
        if (result.status === 'fulfilled') {
            console.log(`Vidin ${index} laaditi edukalt andmetega:`, result.value.data);
            // Renderda see vidin kasutajaliidesesse
        } else {
            console.error(`Vidina ${index} laadimine ebaõnnestus:`, result.reason.message);
            // Näita selle vidina jaoks spetsiifilist veaolukorda
        }
    });
}

loadDashboardWidgets();

            

              
                Copy
              
            
          

`Promise.allSettled()`-iga muutub teie rakendus palju vastupidavamaks. Üksik ebaõnnestumispunkt ei põhjusta kaskaadi, mis viib kogu kasutajaliidese kokkuvarisemiseni. Saate iga tulemust graatsiliselt käsitleda.

3. `Promise.race()`: Esimene finišijoonel

`Promise.race()` teeb täpselt seda, mida selle nimi viitab. See paneb rühma promise'e üksteisega võistlema ja kuulutab võitja välja niipea, kui esimene neist ületab finišijoone, olenemata sellest, kas see oli edu või ebaõnnestumine.

• Sisend: Itreeritav objekt promise'idest.
• Käitumine: See tagastab ühe promise'i, mis laheneb (täitub või lükatakse tagasi) niipea, kui esimene sisend-promise laheneb. Tagastatud promise'i täitumisväärtus või tagasilükkamise põhjus on "võitnud" promise'i oma.
• Oluline märkus: Teisi promise'e ei tühistata. Need jätkavad taustal töötamist ja nende tulemusi `Promise.race()` kontekstis lihtsalt ignoreeritakse.

Kasutusjuhtum: Ajalõpu rakendamine

Kõige levinum ja praktilisem kasutusjuhtum `Promise.race()` jaoks on asünkroonsele operatsioonile ajalõpu kehtestamine. Saate "võistelda" oma peamise operatsiooniga `setTimeout` promise'i vastu. Kui teie operatsioon võtab liiga kaua aega, laheneb ajalõpu promise esimesena ja saate seda käsitleda veana.

            
function createTimeout(delay) {
    return new Promise((_, reject) => {
        setTimeout(() => {
            reject(new Error(`Operatsioon aegus ${delay}ms pärast`));
        }, delay);
    });
}

async function fetchDataWithTimeout() {
    console.log('\nKasutades Promise.race ajalõpu jaoks...');
    try {
        const result = await Promise.race([
            mockApiCall('mõned kriitilised andmed', 2000), // See võtab liiga kaua aega
            createTimeout(1500) // See võidab võistluse
        ]);
        console.log('Andmed hangiti edukalt:', result.data);
    } catch (error) {
        console.error(error.message);
    }
}

fetchDataWithTimeout();

            

              
                Copy
              
            
          

Teine kasutusjuhtum: Liigsed lõpp-punktid

Võite kasutada `Promise.race()` ka sama ressursi päringuks mitmelt liigselt serverilt ja võtta vastuse sellelt serverilt, mis on kõige kiirem. See on aga riskantne, sest kui kiireim server tagastab vea (nt 500 olekukoodi), lükkab `Promise.race()` kohe tagasi, isegi kui veidi aeglasem server oleks tagastanud eduka vastuse. See viib meid meie viimase, selle stsenaariumi jaoks sobivama kombinaatorini.

4. `Promise.any()`: Esimene õnnestuja

ES2021-s tutvustatud `Promise.any()` on nagu `Promise.race()` optimistlikum versioon. See ootab samuti esimese promise'i lahenemist, kuid otsib spetsiifiliselt esimest, mis täitub.

• Sisend: Itreeritav objekt promise'idest.
• Käitumine: See tagastab ühe promise'i, mis täitub niipea, kui mõni sisend-promise täitub. Täitumisväärtus on esimese täitunud promise'i väärtus.
• Tõrkerežiim: See lükatakse tagasi ainult siis, kui kõik sisend-promise'id lükatakse tagasi. Tagasilükkamise põhjus on spetsiaalne `AggregateError` objekt, mis sisaldab `errors` omadust – massiivi kõigist individuaalsetest tagasilükkamise põhjustest.

Kasutusjuhtum: Andmete hankimine liigsetest allikatest

See on ideaalne tööriist ressursi hankimiseks mitmest allikast, näiteks esmasest ja varuserverist või mitmest sisuedastusvõrgust (CDN). Teid huvitab ainult ühe eduka vastuse saamine nii kiiresti kui võimalik.

            
async function fetchResourceFromMirrors() {
    console.log('\nKasutades Promise.any kiireima eduka allika leidmiseks...');
    try {
        const resource = await Promise.any([
            mockApiCall('Esmane CDN', 800, true), // Ebaõnnestub kiiresti
            mockApiCall('Euroopa peegel', 1200), // Aeglasem, kuid õnnestub
            mockApiCall('Aasia peegel', 1100) // Õnnestub samuti, kuid on Euroopa omast aeglasem
        ]);
        console.log('Ressurss hangiti edukalt peeglist:', resource.data);
    } catch (error) {
        if (error instanceof AggregateError) {
            console.error('Kõik peeglid ebaõnnestusid ressursi pakkumisel.');
            // Saate uurida üksikuid vigu:
            error.errors.forEach(err => console.log('- ' + err.message));
        }
    }
}

fetchResourceFromMirrors();

            

              
                Copy
              
            
          

Selles näites ignoreerib `Promise.any()` esmase CDN-i kiiret ebaõnnestumist ja ootab Euroopa peegli täitumist, misjärel see laheneb nende andmetega ja ignoreerib tõhusalt Aasia peegli tulemust.

Õige tööriista valimine: Kiirjuhend

Kuidas otsustada, millist neljast võimsast valikust kasutada? Siin on lihtne otsustusraamistik:

• Kas ma vajan KÕIGI promise'ide tulemusi ja kas on katastroof, kui MÕNI neist ebaõnnestub?
  Kasutage Promise.all(). See on mõeldud tihedalt seotud, kõik-või-mitte-midagi stsenaariumide jaoks.
• Kas ma pean teadma KÕIGI promise'ide tulemust, olenemata sellest, kas need õnnestuvad või ebaõnnestuvad?
  Kasutage Promise.allSettled(). See on mitme sõltumatu ülesande käsitlemiseks, kus soovite töödelda iga tulemust ja säilitada rakenduse vastupidavust.
• Kas mind huvitab ainult kõige esimene lõpetav promise, olenemata sellest, kas see on edu või ebaõnnestumine?
  Kasutage Promise.race(). See on peamiselt ajalõppude või muude võistlustingimuste rakendamiseks, kus ainult esimene tulemus (ükskõik milline) on oluline.
• Kas mind huvitab ainult esimene ÕNNESTUV promise ja ma võin ignoreerida kõiki, mis ebaõnnestuvad?
  Kasutage Promise.any(). See on mõeldud liiasust hõlmavate stsenaariumide jaoks, näiteks sama ressursi jaoks mitme lõpp-punkti proovimine.

Täpsemad mustrid ja reaalse maailma kaalutlused

Kuigi promise'ide kombinaatorid on uskumatult võimsad, nõuab professionaalne arendus sageli veidi rohkem nüansse.

Samaaegsuse piiramine ja koormuse hajutamine

Mis juhtub, kui teil on 1000 ID-ga massiiv ja soovite igaühe kohta andmeid hankida? Kui te naiivselt edastate kõik 1000 promise'i genereerivat kutset `Promise.all()`-i, käivitate koheselt 1000 võrgupäringut. Sellel võib olla mitu negatiivset tagajärge:

• Serveri ülekoormus: Võite üle koormata serveri, kust te päringuid teete, mis toob kaasa vigu või halvenenud jõudluse kõigile kasutajatele.
• Kasutuslimiidid (Rate Limiting): Enamikul avalikel API-del on kasutuslimiidid. Tõenäoliselt ületate oma limiidi ja saate `429 Too Many Requests` vigu.
• Kliendi ressursid: Klient (brauser või server) võib vaeva näha nii paljude avatud võrguühenduste haldamisega korraga.

Lahendus on piirata samaaegsust, töödeldes promise'e partiidena. Kuigi saate selleks oma loogika kirjutada, tegelevad sellega graatsiliselt küpsed teegid nagu `p-limit` või `async-pool`. Siin on kontseptuaalne näide, kuidas võiksite seda käsitsi läheneda:

            
async function processInBatches(items, batchSize, processingFn) {
    let results = [];
    for (let i = 0; i < items.length; i += batchSize) {
        const batch = items.slice(i, i + batchSize);
        console.log(`Töötlen partiid, mis algab indeksiga ${i}...`);
        
        const batchPromises = batch.map(processingFn);
        const batchResults = await Promise.allSettled(batchPromises);
        results = results.concat(batchResults);
    }
    return results;
}

// Kasutusnäide:
const userIds = Array.from({ length: 20 }, (_, i) => i + 1);

// Töötleme 20 kasutajat 5-kaupa partiidena
processInBatches(userIds, 5, id => mockApiCall(`user_${id}`, Math.random() * 1000))
    .then(allResults => {
        console.log('\nPartiide töötlemine on lõpule viidud.');
        const successful = allResults.filter(r => r.status === 'fulfilled').length;
        const failed = allResults.filter(r => r.status === 'rejected').length;
        console.log(`Tulemusi kokku: ${allResults.length}, Õnnestunud: ${successful}, Ebaõnnestunud: ${failed}`);
    });

            

              
                Copy
              
            
          

Märkus tühistamise kohta

Pikaajaline väljakutse natiivsete Promise'idega on see, et neid ei saa tühistada. Kui olete promise'i loonud, jookseb see lõpuni. Kuigi `Promise.race` aitab teil aeglast tulemust ignoreerida, jätkab aluseks olev operatsioon ressursside tarbimist. Võrgupäringute puhul on kaasaegne lahendus `AbortController` API, mis võimaldab teil anda `fetch`-päringule signaali, et see tuleks katkestada. `AbortController` integreerimine promise'ide kombinaatoritega võib pakkuda tugevat viisi pikaajaliste samaaegsete ülesannete haldamiseks ja puhastamiseks.

Kokkuvõte: Järjestikusest mõtlemisest samaaegseni

Asünkroonse JavaScripti valdamine on teekond. See algab ühelõimelise sündmuste tsükli mõistmisest, edeneb Promise'ide ja `async/await` kasutamiseni selguse huvides ning kulmineerub samaaegse mõtlemisega jõudluse maksimeerimiseks. Üleminek järjestikuselt `await` mõtteviisilt paralleelsusele orienteeritud lähenemisele on üks mõjukamaid muudatusi, mida arendaja saab rakenduse reageerimisvõime parandamiseks teha.

Kasutades sisseehitatud promise'ide kombinaatoreid, olete varustatud paljude reaalsete stsenaariumide elegantseks ja täpseks käsitlemiseks:

• Kasutage `Promise.all()` kriitiliste, kõik-või-mitte-midagi andmesõltuvuste jaoks.
• Toetuge `Promise.allSettled()`-ile, et ehitada vastupidavaid kasutajaliideseid sõltumatute komponentidega.
• Rakendage `Promise.race()`, et kehtestada ajapiiranguid ja vältida lõpmatuid ootamisi.
• Valige `Promise.any()`, et luua kiireid ja tõrketaluvusega süsteeme liigsete andmeallikatega.

Järgmine kord, kui leiate end kirjutamast mitut `await` lauset järjest, peatuge ja küsige: "Kas need operatsioonid on tõesti üksteisest sõltuvad?" Kui vastus on ei, on teil suurepärane võimalus oma koodi samaaegsuse jaoks ümber kujundada. Alustage oma promise'ide koos algatamist, valige oma loogika jaoks õige kombinaator ja vaadake, kuidas teie rakenduse jõudlus hüppeliselt kasvab.