Promise

一，Promise使用方式

Promise是es6中增加的构造函数（类）之一 ，还有proxy , map , get

proxy代理 ？

使用方式

1. promise 接收一个函数作为参数 ， 通常我们会在该函数内发送异步请求
   2.该函数有两个参数 ， resolve , reject ,这两个也是函数
   resolve执行时， 会将Promise实例的状态修改为resolved
   reject 执行时， 会将Promise实例的状态修改为rejected
   3.Promise的实例，有then()方法， 该方法可以接收两个函数作为参数，第一个函数表示成功时（resolved）执行的函数，参数是resolve执行时传递的参数，只能传递一个参数

第二个函数表示失败（rejected）时，执行的函数 ，参数是reject执行时传递的参数，也只能传递一个参数 。
4.then方法可以连续打点调用，
当Promise实例为同一个时，第一个then会根据Promise的状态变化而决定执行第一个函数还是第二个函数 ， 后续的then只有第一个参数函数生效，第二个写了也没用。

var p = new Promise(function(resolve,reject){
	//发送ajax要卸载这里
	Ajax.get("./php/a.php","",function(data){
		if(!data.error){
			//以前我们把具体的业务逻辑写在回调函数的if语句块中
			//现在我们不写业务逻辑，而是调用resolve 或者 reject
			console.log(data)
			resolve(data.msg);
		}else{
			reject();
		}
	})

});

//p这个对象有个then（）方法， 接受两个函数作为参数
p.then(function(msg){
	 console.log("成功")
	 console.log(msg)
},function(){
	console.log("失败")
})

以前我们在回调函数中写业务逻辑， 现在我们在函数中成功了就执行resolve(), 失败了就执行reject(). 然后把具体对应的代码写到 then （） 中 。resolve 和 reject 都可以传参数 。

p.then() 调用完了返回的是p对象 ，因此可以继续 .then() 。
这个函数执行完了还是他自己。

二，Promise连续调用

//定义一个promise
p.then(function(msg){
	console.log("成功")
	var p1 = new Promise(function(resolve,reject){
		Ajax.get("php.php","b=2",function(data){
			if(!data.error){
				resolve(data.msg)
			}else{
				reject(data.msg)
			}
		})
	})
	//返回promise实例
	return p1;
},function(){
	console.log("失败")
})

//第二个then监听的就是p1的状态变化

.then(function(data){
	console.log(data)
})
.catch(function(){
// 谁失败处理谁
})

三，Promise的静态方法

之前我们是先发送一个请求，等请求发送回来之后再发送另一个
现在希望同时发送两个请求，等他们都回来之后再做事情

于是 Promise 提供了静态方法 all (构造函数调用的方法叫静态方法)

Promise.all(arr)
该方法接受一个数组为参数， 数组中的每一个成员都是Promise实例。
该方法的作用是 ： 同时监听多个promise实例的状态变化，返回值是一个新的promise实例
如果被监听的promise实例中有任何一个失败了， all返回的promise实例的状态变为rejected（失败) ， 被监听的promise实例都resolved了， all返回的Promise实例状态变为resolved了 （成功）

Promise.all([])

function sendPromise1(){
	return new Promise(function(resolve,reject){{
		Ajax.get("a.php","",function(data){
			if(!data.error){
				resolve(data.msg)
			}else{
				reject(data.msg)
			}
		})
	})
}

function sendPromise2(){
	return new Promise(function(resolve,reject){{
		Ajax.get("b.php","",function(data){
			if(!data.error){
				resolve(data.msg)
			}else{
				reject(data.msg)
			}
		})
	})
}



let p1 = sendPromise1();
let p2 = sendPromise2();
//以下一条代码的含义是， 让p监听p1 和 p2
let p = Promise.all([p1,p2]);
p.then(function(arr){
//成功时，唯一的参数是数组，数组的每一项是all接收的数组的每一项对应的传递的数据
consolo.log("两个都成功")

})
.catch(msg){
	console.log(msg) //失败时，唯一的参数是失败的第一个reject传递的数据
}

Promise.race

// Promise.race
//该方法接受一个数组作为参数，每一个成员应当是Promise的实例
//该方法的作用，返回一个Promise的实例，该实例的状态跟随数组中第一个发生状态变化的Promise实例
let p = Promise.race([p1,p2])
p.then(function(msg){

})
.catch(function(msg){

})

Promise.resolve

该方法接受3种可能性的参数

1. 非Promise 比如数字，字符串，布尔值等
2. Promise实例
3. thenable对象

返回值是一个Promise实例 如果是非Promise作为参数 ，则Promise实例的状态为resolved ,并且接收到的值是该参数

let p = Promise.resolve(1);
p.then(function(msg){
	console.log(msg) //1
})

如果是Promise实例作为参数 ，则跟随它的状态

let p = Promise.resolve(sendPromise());
p.then(function(data){
	console.log("success",data)
})

.catch(function(msg){
	console.log("failed",msg)
})

如果是thenable 对象

let p = Promise.resolve({
then:function(resolve,reject){
	resolve();
}
})
p.then(function(){
	console.log("成功")
})
.catch(function(){
	console.log("失败")
})

Promise.reject()

返回一个状态为rejected的Promise实例， 参数是什么都可以。参数一般是一个描述失败原因的字符串。

let p = Promise.reject("失败了，也不知道为什么")

p.then(function(){
 // 这个then写不写没有用
})
.catch(function(a){
	console.log(a) //失败了，也不知道为什么
})