Javascript基础之-Promise

转载自：http://www.lht.ren/article/3

Promise是什么呢？根据ecma-262的定义：

Promise是一个被用于延时计算的最终结果的占位符

（A Promise is an object that is used as a placeholder for the eventual results of a deferred (and possibly asynchronous) computation.）

 

这个怎么理解呢

好比说，我要去麦当劳买点吃的，下单之后人家会先给你一个订单号，等人家外卖作好了，会提示你，并用那个订单小票来换取你真正的食物，在这时候，那个订单小票就是你这顿饭的占位符。

 

回到Promise，它有三种状态，分别为完成，拒绝和待决议，

而待决议的状态表明它尚未被完成或者是拒绝，也就是说，若是它一直都是处于待决议的状态，意味着代码永远都不会继续往下执行

 

因此下面这段代码永远都执行不到finish

new Promise((resolve, reject) => {
  console.log('waiting');
  document.writeln('waiting');
}).then((msg) => {
  console.log('finish');
});

也就是意味着，必须显示的执行resolve()或者是reject，程序才会继续往下执行。

 

那怎么解决这个问题呢，其实很简单，决议一下就行了嘛，哈哈~~

或者给Promise设置一个超时时间，看下面的代码：

function timeoutPromise(delay) {
  return new Promise( function(resolve,reject){
    setTimeout( function(){
      reject( "Timeout!" );
    }, delay );
  } );
}
Promise.race([
  new Promise(() => {
    console.log('waiting...');
  }),
  timeoutPromise(3000)
]).catch((msg) => {
  console.log(msg);
})

这段代码呢，会先等待5秒，而后会打印出一个错误"Timeout"，在这里，Promise.race()实际上就是竞态的，谁先决议，其他的就会被抛弃。因此我们三秒钟后决议一个拒绝，剩下那个promise自动被抛弃了

 

说到错误处理了，思考下面的代码：

new Promise((resolve, reject) => {
  foo.bar();
}).then((msg) => {
  console.log(msg);
}, null).then((msg) => {
  console.log(msg);
}, (err) => {
  console.log(err);
});

这段代码，很明显foo不是对象，因此会报ReferenceError，因此呢，会自动决议为reject，而后他紧接着的那个then没有拒绝处理回调，而后接着往下传递错误，直到有reject回调为止，假如一直都没有reject回调呢，他就会在全局抛出一个未捕获的异常。

 

那么若是在Promise决议屡次呢，实际上只有第一次决议生效，也就是说，只能有一种决议生效，又成功又失败，或者成功屡次，失败屡次听着就不靠谱是吧，思考下面的代码

new Promise((resolve, reject) => {
  resolve();
  reject();
  console.log('exec finish');
}).then((msg) => {
  console.log('resolve');
}, (err) => {
  console.log('reject');
});

运行结果是输出exec finish 和resolve，由于第一次决议为resolve, 因此reject决议就被抛弃了

 

你们想一下，决议后对应的then里面的回调函数是同步仍是异步的呢，思考下面这个问题：

console.log(0);
let p = new Promise((resolve, reject) => {
  console.log(1);
  resolve();
  console.log(2);
})
console.log(3);
p.then((msg) => {
  console.log(4);
});
console.log(5);

他的结果是 1 2 3 5 4

答案很显然啦，是异步的！实际上当决议之后，就会把它放到一个异步队列里调用

那为何要这么设计呢，会给咱们带来什么好处呢，思考下面这个问题

function getResult() {
  console.log(a);
}
function opt() {
  if (isAsync) {
    setTimeout(() => {
      getResult();
    }, 0);
  } else {
    getResult();
  }
}
var a = 0;
var isAsync = false;
opt();
a++;
isAsync = true;
opt();
a++;

他的结果输出的是0  2，那为何不是0, 1,实际上就是由于因为同步和异步的的不肯定性致使的，也叫zalgo，因此呢，要想消除他们的不肯定性，必须就让他里面的代码要么都是同步，要么都是异步，这也是then为何是异步的缘由了

 

关于then，还有一个问题，就是then的返回值是什么，来继续看问题

var p = Promise.resolve( 21 );
var p2 = p.then( function(v){
  return v * 2;
});
console.log(p2);

经过他的结果，你很容易就能看出来，then的返回值是一个Promise，那么，这个then回调是否是能够这么理解呢？

function callback() {
  return Promise.resolve(42);
}

若是是的话，那么我们就研究一下Promise.resolve()的特性，而后then()同理就能够是吧

 

那么咱们如今就研究一下Promise.resolve()的一些特性：

1. 若是向Promise.resolve()传递一个非Promise，非thenable的当即值，就会当即获得这个值填充的Promise，这个有三个关键字，非Promise，非thenable和当即值

2. 若是向Promise.resolve()传递一个真正的promise，那么就会返回这个Promise，又一个例子，很好理解

   var p = Promise.resolve(42);
   var p2 = Promise.resolve(p);
   console.log(p === p2);   // true

3. 若是向Promise.resolve()传递一个非Promise的thenable值，那么就会展开这个值，而且在展开过程会持续到提取出一个具体的Promise最终值

   你们应该会有一点疑惑，thenable是什么，这段话是什么意思

   var obj = {
     then(resolve, reject) {
       resolve(42);
     }
   };
   Promise.resolve(obj).then((msg) => {
     console.log(msg);  //42
   });

好了，Promise.resolve()特性讲完了，then返回值同理

 

同理完了之后呢，就会出现一些比较有意思的用法

首先就是链式调用，好比说

var p = Promise.resolve( 21 );
var p2 = p.then( function(v){
  console.log( v ); // 21
  // 用值42填充p2
  return v * 2;
} );
// 链接p2
p2.then( function(v){
  console.log( v ); // 42
} );

很简单吧，就不赘述了。

 

还有一个比较有意思，就是Promise实现同步执行，也就是前一个then若是是异步的话，它必须操做完成后，才会执行后面的then，常见的写法是这样的

new Promise((resolve, reject) => {
  setTimeout(() => {
    console.log('exec in promise it');
    resolve();
  }, 1000);
}).then(() => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      console.log('exec in then it');
      resolve();
    }, 1000);
  });
});

这个先过一秒输出第一句话，再过一秒输出第二句话

这个的原理实际上刚刚Promise.resolve()的第二条，若是返回的是Promise，那么会直接返回这个Promise，在这里，直接返回return的这个Promise后，就会等待这个Promise决议，在一秒后决议完，就执行后面的then

 

最后一个有关then的知识点了：

一个Promise决议后，这个Promise上全部的经过then()注册的回调都会在下一个异步时间节点上依次被当即调用，这些回掉中任意一个都没法影响或者延误对其余回调的调用

var p = new Promise((resolve, reject) => {
  resolve();
});
p.then( function(){
  p.then( function(){
    console.log( "C" );
  } );
  console.log( "A" );
} );
p.then( function(){
  console.log( "B" );
} );
// a b c

这个的重点其实是这些决议回调都被加入到了一个队列中，输出的顺序正好实际上就表明了他们加入队列后的前后顺序

 

好的，这一章讲解完了，若是有什么想和我讨论的，或者有什么意见和建议，请留言给我（qq:75675231,email:liu75675231@126.com）

 

参考书籍《你不知道的Javascript中卷》