JavaScript ígéretek magyarázata

Mi az ígéret a JavaScript-ben?

A JavaScript egyszálú, ami azt jelenti, hogy a szkript két bitje nem futhat egyszerre; egymás után kell futniuk. Az ígéret olyan objektum, amely egy aszinkron művelet esetleges befejezését (vagy meghibásodását) és annak eredő értékét képviseli.

var promise = new Promise(function(resolve, reject) { // do thing, then… if (/* everything worked */) { resolve("See, it worked!"); } else { reject(Error("It broke")); } });

Ezen államok egyikében létezik ígéret

  • Függőben: kezdeti állapot, sem teljesítve, sem elutasítva.
  • Teljesítve: a művelet sikeresen befejeződött
  • Elutasítva: a művelet nem sikerült.

Az Ígéret objektum egy olyan érték proxyjaként működik, amely nem feltétlenül ismert az ígéret létrehozásakor. Lehetővé teszi a kezelők társítását egy aszinkron művelet esetleges sikerértékével vagy sikertelenségének okával.

Ez lehetővé teszi, hogy az aszinkron módszerek olyan értékeket adjanak vissza, mint a szinkron módszerek: a végső érték azonnali visszaadása helyett az aszinkron módszer ígéretet ad arra, hogy az értéket a jövőben valamikor megadja.

Az „Akkor” (ígéretlánc) használata

Több aszinkron hívás fogadásához és egymás utáni szinkronizálásához használhatja az ígéretláncolást. Ez lehetővé teszi az első ígéret értékének felhasználását a későbbi későbbi visszahívások során.

Promise.resolve('some') .then(function(string) { // <-- This will happen after the above Promise resolves (returning the value 'some') return new Promise(function(resolve, reject) { setTimeout(function() { string += 'thing'; resolve(string); }, 1); }); }) .then(function(string) { // <-- This will happen after the above .then's new Promise resolves console.log(string); // <-- Logs 'something' to the console });

Promise API

Az Ígéret osztályban 4 statikus módszer létezik:

  • Ígéret.feloldani
  • Ígéret.tagadás
  • Ígéret.minden
  • Ígéret.verseny

Az ígéretek összekapcsolhatók

Amikor ígéreteket ír egy adott probléma megoldására, akkor összekapcsolhatja őket a logika kialakításával.

var add = function(x, y) { return new Promise((resolve,reject) => { var sum = x + y; if (sum) { resolve(sum); } else { reject(Error("Could not add the two values!")); } }); }; var subtract = function(x, y) { return new Promise((resolve, reject) => { var sum = x - y; if (sum) { resolve(sum); } else { reject(Error("Could not subtract the two values!")); } }); }; // Starting promise chain add(2,2) .then((added) => { // added = 4 return subtract(added, 3); }) .then((subtracted) => { // subtracted = 1 return add(subtracted, 5); }) .then((added) => { // added = 6 return added * 2; }) .then((result) => { // result = 12 console.log("My result is ", result); }) .catch((err) => { // If any part of the chain is rejected, print the error message. console.log(err); });

Ez hasznos a funkcionális programozási paradigma követéséhez . Az adatok manipulálására szolgáló funkciók létrehozásával összekapcsolhatja őket a végeredmény megszerzéséhez. Ha bármikor a lánc funkciók érték elutasította a lánc átugorja a legközelebbi catch()felvezető.

További információ a funkcionális programozásról: Funkcionális programozás

Funkciógenerátorok

A legutóbbi kiadásokban a JavaScript több lehetőséget is bemutatott az ígéretek natív kezelésére. Az egyik ilyen módszer a függvénygenerátor. A funkciógenerátorok „szüneteltethető” funkciók. Az ígéretekkel együtt használva a generátorok sokkal könnyebben olvashatják és „szinkronnak” tűnnek.

const myFirstGenerator = function* () { const one = yield 1; const two = yield 2; const three = yield 3; return 'Finished!'; } const gen = myFirstGenerator();

Itt van az első generátorunk, amelyet a function*szintaxis alapján láthat . Az genáltalunk deklarált változó nem fog futni myFirstGenerator, ehelyett „ez a generátor használatra kész”.

console.log(gen.next()); // Returns { value: 1, done: false }

Amikor lefuttatjuk gen.next(), a generátor szüneteltetve lesz, és tovább működik. Mivel ez az első alkalom, hogy felhívtuk gen.next(), fut, yield 1és szünetel, amíg gen.next()újra nem hívunk . Amikor yield 1hívják, visszaadja nekünk azt, valueamit kapott, és függetlenül attól, hogy a generátor van-e done.

console.log(gen.next()); // Returns { value: 2, done: false } console.log(gen.next()); // Returns { value: 3, done: false } console.log(gen.next()); // Returns { value: 'Finished!', done: true } console.log(gen.next()); // Will throw an error

Ahogy folyamatosan hívjuk, folytatja gen.next()a következőt, yieldés minden alkalommal szünetet tart. Amint nem marad több yield, folytatja a generátor többi részének futtatását, amely ebben az esetben egyszerűen visszatér 'Finished!'. Ha gen.next()újra felhívja , akkor hiba lép fel, amikor a generátor elkészült.

Most képzeljük el, ha yieldebben a példában mindegyik a Promise, akkor maga a kód rendkívül szinkronnak tűnik.

A Promise.all (iterable) nagyon hasznos, ha több kérelmet küldünk különböző forrásokhoz

Az Promise.all (iterálható) módszer egyetlen ígéretet ad vissza, amely akkor oldódik fel, amikor az iterálható argumentum összes ígérete megoldódott, vagy ha az iterálható argumentum nem tartalmaz ígéreteket. Az első elutasító ígérettel elutasítja.

var promise1 = Promise.resolve(catSource); var promise2 = Promise.resolve(dogSource); var promise3 = Promise.resolve(cowSource); Promise.all([promise1, promise2, promise3]).then(function(values) { console.log(values); }); // expected output: Array ["catData", "dogData", "cowData"]

További információ az ígéretekről:

  • Hogyan működnek valójában a JavaScript ígéretek
  • Az ígéretek megvalósítása a JavaScript-ben
  • Az ígéretek felhasználása a JavaScript-ben
  • JavsScript ígéret megírása