我一直在使用 ES6 Promise。
通常，一个 Promise 是这样构造和使用的
new Promise(function(resolve, reject){
if (someCondition){
resolve();
} else {
reject();
}
});
但是为了灵活性，我一直在做类似下面的事情来解决问题。
var outsideResolve;
var outsideReject;
new Promise(function(resolve, reject) {
outsideResolve = resolve;
outsideReject = reject;
});
然后
onClick = function(){
outsideResolve();
}
这工作正常，但有没有更简单的方法来做到这一点？如果不是，这是一个好习惯吗？
简单的：
var promiseResolve, promiseReject;
var promise = new Promise(function(resolve, reject){
promiseResolve = resolve;
promiseReject = reject;
});
promiseResolve();
这里的聚会有点晚了，但另一种方法是使用Deferred对象。您基本上拥有相同数量的样板文件，但如果您想传递它们并可能在它们的定义之外解析，这很方便。
幼稚的实现：
class Deferred {
constructor() {
this.promise = new Promise((resolve, reject)=> {
this.reject = reject
this.resolve = resolve
})
}
}
function asyncAction() {
var dfd = new Deferred()
setTimeout(()=> {
dfd.resolve(42)
}, 500)
return dfd.promise
}
asyncAction().then(result => {
console.log(result) // 42
})
ES5 版本：
function Deferred() {
var self = this;
this.promise = new Promise(function(resolve, reject) {
self.reject = reject
self.resolve = resolve
})
}
function asyncAction() {
var dfd = new Deferred()
setTimeout(function() {
dfd.resolve(42)
}, 500)
return dfd.promise
}
asyncAction().then(function(result) {
console.log(result) // 42
})
不，没有其他方法可以做到这一点 - 我唯一能说的是这个用例不是很常见。就像 Felix 在评论中所说的那样 - 你所做的将始终有效。
值得一提的是，promise 构造函数以这种方式运行的原因是抛出安全——如果在你的代码在 promise 构造函数中运行时发生了你没有预料到的异常，它将变成拒绝，这种形式的抛出安全——将抛出的错误转换为拒绝很重要，有助于维护可预测的代码。
出于这个抛出安全的原因，promise 构造函数被选择而不是 deferreds（这是一种替代的promise构造方式，允许你正在做的事情）——至于最佳实践——我会传递元素并使用promise构造函数代替：
var p = new Promise(function(resolve, reject){
this.onclick = resolve;
}.bind(this));
出于这个原因——无论何时你可以使用 promise 构造函数而不是导出函数——我建议你使用它。当你可以避免两者时 - 避免两者和连锁。
请注意，您永远不应该将 promise 构造函数用于诸如if(condition)，第一个示例可以写为：
var p = Promise[(someCondition)?"resolve":"reject"]();
我喜欢@JonJaques 的回答，但我想更进一步。
如果绑定then和catch随后的Deferred对象，那么它完全实现了PromiseAPI，你可以把它当作Promise，await它与这样的。
⚠️ 编者注：我不推荐这种模式了，因为在写这篇文章的时候，
Promise.prototype.finally还不是一个东西，然后它变成了一个东西……这可能发生在其他方法上，所以我建议你用resolve和reject函数来扩充promise实例反而：function createDeferredPromise() { let resolve let reject const promise = new Promise((thisResolve, thisReject) => { resolve = thisResolve reject = thisReject }) return Object.assign(promise, {resolve, reject}) }去upvote别人的答案。
class DeferredPromise {
constructor() {
this._promise = new Promise((resolve, reject) => {
// assign the resolve and reject functions to `this`
// making them usable on the class instance
this.resolve = resolve;
this.reject = reject;
});
// bind `then` and `catch` to implement the same interface as Promise
this.then = this._promise.then.bind(this._promise);
this.catch = this._promise.catch.bind(this._promise);
this.finally = this._promise.finally.bind(this._promise);
this[Symbol.toStringTag] = 'Promise';
}
}
const deferred = new DeferredPromise();
console.log('waiting 2 seconds...');
setTimeout(() => {
deferred.resolve('whoa!');
}, 2000);
async function someAsyncFunction() {
const value = await deferred;
console.log(value);
}
someAsyncFunction();我在 2015 年为我的框架提出了一个解决方案。我把这种类型的 promise 称为Task
function createPromise(handler){
var resolve, reject;
var promise = new Promise(function(_resolve, _reject){
resolve = _resolve;
reject = _reject;
if(handler) handler(resolve, reject);
})
promise.resolve = resolve;
promise.reject = reject;
return promise;
}
// create
var promise = createPromise()
promise.then(function(data){ alert(data) })
// resolve from outside
promise.resolve(200)