Asinchronizavimo / laukimo įvaldymas: asinchroninių funkcijų grandinių tvarkymas „JavaScript“.

„JavaScript“ asinchroninių funkcijų grandinės tvarkymas

Asinchroninės operacijos yra pagrindinė šiuolaikinio „JavaScript“ programavimo dalis, leidžianti neblokuoti vykdymo tokiose aplinkose kaip naršyklės ir Node.js. Tačiau asinchroninių funkcijų, kurios skambina viena kitai, srauto valdymas gali būti sudėtingas, ypač kai norite laukti paskutinės grandinės funkcijos nesustabdydami viso proceso.

Pagal šį scenarijų mes dažnai pasikliaujame „JavaScript“. async/laukti ir Pažadai valdyti sudėtingus asinchroninius srautus. Tačiau pasitaiko atvejų, kai naudoti pažadus ar laukti kiekvienos funkcijos iškvietimo netinka, pavyzdžiui, kai programa turi tęsti vykdymą nelaukdama greito atsakymo. Tai sukuria naują iššūkį kūrėjams.

Jūsų pateiktame pavyzdyje parodyta įprasta situacija, kai kelios funkcijos suaktyvinamos asinchroniškai, ir mums reikia būdo, kaip nustatyti, kada buvo iškviesta paskutinė funkcija. Tradicinių pažadų naudojimas čia gali būti ribojamas, nes sustabdo skambinimo funkciją, verčia ją laukti rezultato, o ne tęsti jo srautą.

Šiame straipsnyje mes išnagrinėsime, kaip išspręsti šią problemą naudojant „JavaScript“. async/laukti mechanizmas. Išnagrinėsime praktinį metodą, kaip užtikrinti, kad pagrindinė funkcija galėtų vykti be tiesioginio laukimo, tačiau vis tiek užfiksuota paskutinės grandinės funkcijos užbaigimas.

Asinchroninių funkcijų tvarkymas naudojant asinchroninį / laukimą ir atgalinius skambučius

Pirmasis scenarijus naudoja async/laukti valdyti asinchroninių funkcijų vykdymą. The async raktinis žodis leidžia funkcijoms grąžinti pažadą, todėl lengviau atlikti asinchronines operacijas nuosekliai. Šiuo atveju FunctionFirst yra atsakinga už funkcijosSecond iškvietimą asinchroniškai naudojant setTimeout. Nors functionFirst nelaukia, kol functionSecond baigsis, mes naudojame laukti FunctionMain, kad užtikrintumėte, jog pagrindinė gija prieš tęsdama lauktų visų asinchroninių operacijų pabaigos. Tai leidžia geriau valdyti asinchroninių įvykių srautą, kartu išlaikant neblokuojančią „JavaScript“ elgseną.

Pagrindinis šio metodo pranašumas yra tas, kad galime valdyti sudėtingus asinchroninius srautus neblokuodami kitų funkcijų vykdymo. Vietoj to, kad programa būtų priversta laukti kiekvieno funkcijos iškvietimo metu, async/wait leidžia toliau vykdyti kodui, kol laukiama pažadų, kurie bus išspręsti fone. Tai pagerina našumą ir užtikrina, kad vartotojo sąsaja reaguoja į priekines programas. Kiekvienos funkcijos delsa imituoja tikrą asinchroninę užduotį, pvz., serverio užklausą arba duomenų bazės užklausą. Pažado mechanizmas išsprendžiamas, kai vykdomos visos grandinės funkcijos, užtikrinant, kad galutinis žurnalo teiginys būtų rodomas tik viską atlikus.

Antrame sprendime mes naudojame atgaliniai skambučiai kad būtų pasiektas panašus neblokuojantis asinchroninis srautas. Kai iškviečiamas functionFirst, jis suaktyvina functionSecond ir iškart grįžta, nelaukdamas, kol bus baigtas. Atšaukimo funkcija, perduodama kaip argumentas, padeda valdyti srautą, suaktyvinant kitą grandinės funkciją, kai baigiasi dabartinė. Šis modelis ypač naudingas aplinkose, kur mums reikia daugiau tiesioginės vykdymo tvarkos kontrolės, nenaudojant pažadų ar asinchronizavimo / laukimo. Tačiau atgaliniai skambučiai gali sukelti „atšaukimo pragarą“, kai susiduriama su giliomis asinchroninių operacijų grandinėmis.

Galiausiai naudojamas trečiasis sprendimas Node.js EventEmitter kad asinchroniniai skambučiai būtų tvarkomi sudėtingesniu būdu. Išsiųsdami pasirinktinius įvykius pasibaigus kiekvienai asinchroninei funkcijai, įgyjame visišką kontrolę, kada suaktyvinti kitą funkciją. Įvykiais pagrįstas programavimas yra ypač efektyvus foninėse aplinkose, nes leidžia naudoti daugiau keičiamo dydžio ir prižiūrimą kodą atliekant kelias asinchronines operacijas. The skleisti metodas siunčia signalus, kai įvyksta konkretūs įvykiai, o klausytojai šiuos įvykius apdoroja asinchroniškai. Šis metodas užtikrina, kad pagrindinė funkcija tęstųsi tik tada, kai įvykdoma paskutinė grandinės funkcija, todėl asinchroniniam užduočių valdymui siūlomas labiau modulinis ir daugkartinio naudojimo būdas.

// Solution 1: Using async/await with Promises in JavaScript
async function functionFirst() {
  console.log('First is called');
  setTimeout(functionSecond, 1000);
  console.log('First fired Second and does not wait for its execution');
  return new Promise(resolve => {
    setTimeout(resolve, 2000); // Set timeout for the entire chain to complete
  });
}

function functionSecond() {
  console.log('Second is called');
  setTimeout(functionLast, 1000);
}

function functionLast() {
  console.log('Last is called');
}

async function functionMain() {
  await functionFirst();
  console.log('called First and continue only after Last is done');
}

functionMain();

// Solution 2: Using Callbacks to Manage Asynchronous Flow Without Blocking
function functionFirst(callback) {
  console.log('First is called');
  setTimeout(() => {
    functionSecond(callback);
  }, 1000);
  console.log('First fired Second and does not wait for its execution');
}

function functionSecond(callback) {
  console.log('Second is called');
  setTimeout(() => {
    functionLast(callback);
  }, 1000);
}

function functionLast(callback) {
  console.log('Last is called');
  callback();
}

function functionMain() {
  functionFirst(() => {
    console.log('called First and continue only after Last is done');
  });
}

functionMain();

// Solution 3: Using Node.js EventEmitter to Handle Asynchronous Functions
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();

function functionFirst() {
  console.log('First is called');
  setTimeout(() => {
    eventEmitter.emit('secondCalled');
  }, 1000);
  console.log('First fired Second and does not wait for its execution');
}

function functionSecond() {
  console.log('Second is called');
  setTimeout(() => {
    eventEmitter.emit('lastCalled');
  }, 1000);
}

function functionLast() {
  console.log('Last is called');
}

eventEmitter.on('secondCalled', functionSecond);
eventEmitter.on('lastCalled', functionLast);

function functionMain() {
  functionFirst();
  eventEmitter.on('lastCalled', () => {
    console.log('called First and continue only after Last is done');
  });
}

functionMain();

Pažangūs asinchroninių funkcijų vykdymo „JavaScript“ valdymo būdai

Vartojant async/laukti ir atgaliniai skambučiai yra veiksmingi asinchroniniams „JavaScript“ srautams valdyti, kitas galingas įrankis, į kurį verta atkreipti dėmesį, yra „JavaScript“ naudojimas generatoriai kartu su asinchronine funkcija. Generatoriaus funkcija leidžia grąžinti kontrolę skambinančiajam, todėl ji puikiai tinka iteraciniams procesams valdyti. Sujungus generatorius su Pažadai, galite pristabdyti ir atnaujinti vykdymą dar labiau kontroliuojamu būdu, suteikdami dar vieną lankstumo lygmenį asinchroninėms darbo eigoms.

Generatoriai gali būti ypač naudingi scenarijuose, kai reikia detalesnės asinchroninių funkcijų iškvietimų kontrolės. Jie veikia leisdami atlikti vykdymą tam tikruose taškuose ir laukti, kol bus atnaujintas išorinis signalas arba pažadas, kad sprendimas bus atnaujintas. Tai naudinga tais atvejais, kai turite sudėtingų funkcijų priklausomybių arba reikia atlikti neblokuojančias operacijas atliekant kelis veiksmus. Nors async/laukti dažnai yra paprastesnis, naudojant generatorius suteikiama galimybė valdyti asinchroninį srautą labiau pritaikytu būdu.

Kitas svarbus aspektas yra klaidų tvarkymas asinchroniniame kode. Skirtingai nuo sinchroninių operacijų, asinchroninių funkcijų klaidos turi būti pašalintos pabandyti/pagauti blokus arba tvarkydami atmestus pažadus. Svarbu į asinchronizavimo darbo eigas visada įtraukti tinkamą klaidų tvarkymą, nes taip užtikrinama, kad sugedus vienai grandinės funkcijai, nebus pažeista visa programa. Pridėję registravimo mechanizmus prie asinchroninių operacijų taip pat galėsite stebėti našumą ir diagnozuoti sudėtingų asinchroninių srautų problemas.