Promise的基本用法

Promise简单来说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。从语法上来说，Promise是一个对象，从它可以获得异步操作的消息。Promise提供统一的API，各种操作都可以用同样的方法进行处理。
Promise对象有两个特点：
1.对象的状态不受外界的影响。
2.一旦在状态改变就不会在再变。
Promise对象代表一个异步操作，一共有三种状态：
1.Pending（进行中）
2.Fulfilled（已成功）
3.Rejected（已失败）
Promise状态改变只能有两种可能：从Pending变为Fulfilled和从Pending变为Rejected。
ES6规定，Promise对象是一个构造函数，用来生成Promise实例

let promise=new Promise((resolve,reject)=>{
	//执行操作
	if(/*异步操作成功*/){
		resolve(value);
	}else{
		reject(error);	
	}
})
//Promise实例生成以后，可以用then方法分别指定Resolved状态和Rejected状态
promise.then(function(value){
	//success
},function(error){
	//failure
});
//Promise创建后会立即执行，then方法指定的回调函数将在当前脚本所在同步任务执行完成后才执行
let promise=new Promise(function(resolve,reject)=>{
	console.log("promise");
	resolve();
});
promise.then(function(){
	console.log("resolved");
});
console.log("hi");
//promise
//resolved
//hi

Promise原型上的方法有then和catch
采用链式的then方法可以指定一组次序调用的回调函数，前一个回调函数有可能返回的还是一个Promise对象（即有异步操作），而后一个回调函数就会等待该Promise对象状态发生变化再调用。

getJSON("/post/1.jpg").then(
	post=>getJSON(post.commentURL);
).then(
	comments=>console.log("Resolved:",comments),
	err=>console.log("rejected",err);	
);

catch用于指定发生错误的回调函数

let promise=new Promise((resolve,reject)=>{
	throw new Error('test');
});
promise.catch((error)=>{
	console.log(error);
});

Promise.all()
Promise.all方法用于将Promise实例包装成一个新的Promise实例。
Promise.all()接受一个数组作为参数。
let p=Promise.all([p1,p2,p3]);
p的状态由p1,p2,p3决定分为两种情况
1.只有p1,p2,p3的状态都变成Fulfilled，p的状态就变成Fulfilled,此时p1,p2,p3的返回值组成一个数组，传递给p的回调函数。
2.只要p1,p2,p3的状态有一个为Rejected，p的状态就变成Rejected,此时第一个被Rejected的实例的返回值会传递给p的回调函数。

let p1=function(){
    return new Promise((resolve, reject)=>{                
        //假设已经进行了异步操作，并且获得了数据
        resolve("p1")
    });
}
let p2=function(){
    return new Promise((resolve, reject)=>{
        //假设已经进行了异步操作，并且获得了数据
        resolve("p2");
    });
}
let p3=function(){
    return new Promise((resolve, reject)=>{
        //假设已经进行了异步操作，并且获得了数据
        resolve("p3");
    });
}
Promise.all([p1(),p2(),p3()]).then(function(data){
    console.log(data);
},function(data){
    console.log(data);
});
//["p1","p2","p3"]
//如果p1执行异步操作后返回的是失败执行reject则只输出["p1"]

Promise.race()
Promise.race方法是将多个Promise实例包装成一个新的Promise实例。
只要p1,p2,p3中有一个实例先改变状态，p的状态就跟着改变。那个先改变的Promise实例返回值就传递给p的回调函数。

let p1=function(){
    return new Promise((resolve, reject)=>{                
        setTimeout(()=>{
        	resolve("p1");
        },3000)
    });
}
let p2=function(){
    return new Promise((resolve, reject)=>{
        setTimeout(()=>{
        	resolve("p2");
        },2000)
    });
}
let p3=function(){
    return new Promise((resolve, reject)=>{
         setTimeout(()=>{
        	resolve("p3");
        },4000)
    });
}
Promise.race([p1(),p2(),p3()]).then(function(data){
    console.log(data);
},function(data){
    console.log(data);
});
//"p2"
//其他异步操作并不是不执行了，而是不会将返回值给p的回调函数

Promise.resolve()
Promise.resolve()方法将现有对象转化为Promise对象

Promise.resolve('foo');
//等同于
new Promise(resolve=>resolve('foo'));

Promise.reject()
Promise.reject(reason)方法会返回一个新的Promise实例，状态为Rejected

let p=Promise.reject('error');
//等同于
let p=new Promise((resolve,reject)=>reject('error'));
p.then(null,function(s){
	console.log(s)
});
//error

Promise的缺点：
（1）无法取消Promise，一旦新建它就会立即执行，无法中途取消。
（2）如果不设置回调函数，Promise内部抛出来的错误不会反应到外部。
（3）当处于Pending状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）。

猜你喜欢