• 你不知道的JavaScript----promise

    目录

    什么是Promise

    Promise

    Promise 值

    完成事件

    Promise “事件”

    具有 then 方法的鸭子类型

    Promise 信任问题

    调用过早

    调用过晚

    Promise 调度技巧

    回调未调用

    调用次数过少或过多

    未能传递参数 / 环境值

    吞掉错误或异常

    是可信任的 Promise 吗？

    链式流

    Promise API

    Promise 用法

    Promise.all 和 Promise.race 的区别和使用

    Promise - finally

    Promise 局限性

    顺序错误处理

    单一值

    单决议

    惯性

    无法取消的 Promise

    Promise 性能

    什么是Promise

    通过如下场景来阐述：

    我到快餐店的柜台，点了一个芝士汉堡。通过下订单并付款，我已经发出了一个对某个值（芝士汉堡）的请求。我已经启动了一次交易。但是，通常我不能马上就得到这个汉堡。收银员会交给我某个东西来代替汉堡：一张带有订单号的收据。收据就是一个 IOU（I owe you，我欠你的）承诺（promise），保证了最终我会得到我的汉堡。
    所以我得好好保留我的收据，我知道这代表了我未来的汉堡，所以不需要担心， 只是现在我还是很饿！
    在等待的过程中，我还可以做点其他的事情，我脑海中已经在想着未来的芝士汉堡了，尽管现在我还没有拿到手。我的大脑之所以可以这么做，是因为它已经把订单号当作芝士汉堡的占位符了。 从本质上讲，这个占位符使得这个值不再依赖时间。这是一个未来值。
    终于，我听到服务员在喊“订单 113”，然后愉快地拿着收据走到柜台，把收据交给收银 员，换来了我的芝士汉堡。换句话说，一旦我需要的值准备好了，我就用我的承诺值（value-promise）换取这个值本身。
    但是，还可能有另一种结果。他们叫到了我的订单号，但当我过去拿芝士汉堡的时候，收银员满是歉意地告诉我：“不好意思，芝士汉堡卖完了。”除了作为顾客对这种情况感到愤怒之外，我们还可以看到未来值的一个重要特性：它可能成功，也可能失败。

    现在值与将来值——-——————

    不要小瞧 x + y。

    1. var x, y = 2; 
    2. console.log( x + y ); // NaN

    运算 x + y假定了 x和 y 都已经设定。也就是说在这里我们假定了 x 和 y 的值都是已决议的，那么试想如果其中一个值未决议（是未来值）就进行计算，那会怎么样？
    如果有的语句现在完成，而有的语句将来完成，那就会在程序里引起混乱。例如：如果语句 2 依赖于语句 1 的完成，那么就会有两个输出：要么语句 1 马上完成，一切 顺利执行；要么语句 1 还未完成，语句 2 因此也将会失败。
    以x + y为例，如果它们中的任何一个还没有准备好，那我们就等待两者都准备好。一旦可以就马上执行加运算。下面是通过回调的实现：

    1. function add(getX,getY,cb) { 
    2.     var x, y; 
    3.     getX( function(xVal){ 
    4.         x = xVal; 
    5.         // 两个都准备好了？
    6.         if (y != undefined) { 
    7.              cb( x + y ); // 发送和
    8.         } 
    9.     } ); 
    10.     getY( function(yVal){ 
    11.         y = yVal; 
    12.         // 两个都准备好了？
    13.         if (x != undefined) { 
    14.             cb( x + y ); // 发送和
    15.         } 
    16.     } ); 
    17. } 
    18. // fetchX() 和fetchY()是同步或者异步函数
    19. add( fetchX, fetchY, function(sum){ 
    20.     console.log( sum ); // 是不是很容易？
    21. } );

    上面我们把 x 和 y 都当作未来值来处理。在我们不确定某个值是现在值还是将来值的时候，我们就把它当做将来值来处理，这样可以防止很多意外的发生。说得直白些就是，为了统一处理现在和将来，我们把它们都变成了将来，即所有的操作都成了异步的。

    Promise

    Promise 值

    先来看看，通过 Promise 函数表达 x + y 的例子:

    1. function add(xPromise,yPromise) { 
    2.     return Promise.all( [xPromise, yPromise] ) 
    3.     .then( function(values){ 
    4.         return values[0] + values[1]; 
    5.     } ); 
    6. } 
    7. // fetchX()和fetchY()返回相应值的promise
    8. add( fetchX(), fetchY() ) 
    9. .then( function(sum){ 
    10.     console.log( sum );
    11. } );

    这样就简单多了。Promise 的决议结果可能是拒绝而不是完成。拒绝值和完成的 Promise 不一样：

    完成值总是编程给出的，而拒绝值，通常称为拒绝原因，可能是程序逻辑直接设置的，也可能是从运行异常隐式得出的值

    通过 Promise，调用 then(..)实际上可以接受两个函数，第一个用于完成情况，第二个用于拒绝情况：

    1. add( fetchX(), fetchY() ) 
    2. .then( 
    3.     // 完成处理函数
    4.     function(sum) { 
    5.         console.log( sum ); 
    6.     }, 
    7.     // 拒绝处理函数
    8.     function(err) { 
    9.         console.error( err );
    10.     } 
    11. );

    我们清晰的看见，Promise采用了分离式回调。Promise 是一种封装和组合未来值的易于复用的机制。

    注意： 关于 Promise 需要理解的最强大也最重要的一个概念：一旦 Promise 决议，它就永远保持在这个状态，成为了不变值。（一旦改变不能在改变 承诺者模式）

    完成事件

    从另外一个角度看待 Promise 的决议：一种在异步任务中作为两个或更多步骤的流程控制机制，时序上的 this-then-that。
    假定要调用一个函数执行某个任务，这个函数可能立即完成任务，也可能需要一段时间才能完成。我们只需要知道它什么时候结束，这样就可以进行下一个任务。即我们想要通过某种方式在程序完成的时候得到通知。
    侦听某个通知，我们就会想到事件，我们的脑海中可能会出现如下的伪代码：

    1. foo(x) { 
    2.  // 开始做点可能耗时的工作
    3. } 
    4. foo( 42 ) 
    5. on (foo "completion") { 
    6.  // 可以进行下一步了！
    7. } 
    8. on (foo "error") { 
    9.  // 啊，foo(..)中出错了
    10. }

    当然这样的代码，Javascript并不提供，更自然的表达方法是：

    1. function foo(x) { 
    2.  // 开始做点可能耗时的工作
    3.     return listener; // 构造一个listener事件通知处理对象来返回
    4. } 
    5. var evt = foo( 42 ); 
    6. evt.on( "completion", function(){ 
    7.  // 可以进行下一步了！
    8. } ); 
    9. evt.on( "failure", function(err){ 
    10.  // 啊，foo(..)中出错了
    11. } );
    12. bar( evt );  // 让bar(..)侦听foo(..)的完成

    这里没有把回调传给 foo(..)，而是返回一个名为 evt的事件注册对象，由它来接受回调。此处的反转显而易见，我们通过反转再反转，拿回了对代码的控制权，即调用代码将控制权反转给第三方，再从第三方那里反转回来。对控制反转的恢复实现了更好的关注点分离，即bar不需要关注foo(...)的调用细节，foo(..)也不需要关注bar是否存在。从本质上说，evt 对象就是分离的关注点之间一个中立的第三方协商机制。

    Promise “事件”

    其实上面的事件侦听对象 evt 就是 Promise 的一个模拟。foo(..) 与 bar(..)的内部实现或许如下

    1. function foo(x) { 
    2.     // 可是做一些可能耗时的工作
    3.     // 构造并返回一个promise
    4.     return new Promise( function(resolve,reject){ 
    5.         // 最终调用resolve(..)或者reject(..)
    6.         // 这是这个promise的决议回调
    7.     } ); 
    8. }
    9. function bar(fooPromise) { 
    10.     // 侦听foo(..)完成
    11.     fooPromise.then( 
    12.         function(){ 
    13.             // foo(..)已经完毕，所以执行bar(..)的任务
    14.         }, 
    15.         function(){ 
    16.             // 啊，foo(..)中出错了！
    17.         } 
    18.     ); 
    19. }

    注意： 传入Promise的函数会立即执行，不会像 then(..) 中的回调一样异步延迟

    另一种实现方式：

    1. function bar() { 
    2.  // foo(..)肯定已经完成，所以执行bar(..)的任务
    3. } 
    4. function oopsBar() { 
    5.  // 啊，foo(..)中出错了，所以bar(..)没有运行
    6. } 
    7. // 对于baz()和oopsBaz()也是一样
    8. var p = foo( 42 ); 
    9. p.then( bar, oopsBar ); 
    10. p.then( baz, oopsBaz );

    注意： p.then( .. ).then( .. ) 与 p.then(..); p.then(..); 是两个意义，前者p决议后调用then，因为.then返回的总是Promise，所以才能支持链式调用，此时第二个.then用的是第一个.then返回的Promise的决议值，而后者用的都是p的决议值。

    具有 then 方法的鸭子类型

    判断类似于 Promise 的值是否是真正的 Promise 很重要，多见于 Promise.resolve() 对于 Promise 和 thenable 的展开。 thenable 类似于 Promise，指任何具有 then(..) 方法的对象和函数。

    注意： 对象的原型链上若具有 then(..) 方法，那么这个对象也会被识别为 thenable。

    这里主要讲对thenable的类型检查。

    根据一个值的形态（具有哪些属性）对这个值的类型做出一些假定。这种类型检查一般用术语鸭子类型来表示——“如果它看起来像只鸭子，叫起来像只鸭子，那它一定就是只鸭子”。

    对 thenable值的鸭子类型检测就大致如下：

    1. if ( 
    2.    p !== null && 
    3.    ( 
    4.        typeof p === "object" || 
    5.        typeof p === "function" 
    6.     ) && 
    7.        typeof p.then === "function" 
    8. ) { 
    9.    // 假定这是一个thenable! 
    10. } 
    11. else { 
    12.    // 不是thenable 
    13. }

    注意

       如果有其它代码无意或恶意地给Object.prototype、Array.prototype或者其它原生原型添加了then方法，也会造成灾难。不过鸭子类型有时候还是有用的，只是要小心鸭子类型把不是Promise的值误判为Promise的情况。

    Promise 信任问题

    Promise 的特性就是专门用来为回调编码的信任问题提供一个有效的可复用的答案。

    调用过早

    即使是立即完成的 Promise也无法被同步观察到。即对一个 Promise 调用 then(..) 的时候，即使这个 Promise 已经决议，提供给then(..) 的回调也总会被异步调用（微队列）。所以 Promise 不存在调用过早这个问题。（.then异步微任务）

    调用过晚

    Promise 创建对象调用 resolve(..) 或 reject(..) 时，这个 Promise 的 then(..) 注册的观察回调就会被自动调度。可以确信，这些被调度的回调在下一个异步事 件点上一定会被触发。所以也不存在调用过晚的问题。

    注意： 当 Promise 决议后，其上所有的通过 then(..) 注册的回调都会在下一个异步时机点上依次被立即调用。这些回调中的任意一个都无法影响或延误对其他回调的调用。
    举个🌰：

    1. p.then( function(){ 
    2.     p.then( function(){ 
    3.         console.log( "C" ); 
    4.     } ); 
    5.     console.log( "A" ); 
    6. } ); 
    7. p.then( function(){ 
    8.  console.log( "B" ); 
    9. } ); 
    10. // 结果：A B C

    这里的 "C" 无法打断或抢占"B"。 下面这样写又是另一种结果：

    1. p.then( function(){ 
    2.     p.then( function(){ 
    3.         console.log( "C" ); 
    4.     } ); 
    5.     console.log( "A" ); 
    6. } )
    7. .then( function(){ 
    8.  console.log( "B" ); 
    9. } ); 
    10. // 结果：A C B

    这里就要注意到 p.then( .. ).then( .. ) 与 p.then(..); p.then(..); 是两个意义

    Promise 调度技巧

    如果两个 promise p1 和 p2 都已经决议，那么 p1.then(..); p2.then(..) 应该最终会先调用 p1 的回调，然后是 p2 的那些。但还有一些微妙的场景可能不是这样的:

    1. var p3 = new Promise( function(resolve,reject){ 
    2.     resolve( "B" ); 
    3. } ); 
    4. var p1 = new Promise( function(resolve,reject){ 
    5.     resolve( p3 ); 
    6. } ); 
    7. p2 = new Promise( function(resolve,reject){ 
    8.     resolve( "A" ); 
    9. } ); 
    10. p1.then( function(v){ 
    11.     console.log( v ); 
    12. } ); 
    13. p2.then( function(v){ 
    14.  console.log( v ); 
    15. } ); 
    16. // 结果：A B

    不易理解的点就在resolve( p3 )，规定的行为是把 p3 展开到 p1，但是注意是异步地展开。

    注意： new Promise((resolve)=>{resolve(val)}) 与 Promise.resolve(val) 并不一定等价

    1. 当 val 是一个 Promise 实例时，resolve(val) 是异步展开，而 Promise.resolve 将不做任何修改、原封不动地返回这个实例
    2. 当 val 是一个 thenable 对象时，都采取异步展开
    3. 当 val 是其他值时，两种方式等价

    这里针对前两种情况给出测试代码（chrome下）：

    Promise.resolve 传入 Promise 实例 是异步展开

    resolve() 传入 Promise 实例，chrome下回调会被推迟两个时序
    原因：new Promise(r => r(v))里浏览器会创建一个 PromiseResolveThenableJob 去处理这个 Promise 实例，也就是所谓的展开

    1. new Promise(resolve => {
    2.     resolve(1);
    3.     Promise.resolve(
    4.         new Promise(function(resolve, reject){
    5.             console.log(2);
    6.             resolve(3)
    7.         })
    8.     ).then(t => console.log(t))
    9.     console.log(4);
    10. }).then(t => console.log(t));
    11. console.log(5);
    12. // 结果： 2 4 5 3 1
    13.  
    14. new Promise((resolve, reject) => {
    15.     console.log(1);
    16.     resolve(Promise.resolve()); // 直接用Promise.resolve()生成实例
    17. }).then(() => {
    18.     console.log(2);
    19. });
    20.  
    21. new Promise(function(resolve) {
    22.     console.log(3);
    23.     resolve();
    24. }).then(function() {
    25.     console.log(4);
    26. }).then(function() {
    27.     console.log(5);
    28. }).then(function() {
    29.     console.log(6);
    30. });
    31. // 结果：1 3 4 5 2 6

    Promise.resolve 传入 thenable 对象（promise）将不做任何修改、原封不动地返回这个实例

    • resolve() 传入 thenable 对象，chrome下回调被推迟一个时序
    1. new Promise(resolve => {
    2.     resolve(1);
    3.     Promise.resolve({
    4.         then: function(resolve, reject){
    5.             console.log(2);
    6.             resolve(3)
    7.         }
    8.     }).then(t => console.log(t))
    9.     console.log(4);
    10. }).then(t => console.log(t));
    11. console.log(5);
    12. // 结果: 4 5 2 1 3
    13.  
    14. new Promise((resolve, reject) => {
    15.     console.log(1);
    16.     resolve({
    17.         then: function(resolve, reject){
    18.             resolve()
    19.         }
    20.     }); 
    21. }).then(() => {
    22.     console.log(2);
    23. });
    24.  
    25. new Promise(function(resolve) {
    26.     console.log(3);
    27.     resolve();
    28. }).then(function() {
    29.     console.log(4);
    30. }).then(function() {
    31.     console.log(5);
    32. }).then(function() {
    33.     console.log(6);
    34. });
    35. // 结果：1 3 4 2 5 6

    这些细微的差别，确实很让人头疼。要避免这样的细微区别带来的噩梦，你永远都不应该依赖于不同 Promise 间回调的顺序和调度。

    •   - 执行函数中执行resolve方法会修改为成功状态
    •   - 执行函数中执行rejecte方法或者有执行代码==报错==，会修改为失败状态
    •   - then方法无论执行哪种状态的回调函数，都会默认return一个新的Promise实例resolve状态的对象，默认值为undefined，通过return res的方式可以给下一次的函数中传值。
    •   - 如果想让then方法的回调函数返回状态为rejected的promise实例，就需要return new rejected对象，或者throw一个错误。

    回调未调用

    首先，没有任何东西（甚至 JavaScript 错误）能阻止 Promise 向你通知它的决议，Promise 在决议时总是会调用完成回调和拒绝回调中的一个。

    如果 Promise 本身永远不被决议，即使这样，Promise 也提供了解决方案：

    1. const p = Promise.race([
    2.   fetch('/resource-that-may-take-a-while'),
    3.   new Promise(function (resolve, reject) {
    4.     setTimeout(() => reject(new Error('request timeout')), 5000)
    5.   })
    6. ]);
    7. p
    8. .then(val => console.log(val))  // 及时完成
    9. .catch(err => console.error(err));  // 超时

    调用次数过少或过多

    根据定义，回调被调用的正确次数应该是 1。Promise 的定义方式使得它只能被决议一次。

    注意：

    如果出于某种原因，Promise 创建代码试图调用 resolve(..) 或 reject(..) 多次，或者试图两者都调用，那么这个 Promise 将只会接受第一次决议，并默默地忽略任何后续调用。
    由于 Promise 只能被决议一次，所以任何通过 then(..) 注册的（每个）回调就只会被调用一次。如果你把同一个回调注册了不止一次（比如 p.then(f); p.then(f);），那它被调用的次数就会和注册次数相同。

    未能传递参数 / 环境值

    • 如果你没有用任何值显式决议，那么这个值就是 undefined，这是 JavaScript 常见的处理方 式。
    • 如果要传递多个值，你就必须要把它们封装在单个值中传递，比如通过一个数组或对象。

    吞掉错误或异常

    如果在 Promise 的创建过程中或在查看其决议结果过程中的任何时间点上出现了一个 JavaScript 异常错误，那这个异常就会被捕捉，并且会使这个 Promise 被拒绝。
    如果在处理异常的过程中再次发生异常，它看起来好像被吞掉了，其实你并没有捕获。

    是可信任的 Promise 吗？

    Promise 并没有完全摆脱回调，它只是改变了传递回调的位置。

    我们并不是把回调传递给 foo(..)，而是从 foo(..) 得到某个东西（外观上看是一个真正的 Promise），然后把回调传给这个东西

    Promise.resolve(..) 提供了可信任的 Promise 封装工具，可以链接使用。

    链式流

    Promise 的两个固有行为特性：

    • 调用 Promise 的 then(..) 会自动创建一个新的 Promise 从调用返回
    • 在完成或拒绝处理函数内部，如果返回一个值或抛出一个异常，新返回的（可链接的） Promise 就相应地决议
    • 如果完成或拒绝处理函数返回一个 Promise，它将会被展开，这样一来，不管它的决议 值是什么，都会成为当前 then(..) 返回的链接 Promise 的决议值

    注意： 从完成（resolve()）处理函数返回 thenable 或者 Promise 的时候会发生展开，但从（拒绝reject()）处理函数返回 thenable 或者 Promise时不会发生展开（经测试得出）。
    举个🌰：

    1. var p = Promise.resolve( 21 ); 
    2. p.then( function(v){ 
    3.     console.log( v ); // 21 
    4.     // 创建一个promise并将其返回
    5.     return new Promise( function(resolve,reject){ 
    6.         resolve( v * 2 ); 
    7.     } ); 
    8. } ) 
    9. .then( function(v){ 
    10.     console.log( v ); // 42 
    11. } );

    你可以认为返回的Promise实例覆盖了原来默认返回的Promise实例。再来看看reject()：

    1. new Promise(function(resolve,reject){
    2.     reject(
    3.         Promise.resolve(1)
    4.     )
    5. })
    6. .then(val=>console.log(2,val))
    7. .catch(err=>console.log(3,err ))
    8. // 结果：3 Promise {<resolved>: 1}

    可以看到 err 是一个 Promise，足以证明 reject() 中并不会发生展开，当然你也可以去试试传入 thenable，也是同样的结果。

    • 如果你调用 promise 的 then(..)，并且只传入一个完成处理函数，一个默认拒绝处理函数 就会顶替上来：
    1. var p = new Promise( function(resolve,reject){ 
    2.     reject( "Oops" ); 
    3. } ); 
    4. var p2 = p.then( 
    5.     function fulfilled(){ 
    6.         // 永远不会达到这里
    7.     } 
    8.      // 假定的拒绝处理函数，如果省略或者传入任何非函数值
    9.      // function(err) { 
    10.      //     throw err; 
    11.      // } 
    12. );
    • 如果没有给 then(..) 传递一个适当有效的函数作为完成处理函数参数，还是会有作为替代 的一个默认处理函数：
    1. var p = Promise.resolve( 42 ); 
    2. p.then( 
    3.     // 假设的完成处理函数，如果省略或者传入任何非函数值
    4.     // function(v) { 
    5.     //     return v; 
    6.     // } 
    7.     null, 
    8.     function rejected(err){ 
    9.         // 永远不会到达这里
    10.     } 
    11. )

    Promise API

    Promise 用法

    1. function foo(name) {
    2.     return new Promise((resolve, reject) => {
    3.         name ? resolve({ name }) : reject({ error: 'error' });
    4.     })
    5. }
    6.  
    7.  
    8. foo('ProsperLee')
    9.     .then(
    10.         // 成功
    11.         value => {
    12.             console.log(value); // ProsperLee
    13.         },
    14.         // 失败 - 优先调用
    15.         reason => {
    16.             console.log('error', reason);
    17.         }
    18.     )
    19.     // 失败
    20.     .catch(reason => {
    21.         console.log('reason', reason);
    22.     })
    23.     // 完成
    24.     .finally(_ => {
    25.         console.log('Hello ProsperLee');
    26.     })
    27.  
    28. foo()
    29.     .then(
    30.         // 成功
    31.         value => {
    32.             console.log(value);
    33.         },
    34.         // 失败 - 优先调用
    35.         reason => {
    36.             console.log('error', reason); // error {error: 'error'}
    37.         }
    38.     )
    39.     // 失败
    40.     .catch(reason => {
    41.         console.log('reason', reason);
    42.     })
    43.     // 完成
    44.     .finally(_ => {
    45.         console.log('Hello Error');
    46.     })
    47.  
    48.  
    49. // 最终输出结果
    50. // ProsperLee
    51. // error {error: 'error'}
    52. // Hello ProsperLee
    53. // Hello Error

    Promise.all 和 Promise.race 的区别和使用

    1. function foo(name) {
    2.     return new Promise((resolve, reject) => {
    3.         name ? resolve({ name }) : reject({ error: 'error' });
    4.     })
    5. }
    6.  
    7. function bar(name) {
    8.     return new Promise((resolve, reject) => {
    9.         setTimeout(_ => {
    10.             name ? resolve({ name }) : reject({ error: 'error' });
    11.         }, 3000);
    12.     })
    13. }
    14.  
    15. // 等待然后返回两个函数成功的返回值
    16. Promise.all([foo('Lee'), bar('Tom')])
    17.     .then(values => {
    18.         // [{name: 'Lee'}, {name: 'Tom'}]
    19.         console.log(values);
    20.     }, reason => {
    21.         console.log(reason);
    22.     })
    23.  
    24. // 等待然后返回函数错误的返回值
    25. Promise.all([foo('Lee'), bar()])
    26.     .then(values => {
    27.         console.log(values);
    28.     }, reason => {
    29.         // {error: 'error'}
    30.         console.log(reason);
    31.     })
    32.  
    33. // 返回出结果快的那个函数的返回值，不论成功或失败
    34. Promise.race([foo(), bar('Tom')])
    35.     .then(value => {
    36.         console.log(value);
    37.     }, reason => {
    38.         // {error: 'error'}
    39.         console.log(reason);
    40.     })

    Promise - finally

    1. function foo(name) {
    2.     return new Promise((resolve, reject) => {
    3.         setTimeout(_ => {
    4.             name ? resolve({ name }) : reject({ error: 'error' });
    5.         }, 3000);
    6.     })
    7. }
    8.  
    9. foo('Lee')
    10.     .finally(_ => {
    11.         console.log('A');
    12.     })
    13.     .then(res => {
    14.         console.log(res);
    15.         return res;
    16.     })
    17.     .finally(_ => {
    18.         console.log('B');
    19.     })
    20.     .then(res => {
    21.         console.log(res);
    22.     })
    23.     .finally(_ => {
    24.         console.log('C');
    25.     })
    26.  
    27. // 最终输出结果：
    28. //      A
    29. //      {name: 'Lee'}
    30. //      B
    31. //      {name: 'Lee'}
    32. //      C

    Promise 局限性

    顺序错误处理

    Promise 链中的错误很容易被无意中默默忽略掉，当然最佳实践就是Promise 链的最后总以一个 catch(..) 结束

    单一值

    Promise 只能有一个完成值或一个拒绝理由。一般的建议是构造一个值封装（比如一个对象或数组）来保持多个信息。

    单决议

    还有很多异步的情况适合另一种模式——一种类似于事件和 / 或数据流的模式。
    设想场景：你可能要启动一系列异步步骤以响应某种可能多次发生的激励（就像是事件），比如按钮点击。这样可能不会按照你的期望工作：

    1. // click(..)把"click"事件绑定到一个DOM元素
    2. // request(..)是前面定义的支持Promise的Ajax 
    3. var p = new Promise( function(resolve,reject){ 
    4.     click( "#mybtn", resolve ); 
    5. } ); 
    6. p.then( function(evt){ 
    7.     var btnID = evt.currentTarget.id; 
    8.     return request( "http://some.url.1/?id=" + btnID ); 
    9. } ) 
    10. .then( function(text){ 
    11.     console.log( text ); 
    12. } );
    13.

    只有在按钮点击一次的情况下，这种方式才能工作。如果这个按钮被点击了第二次的话，promise p 已经决议，因此第二个 resolve(..) 调用就会被忽略。
    解决办法：为每个事件的发生创建一整个新的 Promise 链。如下：

    1. click( "#mybtn", function(evt){ 
    2.     var btnID = evt.currentTarget.id; 
    3.     request( "http://some.url.1/?id=" + btnID ) 
    4.     .then( function(text){ 
    5.         console.log( text ); 
    6.     } ); 
    7. } );
    8.

    这个设计在某种程度上破坏了关注点与功能分离（SoC）的思想。

    惯性

    这里给到一个基于回调的代码转化为基于 Promise 的代码的范例：

    1. if (!Promise.wrap) { 
    2.     Promise.wrap = function(fn) { 
    3.         return function() { 
    4.             var args = [].slice.call( arguments ); 
    5.             return new Promise( function(resolve,reject){ 
    6.                 fn.apply( 
    7.                     null, 
    8.                     args.concat( function(err,v){ 
    9.                         if (err) { 
    10.                             reject( err ); 
    11.                         } 
    12.                         else { 
    13.                             resolve( v ); 
    14.                         } 
    15.                     } ) 
    16.                 ); 
    17.             } ); 
    18.         }; 
    19.     }; 
    20. }
    21. // 使用
    22. var request = Promise.wrap( ajax ); 
    23. request( "http://some.url.1/" ) 
    24. .then( .. ) 
    25.

    我们见识到了闭包的强大之处。闭包是 JS 最强大的特性，没有之一。

    无法取消的 Promise

    一旦创建了一个 Promise 并为其注册了完成和 / 或拒绝处理函数，如果出现某种情况使得 这个任务悬而未决的话，你也没有办法从外部停止它的进程，一种选择是侵入式地定义你自己的决议回调，当然这很丑陋。如下：

    1. var OK = true; 
    2. var p = foo( 42 ); 
    3. Promise.race( [ 
    4.     p, 
    5.     timeoutPromise( 3000 ) 
    6.     .catch( function(err){ 
    7.         OK = false; 
    8.         throw err; 
    9.     } ) 
    10. ] ) 
    11. .then( 
    12.     doSomething, 
    13.     handleError 
    14. ); 
    15. p.then( function(){ 
    16.     if (OK) { 
    17.         // 只在没有超时情况下才会发生 :) 
    18.     } 
    19. } );

    Promise 性能

    更多的工作，更多的保护，这些意味着 Promise 与不可信任的裸回调相比会更慢一些。 但我们不要耿耿于 Promise 微小的性能损失而无视它提供的所有优点， 虽然 Promise 稍慢一些，但是作为交换，得到的是大量内建的可信任性、对 Zalgo 的避免以及 可组合性。
    😏😏😏 Promise 非常好，请使用。它们解决了我们因只用回调的代码而备受困扰的控制反转问题。

     

  • 相关阅读:
    Centos 64位环境下编译32位C程序
    从零开始配置 vim(8)——文件类型检测
    OpenCV学习(4.9) OpenCV中的轮廓
    Java类配置Spring
    最大流与最小费用最大流简略版)
    Academic accumulation|社会创业研究：过去的成就和未来的承诺
    C#语法糖系列 —— 第三篇：聊聊闭包的底层玩法
    Android之CompletableFuture一异步编程常用方法
    华为L410上制作内网镜像模板01
    P06 DDL
  • 原文地址：https://blog.csdn.net/qq_63358859/article/details/127922789