Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

Funzioni resolve e reject dell’esecutore di Promise

Il costruttore `Promise` passa due funzioni all’esecutore. La prima chiamata a una delle due fissa l’esito della promessa, che però può rimanere in attesa.

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

Sintassi

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

new Promise(executor) richiede una funzione e la chiama in modo sincrono, passando prima resolve e poi reject. Sono nomi convenzionali per i parametri; ogni coppia è legata a una singola promessa appena creata. Entrambe le funzioni restituiscono undefined e si possono conservare per chiamarle in seguito, per esempio da una callback. I metodi statici Promise.resolve() e Promise.reject(), invece, restituiscono promesse.

resolve(value) adempie immediatamente la promessa con il valore se questo è primitivo. Passare la promessa al proprio resolve la rifiuta con un TypeError. Per qualsiasi altro oggetto, JavaScript legge la proprietà then in modo sincrono. Se il valore letto non è invocabile, la promessa viene adempiuta immediatamente con l’oggetto stesso, anche se si tratta di un’altra promessa. Se il valore letto è invocabile, l’oggetto è un thenable: JavaScript invoca then in seguito. La promessa adotta l’esito del thenable e può rimanere in attesa. Anche un’eccezione durante la lettura di then, o durante la sua chiamata prima che sia stata invocata una delle callback che ha ricevuto, causa il rifiuto.

reject(reason) rifiuta immediatamente la promessa con il motivo indicato, senza adottarne l’esito nemmeno se il motivo è a sua volta una promessa. È ammesso qualsiasi valore, ma di solito un oggetto Error è più utile. Se si omette l’argomento, si usa undefined. Conta solo la prima chiamata a una delle due funzioni, anche se la promessa è ancora in attesa. L’esito è fissato (resolved), ma la promessa è conclusa (settled) solo quando è adempiuta o rifiutata. I gestori registrati con then() e catch() vengono eseguiti in modo asincrono.

Il costruttore ignora il valore restituito dall’esecutore. Un’eccezione che esce dall’esecutore in modo sincrono rifiuta la promessa solo se non è ancora stata chiamata nessuna delle due funzioni. Se nessuna viene mai chiamata e l’esecutore non lancia eccezioni, la promessa rimane in attesa. Evita un esecutore async: il costruttore ignora la promessa che restituisce, quindi il rifiuto di quest’ultima non rifiuta la promessa esterna.

Esempi

{
  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);
}

Risultato

executor
after constructor
fulfilled: 42
rejected: failed

`executor` compare prima di `after constructor` perché l’esecutore lavora in modo sincrono. `resolve(inner)` fissa l’esito di `outer` mentre `inner` è ancora in attesa, quindi `reject(new Error("ignored"))` non ha effetto. `finish(42)` adempie `inner`; il gestore stampa `fulfilled: 42`, poi `catch()` gestisce il rifiuto di un’altra promessa con il messaggio `failed`.

Lezioni correlate

  • JavaScript · Lezione 14 · Intermedio · Versione: 3
  • JavaScript · Lezione 15 · Intermedio · Versione: 3

Fonti