Async în JavaScript: callback, Promise și async/await
Scrii codul care încarcă profilul unui elev, apoi notele și temele, în timp ce pagina rămâne activă. Serverul e simulat cu întârzieri; apasă „Rulează” și urmărește ordinea:
Încarc profilul…
Pagina rămâne activă
Profil: Ana
Note: [ 9, 10 ] teme: 3
„Pagina rămâne activă” apare a doua, deși e ultima linie. JavaScript nu stă după server: pornește cererea, merge mai departe și revine când vine răspunsul.
să citești ordinea reală în care rulează codul asincron
să lucrezi cu Promise, then și catch
să scrii același cod mai clar, cu async și await
să pornești mai multe cereri deodată, cu Promise.all
Pasul 2 din 5
Cine rulează și când
Patru mesaje, numerotate în ordinea în care apar de fapt. Urmărește cele două cozi de așteptare ale motorului JavaScript.
B e cod sincron, rulează primul. Apoi microtask-ul C (promise-ul), abia apoi timerul A, chiar dacă a fost programat primul.
Pasul 3 din 5
De la callback la async/await
Trei feluri de a scrie același lucru, de la cel mai vechi la cel folosit azi, plus o unealtă pentru viteză. Fiecare exemplu rulează la apăsare.
1
Callback: „sună-mă când e gata”
callback.js
functionciteste(nume, gata) {setTimeout(() => gata("conținutul lui " + nume), 300);}citeste("a.txt", text => { console.log(text);citeste("b.txt", text2 => { console.log(text2); });});console.log("aștept…");
Consola
Apasă „Rulează”.
Ce apare în consolă
aștept…
conținutul lui a.txt
conținutul lui b.txt
Un callback e o funcție dată altei funcții, ca s-o cheme mai târziu. Merge, dar fiecare pas care depinde de cel dinainte intră cu un nivel mai la dreapta. După patru-cinci niveli, codul devine greu de citit și erorile greu de prins.
Un Promise e o promisiune pentru un rezultat viitor. Ajunge în una din două stări: rezolvat, cu o valoare, sau respins, cu o eroare. then primește valoarea, catch prinde orice respingere din lanțul de deasupra.
await pune pe pauză doar funcția async în care se află, până vine valoarea; restul paginii merge mai departe. Erorile se prind cu try/catch, ca la codul obișnuit.
Cererile reale către un server arată la fel: const r = await fetch("/api/note");, apoi const date = await r.json();.
4
Promise.all: așteaptă deodată
paralel.js
const asteapta = ms =>newPromise(r => setTimeout(r, ms));const ms = t => Math.round((Date.now() - t) / 100) * 100;let t = Date.now();awaitasteapta(300);awaitasteapta(300);console.log("unul după altul: ~", ms(t), "ms");t = Date.now();awaitPromise.all([asteapta(300), asteapta(300)]);console.log("deodată: ~", ms(t), "ms");
Consola
Apasă „Rulează”.
Ce apare în consolă
unul după altul: ~ 600 ms
deodată: ~ 300 ms
Două await-uri la rând înseamnă două așteptări adunate. Când cererile nu depind una de alta, le pornești pe toate și aștepți cu Promise.all: durează cât cea mai lentă. Dacă una e respinsă, Promise.all e respins.
Capcană: ai uitat await
Fără await, nu primești valoarea, ci obiectul Promise care o conține. Adunarea îl transformă în text:
fara-await.js
asyncfunctionnota() {return9;}const n = nota();console.log(n);console.log(n + 1);
Ce apare în consolă
Promise { 9 }
[object Promise]1
Repară cu const n = await nota();, într-o funcție async sau într-un modul. Dacă vezi [object Promise] sau Promise {…} în consolă, caută await-ul lipsă.
Capcană: await în forEach
forEach nu știe de promise-uri. Pornește toate funcțiile și trece imediat mai departe:
foreach.js
const asteapta = ms =>newPromise(r => setTimeout(r, ms));[1, 2].forEach(async id => {awaitasteapta(100); console.log("salvat", id);});console.log("Toate salvate!");
Consola
Apasă „Rulează”.
Ce apare în consolă
Toate salvate!
salvat 1
salvat 2
Repară cu for (const id of [1, 2]) { await … } pentru pași pe rând, sau cu await Promise.all(lista.map(async id => …)) pentru pași deodată.
Pasul 4 din 5
Verifică-te
Cinci întrebări noi. După fiecare răspuns vezi imediat de ce e așa.
O funcție async rulează sincron până la primul await, deci „în f” apare imediat. La await se oprește, codul de afară afișează „afară”, apoi funcția continuă.
2 din 5 · Alege varianta
Ce întoarce întotdeauna o funcție declarată cu async?
Răspuns: un Promise.
Chiar și async function f() { return 5; } întoarce un Promise rezolvat cu 5. Valoarea o scoți cu await f() sau f().then(…).
Respingerea sare peste then până la primul catch. După ce catch o tratează, lanțul e din nou în regulă, deci ultimul then rulează.
4 din 5 · Alege varianta
Trei cereri independente durează 1, 2 și 3 secunde. Cât durează await Promise.all([…]) cu toate trei?
Răspuns: aproximativ 3 secunde.
Cererile pornesc toate deodată, iar Promise.all așteaptă până se termină și cea mai lentă. Cu trei await-uri la rând ar fi 6 secunde.
5 din 5 · Prezice ieșirea
Ce apare în consolă?
t5.js
for (let i = 1; i <= 3; i++) {setTimeout(() => console.log(i), 0);}console.log("gata");
Răspuns: gata 1 2 3.
Timerele rulează după tot codul sincron, deci „gata” e primul. Cu let, fiecare tură a buclei are propriul i. Cu var ai fi văzut 4 4 4.
Pasul 5 din 5
Ce ai învățat
Ordinea e mereu: cod sincron, apoi promise-urile gata, apoi timerele.
Un Promise e rezolvat cu o valoare sau respins cu o eroare; then și catch le primesc.
await scoate valoarea dintr-un Promise, în funcții async; erorile se prind cu try/catch.
Pentru cereri independente, Promise.all. În bucle cu await, for…of, nu forEach.
Tiparul complet pentru o cerere reală
Așa arată o cerere către un server, cu toate cazurile tratate. fetch respinge doar când nu există rețea; un 404 sau 500 vine ca răspuns normal, de aceea verifici r.ok.
note.js
asyncfunctionincarcaNote(id) {try {const r = awaitfetch(`/api/elevi/${id}/note`);if (!r.ok) {thrownewError(`Server: ${r.status}`); }const note = await r.json();return note; } catch (e) { console.log("Nu am putut încărca:", e.message);return []; }}