Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / JavaScript

Funciones resolve y reject del ejecutor de Promise

El constructor `Promise` entrega dos funciones a su ejecutor. La primera llamada a cualquiera de ellas fija el resultado de la promesa, sin que necesariamente deje de estar pendiente de inmediato.

Versión: ECMAScript 2024 and the current web platform; runtime support varies

Sintaxis

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

new Promise(executor) requiere una función y la llama de forma síncrona, primero con resolve y después con reject. Estos nombres de parámetros son convencionales; cada par pertenece a una única promesa recién creada. Ambas funciones devuelven undefined y se pueden guardar para llamarlas más tarde, por ejemplo desde una función de retrollamada. En cambio, los métodos estáticos Promise.resolve() y Promise.reject() devuelven promesas.

resolve(value) cumple la promesa inmediatamente con el valor si este es primitivo. Pasar la promesa a su propio resolve la rechaza con un TypeError. Para cualquier otro objeto, JavaScript lee la propiedad then de forma síncrona. Si el valor leído no es invocable, la promesa se cumple de inmediato con el objeto mismo, aunque este sea otra promesa. Si el valor leído es invocable, el objeto es un thenable: JavaScript llama a then más tarde. La promesa adopta el resultado del thenable y puede seguir pendiente. También se rechaza si se lanza una excepción al leer then, o al llamarlo antes de que se haya invocado alguna de las funciones de retrollamada que recibe.

reject(reason) rechaza inmediatamente la promesa con el motivo dado, sin adoptar su resultado aunque ese motivo sea una promesa. Se admite cualquier valor, pero un objeto Error suele ser más útil. Si se omite el argumento, se usa undefined. Solo cuenta la primera llamada a una de las dos funciones, aunque la promesa siga pendiente. Su resultado queda fijado (resolved), pero solo alcanza su estado final (settled) cuando se cumple o se rechaza. Los manejadores registrados con then() y catch() se ejecutan de forma asíncrona.

El constructor ignora el valor que devuelve el ejecutor. Si una excepción sale del ejecutor de forma síncrona, solo rechaza la promesa si aún no se ha llamado a ninguna de las dos funciones. Si no se llama nunca a ninguna y el ejecutor no lanza una excepción, la promesa sigue pendiente. Evita un ejecutor async: el constructor ignora la promesa que devuelve, así que su rechazo no rechaza la promesa exterior.

Ejemplos

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

Resultado

executor
after constructor
fulfilled: 42
rejected: failed

`executor` aparece antes que `after constructor` porque el ejecutor se ejecuta de forma síncrona. `resolve(inner)` fija el resultado de `outer` mientras `inner` sigue pendiente, por lo que `reject(new Error("ignored"))` no tiene efecto. `finish(42)` cumple `inner`; el manejador muestra `fulfilled: 42` y, después, `catch()` procesa el rechazo de otra promesa con el mensaje `failed`.

Lecciones relacionadas

  • JavaScript · Lección 14 · Intermedio · Versión: 3
  • JavaScript · Lección 15 · Intermedio · Versión: 3

Fuentes