创建（ES6）承诺而不开始解决它

使用ES6承诺，如何在不定义解决承诺的逻辑的情况下创建承诺？这是一个基本示例（某些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 :(
}

使用其他promise库很容易做到。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();
}

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

我能看到的唯一方法是将resolve函数存储在Promise的执行程序中某个地方，但这似乎很麻烦，而且我不确定确切地在运行此函数时定义了它-它总是在构造时立即运行吗？

谢谢。

好问题！

传递给promise构造函数的解析器有意地同步运行以支持此用例：

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

然后，在以后的某个时间点：

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

给出promise构造函数的原因是：

• 通常（但并非总是）解析逻辑与创建绑定在一起。
• promise构造函数是安全抛出的，并将异常转换为拒绝。

有时，它不适合，因此解析器会同步运行。这是有关该主题的相关阅读。

我想在这里加2美分。正好考虑“创建es6 Promise而不开始解决它”的问题，我解决了创建包装器函数并调用包装器函数的问题。码：

假设我们有一个f返回Promise的函数

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

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

现在，我想准备一个呼叫，f('hello', 42)而无需实际解决：

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

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

希望这会帮助某人:)

Promise.all()如果我想准备调用f1('super')＆f2('rainbow')，则按注释中的要求进行引用（并由@Joe Frambach回答），2个返回promise的函数

const f1 = args => new Promise( ... )
const f2 = args => new Promise( ... )

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

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

如何采用更全面的方法？

您可以编写一个构造函数，该构造函数返回以.resolve()和.reject()方法修饰的新Promise 。

您可能会选择命名构造函数Deferred-javascript promises历史中有很多优先级的术语。

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

通过返回经过修饰的promsie而不是简单的对象，除修饰外，所有promise的自然方法/属性仍然可用。

此外，通过处理fn，如果您需要/选择在Deferred上使用它，则显示模式仍然可用。

演示

现在，有了该Deferred()实用程序，您的代码实际上与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();
}

在JavaScript领域，事情正在逐渐好转，但这是情况仍然不必要地复杂的一种情况。这是一个简单的帮助程序，用于公开“解析”和“拒绝”功能：

Promise.unwrapped = () => {
  let resolve, reject, promise = new Promise((_resolve, _reject) => {
    resolve = _resolve, reject = _reject
  })
  promise.resolve = resolve, promise.reject = reject
  return promise
}

// a contrived example

let p = Promise.unwrapped()
p.then(v => alert(v))
p.resolve('test')

显然曾经有一个Promise.defer帮助者，但即使如此，也坚持要求推迟的对象与承诺本身分开……