Promise.resolve vs new Promise (resolver)

Estoy usando bluebird y veo dos formas de resolver funciones sincrónicas en una Promise, pero no entiendo las diferencias entre ambas formas. Parece que el stacktrace es un poco diferente, por lo que no son solo un alias, ¿verdad?

Entonces, ¿cuál es la forma preferida?

Camino A

function someFunction(someObject) {
  return new Promise(function(resolve) {
    someObject.resolved = true;
    resolve(someObject);
  });
}

Camino B

function someFunction(someObject) {
  someObject.resolved = true;
  return Promise.resolve(someObject);
}

Al contrario de ambas respuestas en los comentarios, hay una diferencia.

Mientras

Promise.resolve(x);

es básicamente lo mismo que

new Promise(function(r){ r(x); });

hay una sutileza.

Las funciones de devolución de promesas generalmente deben tener la garantía de que no deben lanzar de forma síncrona, ya que pueden lanzar de forma asincrónica. Para evitar resultados inesperados y condiciones de carrera, los lanzamientos generalmente se convierten en rechazos devueltos.

Con esto en mente, cuando se creó la especificación, el constructor de la promesa es seguro.

¿Y si someObjectes undefined?

• Way A devuelve una promesa rechazada.
• Way B lanza sincrónicamente.

Bluebird vio esto y Petka agregó Promise.methodpara abordar este problema para que pueda seguir usando valores de retorno. Entonces, la forma correcta y más fácil de escribir esto en Bluebird es en realidad ninguna de las dos, es:

var someFunction = Promise.method(function someFunction(someObject){
    someObject.resolved = true;
    return someObject;
});

Promise.method convertirá los lanzamientos en rechazos y los retornos a resoluciones por ti. Es la forma más segura de hacer esto y asimila thenables a través de valores de retorno, por lo que funcionaría incluso si someObjectde hecho es una promesa.

En general, Promise.resolvese utiliza para convertir objetos y promesas extranjeras (thenables) en promesas. Ese es su caso de uso.

Hay otra diferencia que no se menciona en las respuestas o comentarios anteriores:

Si someObjectes un Promise, new Promise(resolve)costaría dos tick adicionales.

Compare dos fragmentos de código siguientes:

const p = new Promise(resovle => setTimeout(resovle));

new Promise(resolve => resolve(p)).then(() => {
  console.log("tick 3");
});

p.then(() => {
  console.log("tick 1");
}).then(() => {
  console.log("tick 2");
});

const p = new Promise(resovle => setTimeout(resovle));

Promise.resolve(p).then(() => {
  console.log("tick 3");
});

p.then(() => {
  console.log("tick 1");
}).then(() => {
  console.log("tick 2");
});

El segundo fragmento imprimiría "tick 3" en primer lugar. ¿Por qué?

• Si el valor es una promesa, Promise.resolve(value)devolvería el valor exactamente. Promise.resolve(value) === valuesería cierto. ver MDN

• Pero new Promise(resolve => resolve(value))devolvería una nueva promesa que se ha cerrado para seguir la valuepromesa. Se necesita una marca adicional para hacer el "bloqueo".

  // something like:
  addToMicroTaskQueue(() => {
    p.then(() => {
      /* resolve newly promise */
    })
      // all subsequent .then on newly promise go on from here
      .then(() => {
        console.log("tick 3");
      });
  });

  La tick 1 .thenllamada se ejecutaría primero.

Referencias:

• http://exploringjs.com/es6/ch_promises.html#sec_demo-promise