Javascript基础之-Promise
作者:小辞 标签:Javascript

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中卷》