浅谈Promise,async,await

promise的基本用法
首先我们明确pormise是一个对象
第一步我们需要先new一个promise

const promise = new Promise()

promise支持我们传入一个参数

const promise = new Promise(param)

但是请注意这个地方的参数是一个函数，我们先把这个函数用箭头函数的形式写出来

const promise = new Promise(()=>{
	
})

而这个函数又可以接收两个参数，一个是resolve，一个是reject

const promise = new Promise((resolve,reject)=>{
	
})

以上是我们使用promise的第一步
第二步，就是将我们的异步代码写在Promise的函数中，此处我们使用微信小程序的wx.request函数做演示

const promise = new Promise((resolve,reject)=>{
	wx.request({
		success(res){
			...
		}
		fail(error){
			
		}
	})
})

promise有三种状态，第一种是pending（进行中，代表异步的操作正在进行），第二种是fulfilled（已成功，代表异步操作已经执行成功了），第三种是rejected（已失败，代表异步操作执行失败），我们在使用promise的时候这三种状态是如何发生并且发生改变的呢
首先当我们new了一个promise的时候，此时promise已经处在pending中，也就是进行中了，而对于一个处于进行中状态的promise来说它的结果就只有两种，一种是已成功，一种是已失败，那么如何将进行中的promise的状态修改成已成功或者是已失败呢，通过调用resolve，会将状态修改成已成功，调用rejected会将状态修改成已失败。

const promise = new Promise((resolve,reject)=>{
	wx.request({
		success(res){
			resolve(res)
		}
		fail(error){
			reject(error)
		}
	})
})

值得注意的是，一旦这个promise的状态被修改成已成功或者已失败的时候，此时promise的状态就被凝固了，它不可能再被修改成别的状态了，也就是操作时不可逆的。

以上我们就完成了new promise的全过程，接下来我们就可以
通过promise的变量随时取到我们此次异步调用的结果啦。我们使用promise提供的.then方法取到结果

promise.then()

promise的这个方法接收两个回调函数的参数，第一个参数需要传入一个当promise成功时候的回调函数，第二个参数需要传入当promise失败时候的回调函数

promise.then((res)=>{
	
},(error)=>{
	
})

注意：这两个回调函数的顺序是不能颠倒的，第一个必须是成功状态，第二个必须是失败

promise的精髓就在于使用对象的方式保存了异步调用的结果。

promise可以解决异步嵌套的问题
举例：微信小程序中wx.request就是一个异步的函数，需要用回调函数来接收异步调用的结果

wx.request({
  url: 'test.php', //仅为示例，并非真实的接口地址
  success (res) {
    console.log(res.data)
  }
})

success函数就为回调函数，用来接收此次请求成功的结果，假设我们在此次回调函数中继续需要发起新的网络请求，那么毫无疑问，我们继续还需要用一个回调函数来接收调用结果，如果我们还继续需要发起请求呢，就会导致写出下面这样的代码

wx.request({
  url: 'test.php', //仅为示例，并非真实的接口地址
  success (res) {
    wx.request({
		success (res) {
			wx.request({
				success (res){
					wx.request({
						success (res){
							...
						}
					})	
				}
			})
		}
	})
  }
})

这样的代码是不是看起来很复杂，嵌套的结构过于繁琐，这种过多的回调函数的嵌套，有一个专有名词，叫做回调地狱，promise就是可以用来解决这个问题。我们现在定义了三个promise对象

const promise1 = new Promise((resolve,reject)=>{
	wx.request({
		url:'/test1'
		success(res){
			resolve(res)
		}
		fail(error){
			reject(error)
		}
	})
})
const promise2 = new Promise((resolve,reject)=>{
	wx.request({
		url:'/test2'
		success(res){
			resolve(res)
		}
		fail(error){
			reject(error)
		}
	})
})
const promise3 = new Promise((resolve,reject)=>{
	wx.request({
		url:'/test3'
		success(res){
			resolve(res)
		}
		fail(error){
			reject(error)
		}
	})
})

我们想实现的功能是再promise1成功之后调用promise2，promise2成功之后调用promise3，正常情况下我们都会写出这样的代码

promise1.then((res)=>{
	promise2.then((res)=>{
		promise3.then((res)=>{
			
		})
	})
})

但是你会发现这样写好像和回调地狱也没啥差别，所以说这样写才不是真正会用promise，真正用promise写出来的代码是这样的

promise1.then((res)=>{
	return promise2
}).then({res}=>{
	return promise3
}).then((res)=>{
	coonsole.log(res)
})

现在打印出来的res是promise3异步执行的结果，这才是promise的正确用法，这样能让我们每一次异步调用都是平行的关系。但是上述这种仅限于所有涉及到的函数都是异步函数。

接下来说一下async和await（号称异步终结解决方案）
async和await必须搭配在一起使用，否则是会报错
await意义有两个

1.对promise对象求值，比如说某个函数调用的结果返回的是一个promise对象：Promise{‘123’},我们这个时候不想要promise对象而是只想要里面的字符串’123’,那么这时候我们只要在返回结果前面加上await就可以了，但是值得注意的是await并不仅仅只能对promise进行求值，而是可以对任意的表达式都可以进行求值比如说await 100*100,那么结果肯定是10000

2.await可以阻塞当前线程
当await后面调用的是一个异步的函数的时候，这个时候就必须等待异步操作的结果返回之后，才会继续执行下面的代码。这就将难以处理的异步函数的调用变成同步的。

async的意义在于
1.使用了async这个函数的任何的返回值，都会被强制包装成为一个promise对象
2.如果不用async，光用await，代码会报错，所以必须使用，也是相当于捆绑使用吧。

那么async和await怎么搭配promise来使用呢
举个例子

class1.fun1(args1).then((res)=>{
	return res.fun2(args2)
}).then((result)=>{
	console.log(result)
})

这样的一段代码就可以改写成

const res = await class1.fun1(args1)
const result = await res.fun2(args2)
console.log(result)

是不是很简单~

以上就是我个人对promise，asynchronous，await的理解，最近工作没有hin忙，所以可能会多些一些东西~