Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / JavaScript

Funkce resolve a reject v executoru Promise

Konstruktor `Promise` předá executoru dvě funkce. První volání jedné z nich závazně určí výsledek, ale příslib může ještě zůstat v čekajícím stavu.

Verze: ECMAScript 2024 and the current web platform; runtime support varies

Syntaxe

new Promise((resolve, reject) => { /* Call resolve(value) or reject(reason). */ });

new Promise(executor) vyžaduje funkci a zavolá ji synchronně s argumenty resolve a reject v tomto pořadí. Jde o obvyklé názvy parametrů; každá dvojice funkcí patří k jednomu nově vytvořenému příslibu. Obě funkce vracejí undefined a lze je uchovat pro pozdější volání, například ve zpětném volání. Naproti tomu statické metody Promise.resolve() a Promise.reject() vracejí přísliby.

resolve(value) příslib ihned splní danou hodnotou, pokud je primitivní. Předání příslibu jeho vlastní funkci resolve způsobí odmítnutí s TypeError. U každého jiného objektu JavaScript synchronně přečte vlastnost then. Pokud načtená hodnota není volatelná, příslib se ihned splní samotným objektem, i když je tímto objektem jiný příslib. Pokud je načtená hodnota volatelná, jde o thenable: JavaScript zavolá then až později. Příslib převezme výsledek tohoto objektu a může zůstat v čekajícím stavu. K odmítnutí vede také výjimka při čtení then nebo při jeho volání, pokud ještě nebyla zavolána žádná z předaných funkcí zpětného volání.

reject(reason) příslib ihned odmítne s uvedeným důvodem a nepřebírá výsledek důvodu, ani když je jím příslib. Důvodem může být libovolná hodnota, ale objekt Error bývá užitečnější. Při vynechání argumentu se použije undefined. Počítá se jen první volání jedné z dvojice funkcí, i když příslib stále čeká. Výsledek je závazně určen (resolved), ale příslib je uzavřený (settled) až po splnění nebo odmítnutí. Obslužné funkce zaregistrované pomocí then() a catch() se spouštějí asynchronně.

Konstruktor ignoruje návratovou hodnotu executoru. Výjimka, která se z executoru synchronně šíří ven, příslib odmítne jen tehdy, pokud ještě nebyla zavolána žádná z obou funkcí. Pokud se žádná nezavolá a executor nevyvolá výjimku, příslib zůstane čekat. Nepoužívejte executor async: konstruktor ignoruje příslib, který executor vrací, takže jeho odmítnutí neodmítne vnější příslib.

Příklady

{
  let finish;
  const inner = new Promise((resolve) => {
    finish = resolve;
  });

  const outer = new Promise((resolve, reject) => {
    console.log("executor");
    resolve(inner);
    reject(new Error("ignored"));
  });

  console.log("after constructor");
  outer.then((value) => {
    console.log(`fulfilled: ${value}`);
    return new Promise((resolve, reject) => {
      reject(new Error("failed"));
    });
  }).catch((reason) => {
    console.log(`rejected: ${reason.message}`);
  });
  finish(42);
}

Výsledek

executor
after constructor
fulfilled: 42
rejected: failed

`executor` se vypíše před `after constructor`, protože executor běží synchronně. `resolve(inner)` závazně určí výsledek `outer`, zatímco `inner` stále čeká, takže `reject(new Error("ignored"))` nemá žádný účinek. `finish(42)` splní `inner`; obslužná funkce vypíše `fulfilled: 42` a `catch()` následně zpracuje odmítnutí jiného příslibu se zprávou `failed`.

Související lekce

  • JavaScript · Lekce 14 · Středně pokročilá · Verze: 3
  • JavaScript · Lekce 15 · Středně pokročilá · Verze: 3

Zdroje