我想使用promises,但我有一个回调API,格式如下:
window.onload; // set to callback
...
window.onload = function() {
};
function request(onChangeHandler) {
...
}
request(function() {
// change happened
...
});
function getStuff(dat, callback) {
...
}
getStuff("dataParam", function(err, data) {
...
})
API;
API.one(function(err, data) {
API.two(function(err, data2) {
API.three(function(err, data3) {
...
});
});
});
I am looking for a way to create deferred object which will be resolved outside the current scope. I like deferred objects and as I see Promise.defer() in Chrome 38 returns the deferred object.
但最新的Firefox 34 Promise.defer在Safari 8.0中也未定义.
所以我Promise.defer现在无法到处使用.未来地位怎么样？它会在其他浏览器中实现还是会被弃用？
使用Promises时,为什么不能在代码库的其他地方触发resolve和reject定义？
我不明白为什么resolve和reject逻辑应该在声明promise的地方进行本地化.这是一种疏忽,还是强制要求executor参数？
我相信执行程序函数应该是可选的,并且它的存在应该确定promise是否封装了解决方案.如果没有这样的要求,承诺将更加可扩展,因为您不必立即启动异步.承诺也应该是可以重置的.它是一个1开关,1或0,resolve()或reject().有迹象表明,可附接的并行和串行结果众多:promise.then(parallel1)和promise.then(parallel2)并且也promise.then(seq1).then(seq2)但参考特权玩家无法解析/拒绝到交换机
您可以在以后构建结果树,但不能改变它们,也不能改变根(输入触发器)
老实说,连续结果的树也应该是可编辑的.假设你想要拼出一个步骤并在你宣布许多承诺链之后做其他事情.重建承诺和每个顺序功能是没有意义的,特别是因为你甚至不能拒绝或毁掉承诺......
考虑以下两个例子......
function test1() {
return new Promise(function () {
return 123;
});
}
test1()
.then(function (data) {
console.log("DATA:", data);
return 456;
})
.then(function (value) {
console.log("VALUE:", value);
});
它什么也没输出.
function test2() {
return new Promise(function (resolve, reject) {
resolve(123);
});
}
test2()
.then(function (data) {
console.log("DATA:", data);
return 456;
})
.then(function (value) {
console.log("VALUE:", value);
});
它输出:
DATA: 123
VALUE: 456
promise构造函数不能简单地解析TEST 1中的返回值有什么缺点或规范矛盾？
为什么它必须与TEST 2中的结果不同？
我试图理解构造的promise对象如何根据promise规范与可能的对象不同.
根据MDN：
执行器函数由Promise实现立即执行，传递resolve和reject函数
做出这个决定的真正原因是什么？为什么承诺不偷懒？
我想我终于在大多数情况下都围绕着javascript/ES6 Promises.这并不容易!但是有些东西让我对这个设计感到困惑.
为什么Promise构造函数会进行回调？鉴于立即调用回调,调用者不能只执行该代码,从而避免一个不必要的心灵弯曲"不要打电话给我,我会打电话给你"？
以下是我所认为的Promise使用的原型示例,复制自Jake Archibald的Javascript Promises教程http://www.html5rocks.com/en/tutorials/es6/promises/#toc-promisifying-xmlhttprequest,并删除了注释.
它是XMLHttpRequest GET请求的基于Promise的包装器:
function get(url) {
return new Promise(function(resolve, reject) {
var req = new XMLHttpRequest();
req.open('GET', url);
req.onload = function() {
if (req.status == 200) {
resolve(req.response);
}
else {
reject(Error(req.statusText));
}
};
req.onerror = function() {
reject(Error("Network Error"));
};
req.send();
});
}
对我来说,上面的代码将更容易理解,如果它被重写如下,使用我正在想象的一种非常不同的承诺,具有无参数构造函数和解析/拒绝方法:
function get(url) {
var promise = new MyEasierToUnderstandPromise();
var req = new XMLHttpRequest();
req.open('GET', url);
req.onload = function() {
if (req.status == 200) {
promise.resolve(req.response);
}
else { …在Angular中,以下片段似乎是等效的:
let deferred = $q.defer();
if(whatever) {
deferred.resolve('something');
}
else {
deferred.reject('nah');
}
return deferred.promise;
和
return $q((resolve,reject) => {
if(whatever) {
resolve('something');
}
else {
reject('nah');
}
});
我的问题:如果它们不相同,它们有何不同？如果它们是等价的,是否有令人信服的理由选择一个而不是另一个？
我一直试图理解为什么下面的代码没有抓住它throw.如果async从new Promise(async (resolve, ...部件中删除关键字,那么它可以正常工作,因此它与Promise执行程序是异步函数的事实有关.
(async function() {
try {
await fn();
} catch(e) {
console.log("CAUGHT fn error -->",e)
}
})();
function fn() {
return new Promise(async (resolve, reject) => {
// ...
throw new Error("<<fn error>>");
// ...
});
}
这里的答案,这里和这里重复一遍"如果你在任何其他异步回调中,你必须使用reject",但是"异步"它们并不是指async函数,所以我认为它们的解释不适用于此(如果他们这样做,我不明白如何).
如果不是throw我们使用reject,上面的代码工作正常.从根本上说,我想明白为什么throw不在这里工作.谢谢!
我有以下代码：
return requestAsync({
method: 'GET',
url: 'https://' + servers[num - 1] + ':8033/version.txt'
}).then().catch()
我尝试在then处理程序中引发错误，但这没有用
如果then处理程序中不满足条件，我想抛出一个catch处理程序处理的错误。我该怎么做？
码：
var P = require('bluebird');
var defer = function () {
var resolve, reject;
var promise = new P(function () {
resolve = arguments[0];
reject = arguments[1];
});
return {
resolve: function () {
resolve.apply(null, arguments);
return promise;
},
reject: function () {
reject.apply(null, arguments);
return promise;
},
promise: promise
};
};
var pool = {maxSockets: Infinity};
var requestAsync = function (options) {
options.pool …如何实现扩展 Promise 的 Deferred 承诺？在需要典型 Promise 的情况下，为类型安全使用扩展 Promise 很重要。
实施后
export class Deferred<T> extends Promise<T> {
public _resolveSelf;
public _rejectSelf;
constructor() {
super(
(resolve, reject) =>
{
this._resolveSelf = resolve
this._rejectSelf = reject
}
)
}
public resolve(val:T) { this._resolveSelf(val) }
public reject(reason:any) { this._rejectSelf(reason) }
}
抛出TypeError: _this is undefined。
在这个 Typescript playground 中，可以看到编译后的 javascript 很有趣。在第 15 行，在声明过程中_this已经分配了它的属性。
Promise 构造函数中错误处理的最佳实践是什么？
Promises 在promise 链中具有传播错误的巨大优势，错误无法逃脱，但是涉及到Promise 构造函数时，您必须手动处理可能出现的错误。
让我举个例子：
new Promise(resolve => {
throw new Error('error in the constructor');
resolve();
});
当上面的代码运行时，承诺永远不会得到解决（或拒绝），所以我无法处理承诺链中的错误。现在一个明显的解决方案是：
new Promise((resolve, reject) => {
try {
throw new Error('error in the constructor');
resolve();
} catch(error) {
reject(error)
}
});
但是在构造函数中一直进行手动错误检查对我来说似乎有点矫枉过正，同时例如在 Promise 的then方法中我不需要这个。
因此，例如以下解决方案执行相同的操作，但没有手动错误处理：
Promise.resolve()
.then(() => {
throw new Error('error in the constructor');
});
所以我的问题是，有没有更好的方法来在 Promise 构造函数中进行错误处理？或者我应该使用最后一个例子，在我看来它更简洁。
promise ×10
javascript ×9
es6-promise ×3
node.js ×3
angularjs ×1
async-await ×1
asynchronous ×1
bluebird ×1
callback ×1
deferred ×1
q ×1
typescript ×1
w3c ×1