javascript - then - Creando una promesa(ES6) sin comenzar a resolverla

promise typescript

Question

Usando las promesas de ES6, ¿cómo creo una promesa sin definir la lógica para resolverla? Aquí hay un ejemplo básico (algo de TypeScript):

var promises = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return promises[key];
  }
  var promise = new Promise(resolve => {
    // But I don''t want to try resolving anything here :(
  });

  promises[key] = promise;
  return promise;
}

function resolveWith(key: string, value: any): void {
  promises[key].resolve(value); // Not valid :(
}

Se hace fácilmente con otras bibliotecas de promesas. JQuery es, por ejemplo:

var deferreds = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return deferreds[key].promise();
  }
  var def = $.Deferred();    
  deferreds[key] = def;
  return def.promise();
}

function resolveWith(key: string, value: any): void {
  deferreds[key].resolve(value);
}

La única forma en que puedo ver esto es almacenar la función de resolución en algún lugar dentro del ejecutor de la promesa, pero eso parece desordenado, y no estoy seguro de que esté definido exactamente cuando se ejecuta esta función. ¿Siempre se ejecuta inmediatamente en la construcción?

Gracias.

Answer 1

¡Buena pregunta!

El resolvedor pasado al constructor de la promesa se ejecuta de forma intencionada sincrónica para admitir este caso de uso:

var deferreds = [];
var p = new Promise(function(resolve, reject){
    deferreds.push({resolve: resolve, reject: reject});
});

Luego, en algún momento posterior en el tiempo:

 deferreds[0].resolve("Hello"); // resolve the promise with "Hello"

La razón por la cual el constructor de la promesa se da es que:

• Típicamente (pero no siempre) la lógica de resolución está ligada a la creación.
• El constructor de la promesa es seguro y convierte las excepciones en rechazos.

A veces no encaja y para eso el resolver se ejecuta sincrónicamente. Aquí hay una lectura relacionada sobre el tema .

Answer 2

¿Qué tal un enfoque más integral?

Podría escribir un Constructor que devuelva una nueva Promesa decorada con .resolve() y .reject() .

Probablemente elegirías Deferred nombre al constructor Deferred , un término con mucha precedencia en [la historia de] las promesas javascript.

function Deferred(fn) {
    fn = fn || function(){};

    var resolve_, reject_;

    var promise = new Promise(function(resolve, reject) {
        resolve_ = resolve;
        reject_ = reject;
        fn(resolve, reject);
    });

    promise.resolve = function(val) {
        (val === undefined) ? resolve_() : resolve_(val);
        return promise;//for chainability
    }
    promise.reject = function(reason) {
        (reason === undefined) ? reject_() : reject_(reason);
        return promise;//for chainability
    }
    promise.promise = function() {
        return promise.then(); //to derive an undecorated promise (expensive but simple).
    }

    return promise;
}

Al devolver una promsie decorada en lugar de un objeto simple, todos los métodos / propiedades naturales de la promesa permanecen disponibles, además de las decoraciones.

Además, al manejar fn , el patrón revelador permanece disponible, si necesita / elige usarlo en un Deferred.

DEMO

Ahora, con la utilidad Deferred() en su lugar, su código es prácticamente idéntico al ejemplo de jQuery.

var deferreds = {};
function waitFor(key: string): Promise<any> {
  if (key in promises) {
    return deferreds[key].promise();
  }
  var def = Deferred();    
  deferreds[key] = def;
  return def.promise();
}

Answer 3

Quiero agregar mis 2 centavos aquí. Teniendo en cuenta exactamente la pregunta " Creando una promesa es6 sin comenzar a resolverla ", la resolví creando una función envoltorio y llamando a la función envoltorio en su lugar. Código:

Digamos que tenemos una función f que devuelve una Promesa

/** @return Promise<any> */
function f(args) {
   return new Promise(....)
}

// calling f()
f(''hello'', 42).then((response) => { ... })

Ahora, quiero preparar una llamada a f(''hello'', 42) sin resolverla en realidad:

const task = () => f(''hello'', 42) // not calling it actually

// later
task().then((response) => { ... })

Espero que esto ayude a alguien :)

Promise.all() referencia a Promise.all() como se solicita en los comentarios (y respondida por @Joe Frambach), si quiero preparar una llamada a f1(''super'') y f2(''rainbow'') - 2 funciones que devuelven promesas -

function f1(args) {
  return new Promise( ... )
}

function f2(args) {
  return new Promise( ... )
}

const tasks = [
  () => f1(''super''),
  () => f2(''rainbow'')
]

// later
Promise.all(tasks)
  .then(() => { ... })