Proučavamo Async/Await u JavaScriptu na primjerima

Autor članka objašnjava korištenje Async/Await u JavaScriptu kroz primjere. U osnovi, Async/Await je zgodan način za pisanje asinhronog koda. Prije nego što je ova mogućnost postojala, takav se kod pisao koristeći povratne pozive i promise. Autor originalnog članka otkriva prednosti Async/Await analizirajući različite primjere.

Podsećamo: za sve čitaoce „Habra“ — popust od 10.000 rubalja prilikom upisa na bilo koji kurs Skillbox uz promo kod „Habr“.

Skillbox preporučuje: Online obrazovni kurs „Java programer“.

Povratni poziv

Povratni poziv predstavlja funkciju čije se izvršenje odlaže na neodređeno vreme. Ranije su se povratni pozivi koristili u delovima koda gde se rezultat nije mogao dobiti odmah.

Evo primera asinhronog čitanja datoteke u Node.js:

fs.readFile(__filename, 'utf-8', (err, data) => {
  if (err) {
    throw err;
  }
  console.log(data);
});

Problemi se javljaju kada je potrebno izvršiti više asinhronih operacija odjednom. Zamislimo sledeći scenario: vrši se upit u bazi podataka za korisnika Arfat, potrebno je pročitati njegovo polje profile_img_url i preuzeti sliku sa servera someserver.com.
Nakon preuzimanja konvertujemo sliku u drugi format, na primer iz PNG u JPEG. Ako je konverzija bila uspešna, korisniku se šalje e-mail. Zatim se informacija o događaju upisuje u datoteku transformations.log sa oznakom datuma.

Vredi obratiti pažnju na složenost povratnih poziva i veliki broj }) u finalnom delu koda. Ovo se naziva Callback Hell ili Piramida Propasti.

Nedostaci ovog pristupa su očigledni:

  • Ovaj kod je teško čitati.
  • Takođe, teško je obraditi greške, što često dovodi do pogoršanja kvaliteta koda.

Da bi se rešio ovaj problem, u JavaScript su dodati promise. Oni omogućavaju da se duboka ugnježdenost povratnih poziva zameni sa .then.

Pozitivno u vezi sa promise je to da kod postaje mnogo lakši za čitanje, pri čemu se čita od vrha ka dnu, a ne sa leve na desnu stranu. Ipak, promise takođe imaju svoje probleme:

  • Potrebno je dodavati veliki broj .then.
  • Umesto try/catch koristi se .catch za obradu svih grešaka.
  • Rad sa više promise unutar jednog ciklusa nije uvek zgodan i u nekim slučajevima otežava kod.

Evo zadatka koji će prikazati značaj poslednje tačke.

Pretpostavimo da postoji for petlja koja ispisuje niz brojeva od 0 do 10 sa nasumičnim vremenskim intervalom (0–n sekundi). Koristeći promise, potrebno je promeniti ovu petlju tako da se brojevi ispisuju u redosledu od 0 do 10. Tako, ako ispis nula traje 6 sekundi, a jednog 2 sekunde, prvo će biti ispisana nula, a zatim će početi odbrojavanje za ispis jedinice.

I naravno, za rešenje ovog zadatka ne koristimo Async/Await ili .sort. Primer rešenja je na kraju.

Async funkcije

Dodavanje async funkcija u ES2017 (ES8) pojednostavilo je rad sa promise-ima. Napominjem da async funkcije rade 'na vrhu' promise-a. Ove funkcije ne predstavljaju kvalitativno drugačije koncepte. Async funkcije su zamišljene kao alternativa kodu koji koristi promise.

Async/Await omogućava organizaciju rada sa asinhronim kodom u sinkronom stilu.

Dakle, poznavanje promise-a olakšava razumevanje principa Async/Await.

Syntax

Uobičajeno se sastoji od dve ključne reči: async i await. Prva reč pretvara funkciju u asinhronu. U takvim funkcijama je dozvoljena upotreba await. U bilo kojem drugom slučaju korišćenje ove funkcije izazvaće grešku.

// With function declaration
 
async function myFn() {
  // await ...
}
 
// With arrow function
 
const myFn = async () => {
  // await ...
}
 
function myFn() {
  // await fn(); (Syntax Error since no async)
}
 

Async se stavlja na početku deklaracije funkcije, a u slučaju korišćenja streličaste funkcije — između znaka '=' i zagrade.

Ove funkcije se mogu staviti u objekat kao metode ili koristiti u deklaraciji klase.

// As an object's method
 
const obj = {
  async getName() {
    return fetch('https://www.example.com');
  }
}
 
// In a class
 
class Obj {
  async getResource() {
    return fetch('https://www.example.com');
  }
}

NB! Trebalo bi imati na umu da konstruktori klasa i getteri/setteri ne mogu biti asinhroni.

Semantika i pravila izvršenja

Async funkcije, u principu, su slične standardnim JS funkcijama, ali postoje i izuzeci.

Tako, async funkcije uvek vraćaju promise-e:

async function fn() {
  return 'hello';
}
fn().then(console.log)
// hello

Specifično, fn vraća string hello. Pošto je ovo asinhrona funkcija, vrednost stringa se obavija u promise pomoću konstruktora.

Evo alternativne konstrukcije bez Async:

function fn() {
  return Promise.resolve('hello');
}

fn().then(console.log);
// hello

U ovom slučaju, vraćanje promise-a se vrši 'ručno'. Asinhrona funkcija se uvek obavija u novi promise.

Ako je vraćena vrijednost primitivna, async-funkcija vraća vrijednost omotavajući je u promisu. Ako je vraćena vrijednost objekat promisa, njegovo rješenje vraća se u novom promisu.

const p = Promise.resolve('hello')
p instanceof Promise;
// true

Promise.resolve(p) === p;
// true
 

Ali šta će se desiti ako se unutar async-funkcije dogodi greška?

async function foo() {
  throw Error('bar');
}

foo().catch(console.log);

Ako se ne obradi, foo() će vratiti promisa sa rejetovanjem. U ovoj situaciji umesto Promise.resolve vraća se Promise.reject, koji sadrži grešku.

Async-funkcije uvek daju promisa kao izlaz, bez obzira na to šta se vraća.

Asinhrone funkcije se obustavljaju na svakom await.

Await utiče na izraze. Ako je izraz promisa, async-funkcija se obustavlja do izvršenja promisa. Ako izraz nije promisa, konvertuje se u promisa putem Promise.resolve, a zatim se završava.

// utility function to cause delay
// and get random value
 
const delayAndGetRandom = (ms) => {
  return new Promise(resolve => setTimeout(
    () => {
      const val = Math.trunc(Math.random() * 100);
      resolve(val);
    }, ms
  ));
};
 
async function fn() {
  const a = await 9;
  const b = await delayAndGetRandom(1000);
  const c = await 5;
  await delayAndGetRandom(1000);
 
  return a + b * c;
}
 
// Execute fn
fn().then(console.log);

Evo opisa kako fn-funkcija funkcioniše.

  • Nakon njenog poziva, prva linija se konvertuje iz const a = await 9; u const a = await Promise.resolve(9);.
  • Nakon korišćenja Await, izvršenje funkcije se obustavlja dok a ne dobije svoju vrijednost (u ovoj situaciji to je 9).
  • delayAndGetRandom(1000) obustavlja izvršenje fn-funkcije dok se ne završi sama (nakon 1 sekunde). To zapravo zaustavlja fn-funkciju na 1 sekundu.
  • delayAndGetRandom(1000) vraća slučajnu vrijednost preko resolve, koja se zatim dodeljuje varijabli b.
  • A slučaj sa varijablom c je analogan slučaju sa varijablom a. Nakon toga sve se zaustavlja na sekundu, ali sada delayAndGetRandom(1000) ne vraća ništa jer to nije potrebno.
  • Na kraju, vrijednosti se izračunavaju prema formuli a + b * c. Rezultat se omotava u promisa pomoću Promise.resolve i vraća funkcijom.

Ove pauze mogu podsjećati na generatore u ES6, ali to ima svoje razloge.

Rješavamo zadatak

Sada ćemo razmotriti rešenje zadatka koji je prethodno naznačen.

U funkciji finishMyTask koristi se Await za čekanje rezultata operacija poput queryDatabase, sendEmail, logTaskInFile i drugih. Kada se ovo rešenje uporedi sa onim koje koristi promsi, očigledna je sličnost. Ipak, verzija sa Async/Await značajno pojednostavljuje sve sintaktičke komplikacije. U ovom slučaju nema velikog broja kolbeka i lanaca poput .then/.catch.

Evo rešenja sa ispisom brojeva, ovde postoje dve varijante.

const wait = (i, ms) => new Promise(resolve => setTimeout(() => resolve(i), ms));
 
// Implementation One (Using for-loop)
const printNumbers = () => new Promise((resolve) => {
  let pr = Promise.resolve(0);
  for (let i = 1; i <= 10; i += 1) {
    pr = pr.then((val) => {
      console.log(val);
      return wait(i, Math.random() * 1000);
    });
  }
  resolve(pr);
});
 
// Implementation Two (Using Recursion)
 
const printNumbersRecursive = () => {
  return Promise.resolve(0).then(function processNextPromise(i) {
 
    if (i === 10) {
      return undefined;
    }
 
    return wait(i, Math.random() * 1000).then((val) => {
      console.log(val);
      return processNextPromise(i + 1);
    });
  });
};

A ovo je rešenje sa korišćenjem async funkcija.

async function printNumbersUsingAsync() {
  for (let i = 0; i < 10; i++) {
    await wait(i, Math.random() * 1000);
    console.log(i);
  }
}

Obrada grešaka

Neobrađene greške se omotavaju u rejected promisi. Ipak, u async funkcijama moguće je koristiti konstrukciju try/catch kako bi se izvršila sinhronizovana obrada grešaka.

async function canRejectOrReturn() {
  // čekaj jednu sekundu
  await new Promise(res => setTimeout(res, 1000));

  // Odbij sa ~50% verovatnoće
  if (Math.random() > 0.5) {
    throw new Error('Žao mi je, broj je prevelik.')
  }

  return 'savršeni broj';
}

canRejectOrReturn() je asinhrona funkcija koja se ili uspešno izvršava ("savršeni broj"), ili neuspešno završava sa greškom ("Žao mi je, broj je prevelik").

async function foo() {
  try {
    await canRejectOrReturn();
  } catch (e) {
    return 'greška uhvaćena';
  }
}

Pošto se u gornjem primeru očekuje izvršenje canRejectOrReturn, njegovo neuspešno završavanje će pokrenuti catch blok. Kao rezultat, funkcija foo će se završiti ili sa undefined (kada try blok ne vraća ništa), ili sa greška uhvaćena. Tako da ova funkcija neće imati neuspešno završavanje, jer će try/catch obraditi samu funkciju foo.

Evo još jednog primera:

async function foo() {
  try {
    return canRejectOrReturn();
  } catch (e) {
    return 'greška uhvaćena';
  }
}

Važno je napomenuti da se u primeru iz foo vraća canRejectOrReturn. Foo u ovom slučaju se završava ili sa savršenim brojem ili se vraća greška Error ("Žao mi je, broj je prevelik"). Catch blok nikada neće biti izvršen.

Problem je u tome što foo vraća promisu koju je prosledio canRejectOrReturn. Tako da rešenje funkcije foo postaje rešenje za canRejectOrReturn. U tom slučaju kod će se sastojati od samo dve linije:

try {
    const promise = canRejectOrReturn();
    return promise;
}

A šta će se desiti ako se zajedno koriste await i return:

async function foo() {
  try {
    return await canRejectOrReturn();
  } catch (e) {
    return 'greška uhvaćena';
  }
}

U gornjem kodu foo će se uspješno završiti i sa savršenim brojem i sa uhvaćenom greškom. Ovdje neće biti odbijanja. Međutim, foo će se završiti sa canRejectOrReturn, a ne sa undefined. Potvrdimo to tako da uklonimo redak return await canRejectOrReturn():

try {
    const value = await canRejectOrReturn();
    return value;
}
// …

Česte greške i zamke

U nekim slučajevima korištenje Async/Await može dovesti do grešaka.

Zaboravljeni await

Ovo se često događa — ispred promise-a se zaboravi ključna riječ await:

async function foo() {
  try {
    canRejectOrReturn();
  } catch (e) {
    return 'uhvaćena';
  }
}

U kodu, kao što se vidi, nema ni await ni return. Stoga foo uvijek završava sa undefined bez kašnjenja od 1 sekunde. Međutim, promise će se izvršiti. Ako dođe do greške ili odbijanja, u tom slučaju će biti pozvan UnhandledPromiseRejectionWarning.

Async-funkcije u callback-ovima

Async-funkcije se veoma često koriste u .map ili .filter kao callback-ovi. Kao primjer možemo navesti funkciju fetchPublicReposCount(username), koja vraća broj otvorenih repozitorija na GitHub-u. Recimo da imamo tri korisnika čiji su podaci potrebni. Evo koda za ovu zadaću:

const url = 'https://api.github.com/users';

// Pomoćna fn za preuzimanje broja repozitorija
const fetchPublicReposCount = async (username) => {
  const response = await fetch(`${url}/${username}`);
  const json = await response.json();
  return json['public_repos'];
}

Potrebni su nam računi ArfatSalman, octocat, norvig. U ovom slučaju izvršavamo:

const users = [
  'ArfatSalman',
  'octocat',
  'norvig'
];

const counts = users.map(async username => {
  const count = await fetchPublicReposCount(username);
  return count;
});

Vredno je obratiti pažnju na Await u callback-u .map. Ovdje su counts — niz promisea, a .map — anonimni callback za svakog navedenog korisnika.

Prekomjerno sekvencijalno korištenje await

Kao primjer uzmimo ovakav kod:

async function fetchAllCounts(users) {
  const counts = [];
  for (let i = 0; i < users.length; i++) {
    const username = users[i];
    const count = await fetchPublicReposCount(username);
    counts.push(count);
  }
  return counts;
}

Ovdje se u varijablu count stavlja broj repa, zatim se taj broj dodaje u niz counts. Problem koda je u tome što svi sljedeći korisnici čekaju dok podaci prvog korisnika ne dođu sa servera. Tako u jednom trenutku obrađuje se samo jedan korisnik.

Na primjer, ako za obradu jednog korisnika treba oko 300 ms, za sve korisnike to već iznosi sekundu; utrošeno vreme linearno zavisi od broja korisnika. Međutim, pošto dobijanje broja repozitorija ne zavisi jedan od drugog, procese je moguće paralelizovati. Za to je potrebno raditi sa .map i Promise.all:

async function fetchAllCounts(users) {
  const promises = users.map(async username => {
    const count = await fetchPublicReposCount(username);
    return count;
  });
  return Promise.all(promises);
}

Promise.all kao ulaz dobija niz promise-ova koji se vraća kao promise. On se završava ili nakon završetka svih promise-ova u nizu ili pri prvom rejetovanju. Može se desiti da se svi oni ne pokrenu simultano; da bismo omogućili simultano pokretanje, možemo koristiti p-map.

Zaključak

Async funkcije postaju sve važnije za razvoj. A za adaptivnu upotrebu async funkcija trebalo bi iskoristiti Async iteratore. JavaScript programer treba dobro da razume ovo.

Skillbox preporučuje:

Izvor: habr.com

Kupite pouzdan hosting za sajtove uz zaštitu od DDoS, VPS VDS servere 🔥 Kupite pouzdan hosting za sajtove uz zaštitu od DDoS, VPS VDS servere | ProHoster