Asinhronas/gaidīšanas apgūšana: asinhrono funkciju ķēžu apstrāde JavaScript

Darbs ar asinhrono funkciju ķēdi JavaScript

Asinhronās darbības ir mūsdienu JavaScript programmēšanas galvenā sastāvdaļa, kas nodrošina nebloķējošu izpildi tādās vidēs kā pārlūkprogrammas un Node.js. Tomēr to asinhrono funkciju plūsmas pārvaldība, kas izsauc viena otru, var būt sarežģīta, it īpaši, ja vēlaties gaidīt ķēdes pēdējo funkciju, neapturot visu procesu.

Šajā scenārijā mēs bieži paļaujamies uz JavaScript async/wait un Solījumi lai apstrādātu sarežģītas asinhronas plūsmas. Bet ir gadījumi, kad Promises lietošana vai katras funkcijas izsaukuma gaidīšana nav piemērota, piemēram, kad programmai jāturpina izpilde, negaidot tūlītēju atbildi. Tas izstrādātājiem rada jaunu izaicinājumu.

Jūsu sniegtajā piemērā ir parādīta izplatīta situācija, kad vairākas funkcijas tiek aktivizētas asinhroni, un mums ir nepieciešams veids, kā noteikt, kad pēdējā funkcija ir izsaukta. Tradicionālo solījumu izmantošana šeit var būt ierobežojoša, jo tā aptur zvanīšanas funkciju, liekot tai gaidīt rezultātu, nevis turpināt savu plūsmu.

Šajā rakstā mēs izpētīsim, kā atrisināt šo problēmu, izmantojot JavaScript async/wait mehānisms. Mēs apskatīsim praktisku pieeju, lai nodrošinātu, ka galvenā funkcija var turpināties bez tiešas gaidīšanas, vienlaikus saglabājot ķēdes pēdējās funkcijas pabeigšanu.

Izpratne par asinhrono funkciju apstrādi, izmantojot Async/Await un atzvanīšanu

Pirmais skripts izmanto async/wait lai pārvaldītu asinhrono funkciju izpildi. The asinhrons atslēgvārds ļauj funkcijām atgriezt solījumu, atvieglojot asinhrono darbību secīgu apstrādi. Šajā gadījumā functionFirst ir atbildīga par FunctionSecond izsaukšanu asinhroni izmantojot setTimeout. Pat ja functionFirst negaida, līdz functionSecond beigsies, mēs izmantojam gaidīt FunctionMain, lai nodrošinātu, ka galvenais pavediens pirms turpināšanas gaida visu asinhrono darbību pabeigšanu. Tas nodrošina labāku asinhrono notikumu plūsmas kontroli, vienlaikus saglabājot nebloķējošu darbību JavaScript.

Šīs pieejas galvenā priekšrocība ir tā, ka mēs varam apstrādāt sarežģītas asinhronās plūsmas, nebloķējot citu funkciju izpildi. Tā vietā, lai piespiestu programmu gaidīt katrā funkcijas izsaukumā, async/await ļauj kodam turpināt izpildi, gaidot solījumu atrisināšanu fonā. Tas uzlabo veiktspēju un nodrošina lietotāja interfeisa atsaucību priekšgala lietojumprogrammās. Katras funkcijas aizkave simulē faktisku asinhronu uzdevumu, piemēram, servera pieprasījumu vai datu bāzes vaicājumu. Promise mehānisms tiek atrisināts, kad visas ķēdes funkcijas ir izpildītas, nodrošinot, ka galīgais žurnāla paziņojums parādās tikai pēc tam, kad viss ir izdarīts.

Otrajā risinājumā mēs izmantojam atzvani lai panāktu līdzīgu nebloķējošu asinhrono plūsmu. Kad tiek izsaukts functionFirst, tas aktivizē functionSecond un nekavējoties atgriežas, negaidot tā pabeigšanu. Atzvanīšanas funkcija, kas nodota kā arguments, palīdz kontrolēt plūsmu, aktivizējot nākamo ķēdes funkciju, kad pašreizējā funkcija ir pabeigta. Šis modelis ir īpaši noderīgs vidēs, kur mums nepieciešama tiešāka kontrole pār izpildes secību, neizmantojot solījumus vai asinhronizāciju/gaidīšanu. Tomēr, strādājot ar dziļām asinhrono darbību ķēdēm, atzvanīšana var izraisīt “atzvanīšanas elli”.

Visbeidzot, tiek izmantots trešais risinājums Node.js EventEmitter lai sarežģītāk apstrādātu asinhronos zvanus. Izdodot pielāgotus notikumus pēc katras asinhronās funkcijas pabeigšanas, mēs iegūstam pilnu kontroli pār to, kad aktivizēt nākamo funkciju. Uz notikumiem balstīta programmēšana ir īpaši efektīva aizmugursistēmas vidēs, jo tā nodrošina vairāk mērogojamu un uzturējamu kodu, strādājot ar vairākām asinhronām operācijām. The izstaro metode sūta signālus, kad notiek konkrēti notikumi, un klausītāji apstrādā šos notikumus asinhroni. Šī metode nodrošina, ka galvenā funkcija turpinās tikai tad, kad ķēdē ir izpildīta pēdējā funkcija, piedāvājot modulārāku un atkārtoti lietojamu pieeju asinhrono uzdevumu pārvaldībai.

// 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();

Uzlabotas metodes asinhrono funkciju izpildes pārvaldībai JavaScript

Lietojot async/wait un atzvani ir efektīvas asinhrono plūsmu apstrādei JavaScript, vēl viens spēcīgs rīks, kas ir pelnījis uzmanību, ir JavaScript izmantošana ģeneratori apvienojumā ar asinhrono funkcionalitāti. Ģeneratora funkcija ļauj jums atdot kontroli zvanītājam, padarot to ideāli piemērotu iteratīvu procesu apstrādei. Savienojot ģeneratorus ar Solījumi, varat apturēt un atsākt izpildi vēl kontrolētākā veidā, piedāvājot vēl vienu elastības līmeni asinhronām darbplūsmām.

Ģeneratori var būt īpaši noderīgi scenārijos, kad nepieciešama precīzāka kontrole pār asinhrono funkciju izsaukumiem. Tie darbojas, ļaujot jums nodrošināt izpildi noteiktos punktos un gaidīt ārēju signālu vai solījumu atsākt risinājumu. Tas ir noderīgi gadījumos, kad starp funkcijām ir sarežģītas atkarības vai ir nepieciešamas nebloķējošas darbības vairākās darbībās. Lai gan async/wait bieži vien ir vienkāršāk, ģeneratoru izmantošana sniedz iespēju kontrolēt asinhrono plūsmu pielāgotākā veidā.

Vēl viens svarīgs apsvērums ir kļūdu apstrāde asinhronajā kodā. Atšķirībā no sinhronajām darbībām, asinhrono funkciju kļūdas ir jānovērš mēģināt/noķert blokus vai apstrādājot noraidītos solījumus. Ir svarīgi savās asinhronajās darbplūsmās vienmēr iekļaut pareizu kļūdu apstrādi, jo tas nodrošina, ka, ja viena ķēdes funkcija neizdodas, tā neizjauc visu lietojumprogrammu. Reģistrācijas mehānismu pievienošana asinhronajām darbībām arī ļaus izsekot veiktspējai un diagnosticēt problēmas sarežģītās asinhronās plūsmās.