odoo javascript 扩展功能（二）

Promise 和异步代码
promise解释
想象一下这样的场景：我走到一家快餐店的柜台前，点了一份芝士汉堡。我递给收银员 1.47 美元。通过下订单并付款，我提出了退还价值的请求（芝士汉堡）。我已经开始交易了。
但通常，芝士汉堡对我来说不是立即可用的。收银员递给我一些东西来代替我的芝士汉堡：一张带有订单号的收据。这个订单号是一个 IOU（“我欠你的”）承诺，确保我最终会收到我的芝士汉堡。
所以我保留我的收据和订单号。我知道它代表了我未来的芝士汉堡，所以我再也不用担心它了——除了饿！
在我等待的时候，我可以做其他事情，比如给朋友发短信说：“嘿，你能和我一起吃午饭吗？我要去吃一个芝士汉堡。”
我已经在思考我未来的芝士汉堡了，尽管我还没有拿到它。我的大脑能够做到这一点，因为它将订单号视为芝士汉堡的占位符。占位符本质上使值与时间无关。这是一个未来的价值。
最终，我听到：“订购 113！” 我拿着收据兴高采烈地走回柜台。我把收据递给收银员，然后拿回我的芝士汉堡。
换句话说，一旦我的未来价值准备好，我就用价值承诺交换价值本身。
但还有另一种可能的结果。他们打电话给我的订单号，但当我去取我的芝士汉堡时，收银员遗憾地告诉我，“对不起，我们似乎都没有芝士汉堡了。” 暂时把这种情况的客户挫败感放在一边，我们可以看到未来价值的一个重要特征：它们可以表示成功或失败。
每次我点芝士汉堡时，我都知道我要么最终得到一个芝士汉堡，要么我会得到芝士汉堡短缺的悲惨消息，我必须想办法午餐吃点别的东西。

1、创建新的 Promise
把一个常数变成一个promise
Promise 上有 2 个静态函数，它们基于常量创建已解决(resolve)或已拒绝(reject)的 Promise：

var p = Promise.resolve({blabla: '1'}); // creates a resolved promise
p.then(function (result) {
    console.log(result); // --> {blabla: '1'};
});


var p2 = Promise.reject({error: 'error message'}); // creates a rejected promise
p2.catch(function (reason) {
    console.log(reason); // --> {error: 'error message');
});

注意：
请注意，即使创建的 Promise 已经解决或被拒绝，then或catch处理程序仍将被异步调用。

使用已经存在的异步结构
假设要在一个函数中执行 rpc，并且当它完成时在 this 上设置结果。是this._rpc一个返回Promise.

function callRpc() {
    var self = this;
    return this._rpc(...).then(function (result) {
        self.myValueFromRpc = result;
    });
}

请注意，即使创建的 Promise 已经解决或被拒绝，thenorcatch处理程序仍将被异步调用。

调用基础功能
假如我们要使用“this.close”这个功能，
that takes as parameter a callback that is called when the closing is finished. Now suppose that you are doing that in a method that must send a promise that is resolved when the closing is finished.

1 function waitForClose() {
2     var self = this;
3     return new Promise (function(resolve, reject) {
4         self.close(resolve);  //成功则关闭
5     });
6 }

第 2 行：我们将 保存this到一个变量中，以便在内部函数中，我们可以访问组件的范围
第 3 行：我们创建并返回一个新的promise。Promise 的构造函数接受一个函数作为参数。这个函数本身有两个我们在这里调用的resolve参数和reject函数。
resolve是一个函数，当被调用时，将 Promise 置于已解决状态。
reject是一个函数，当被调用时，将 Promise 置于拒绝状态。我们这里不使用reject，可以省略。
第 4 行：我们在对象上调用函数 close。它需要一个函数作为参数（回调），并且 resolve 已经是一个函数，所以我们可以直接传递它。为了更清楚，我们可以这样写：

return new Promise (function (resolve) {
    self.close(function () {
        resolve();
    });
});

创建一个promise生成器（依次调用一个promise并等待最后一个promise）

假设您需要遍历一个数组，按顺序执行一个操作，并在最后一个操作完成时解决一个 Promise。

function doStuffOnArray(arr) {
    var done = Promise.resolve();
    arr.forEach(function (item) {
        done = done.then(function () {
            return item.doSomethingAsynchronous();
        });
    });
    return done;
}

这样，您返回的promise实际上是最后一个promise。

创建一个promise，然后在其定义范围之外解决它（反模式）

我们不建议使用它，但有时它很有用。首先仔细考虑替代方案……

…
var resolver, rejecter;
var prom = new Promise(function (resolve, reject){
resolver = resolve;
rejecter = reject;
});
…

resolver(“done”); // will resolve the promise prom with the result “done”
rejecter(“error”); // will reject the promise prom with the reason “error”

2、等待promise

等待一些promise

如果您有多个需要等待的 Promise，您可以将它们转换为单个 Promise，当使用 Promise.all(arrayOfPromises) 解决所有 Promise 时，该 Promise 将被解决。

var prom1 = doSomethingThatReturnsAPromise();
var prom2 = Promise.resolve(true);
var constant = true;

var all = Promise.all([prom1, prom2, constant]); // all is a promise
// results is an array, the individual results correspond to the index of their
// promise as called in Promise.all()
all.then(function (results) {
    var prom1Result = results[0];
    var prom2Result = results[1];
    var constantResult = results[2];
});
return all;

                                                                           中亿丰数字科技有限公司 姜振建