那么 promise的结构是什么呢
return new Promise((resolve, reject) => {
//做一些异步操作
}
demo实例：
function save(txt) {
return new Promise((suc, err) => {
if (txt > 10) {
suc('够大了')
} else {
err('不够')
}
})
}
console.log('save的promise', save(12).then((data) => {
console.log('promise返回值', data);
}));
/**
- 检查微信会话是否过期
*/
function checkSession() {
return new Promise(function(resolve, reject) {
wx.checkSession({
success: function() {
resolve(true);
},
fail: function() {
reject(false);
}
})
});
}
简单的promise实例
<script>
function one() {
console.log("1111");
}
function two() {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve(console.log("222"))
}, 2000)
})
}
function three() {
console.log("333");
}
async function show() {
one();
await two()
three();
}
show()
</script>
<body>
</body>
</html>
promise的结构大概是这样的
var promise = new Promise(function(resolve, reject) {
// ... some code
if (/* 满足条件 */){
resolve(value);
} else {
reject(error);
}
});
resolve表示异步执行成功
reject表示异步执行失败
1、Promise概述
比较官方的介绍就是：Promise是异步编程的一种解决方案。从语法上说，Promise 是一个对象，从它可以获取异步操作的消息。
在我理解下，所谓Promise其实就是一个通知。就像你期末考试，你不知道老师试卷什么时候改好，每天都担惊受怕自己是否及格。终于到了暑假的某一天，试卷发到你手里，这个时候只有两种结果：及格或不及格。 也就是Promise中的fulfilled（已成功）和 rejected（已失败）。然而我们等待试卷的过程就叫pending（进行中）。
官方里有这么一句话：除了异步操作的结果，任何其他操作都无法改变这个状态。
什么意思呢，也就是，我拿到了试卷，及格和不及格这个状态已经是事实了。也就是(已成功) 或 (已失败) 是没办法改变了。
定义Promise
它可以定义成功(resolve)返回的数据，和失败(reject)返回的数据。
function netPlay(age){
// 定义一个Promise,然后在里面做一些异步，等待返回
return new Promise(function(resolve,reject){
setTimeout(function(){
if(age>18){
resolve('你已经成年了，可以去网吧上网了')
}else{
reject('未成年人不准去网吧！')
}
},3000)
})
}
//又或者封装小程序的请求
function promiseAjax(_url,type,callback,data){
return new Promise(function (resolve, reject) {//成功的回调和失败的回调
wx.request({
url: _url,
method:type,
data, //如果要上传数据，就是这个data
success(res){
resolve(res);
},
fail(err){
reject(err);
}
})
});
}
如果说Promise是决定成功与否的命运，那么then就是我们面对这些结果的处理
2、then
官方介绍：then 方法接收两个函数作为参数，第一个参数是 Promise 执行成功时的回调，第二个参数是 Promise 执行失败时的回调，两个函数只会有一个被调用。
也就是说，我们这个暑假考完试后，老爸跟你讲了两种情况，如果你及格了，给你买一台ps5。如果不及格，罚你洗碗一个月。
而then就是处理结果的一个方法，分别是成功的回调(第一个参数)，和失败的回调(第二个参数)。 我们还在等待结果的时候就可以安排好怎样应对这个结果。
//定义Promise
function test(mark){
return new Promise(function(resolve,reject){
setTimeout(function(){
if(mark>60){
resolve('及格')
}else{
reject('不及格')
}
},3000)
})
}
//调用
test(59).then((data)=>{
console.log(data,'去买ps5')
},(err)=>{
console.log(err,'洗碗一个月') //不及格，洗碗一个月
})
//当然，这里因为不是调用接口获取结果的，所以59分不及格是预料之中，但如果我们的setTimeOut换成接口，根据每个学生获取他的分数，那么这个方法就奏效了。
注意
我们在前面有说到，then的第二个参数是用来接受reject(失败的回调),但其实catch也是接收reject传递的数据
test(59).then((data)=>{
console.log(data,'去买ps5')
}).catch((err)=>{
console.log(err,'洗碗一个月') //不及格，洗碗一个月
})
以上就是我们Promise的基本用法啦。
但是还没完，毕竟我也不是很熟，所以只能理解一点更新一点。
扩展
Promise.All
Promise.all方法执行后返回的依旧是promise, all两个全成功才表示成功 。
什么意思呢？
终于，你已经从上一年的暑假中得到了教训，努力学习，终于获得了质的飞跃，从不及格进入了新的领域。拿着60分的试卷去让老爸买一台PS5. 老爸马上兑现诺言，和你一起去游戏商城买这台PS5游戏机，结果，店家说:'你们做梦吧，PS5还没出呢！' ，所以，最终你还是没有买到PS5。
这个方法就是这个道理，它可以让我们执行多个异步操作，并且在同一个回调中处理所有的返回数据。返回的数据和传的参数数组的顺序是一样的。
function test(mark){
return new Promise(function(resolve,reject){
setTimeout(function(){
if(mark>60){
resolve('及格')
}else{
reject('不及格')
}
},3000)
})
}
function game(date){
return new Promise(function(resolve,reject){
setTimeout(function(){
if(date>2020){
resolve('PS5终于开售了')
}else{
reject('你们做梦吧，PS5还没出呢！')
}
},3000)
})
}
let result = Promise.all([test(60),game(2020)])
result.then((data)=>{
console.log(data)
}).catch((err)=>{
console.log(err) //你们做梦吧，PS5还没出呢！
})
注意：reject出来的数据只会是其中一条。就算两个异步都是失败返回，也只会返回最后一个。但如果成功，会返回成功回调全部数据。
<meta charset="utf-8">
1.Promise是什么？
Promise是异步编程的一种解决方案，在ES6中Promise被列为了正式规范，统一了用法，原生提供了Promise对象。
2.Promise的基本用法
- then中成功失败的执行
// resolve代表成功 reject失败 都是一个函数
let p = new Promise(function(reslove,reject){
//reslove('成功') //状态由等待变为成功，传的参数作为then函数中成功函数的实参
reject('失败') //状态由等待变为失败，传的参数作为then函数中失败函数的实参
})
//then中有2个参数，第一个参数是状态变为成功后应该执行的回调函数，第二个参数是状态变为失败后应该执行的回调函数。
p.then((data)=>{
console.log('成功'+data)
},(err)=>{
console.log('失败'+err)
})
Promise承诺：默认情况下是等待状态pending，如果有一天状态转变为成功就成功了，如果状态变成失败就失败了。状态一旦改变了就不能再改变了。
- 如果then中返回了一个promise 会将promise的结果继续传给第二then中（如果结果是将状态改成成功就走下一个then的成功回调，状态改为失败就走下一个then的失败回调）
function read( content ) {
return new Promise(function( reslove,reject ) {
setTimeout(function(){
if(content>4){
resolve(content)
}else{
reject('小于4')
}
},1000)
})
}
read(1).then(( data )=>{
console.log(data)
},( err )=>{
console.log(err) //小于4
return read(2) //将状态改为了失败
})
.then(( data )=>{
console.log('data',data)
},( err )=>{
console.log(err) //小于4
})
- 第一个then不管是走成功还是失败的回到函数，只要返回一个普通值（不抛出错误或者返回promise），都会执行下一个then的成功的回调。
let p = new Promise(function(reslove,reject){
reject('失败1')
})
p.then((data)=>{
console.log('成功'+data)
},(err)=>{
console.log('失败'+err) //失败失败1
})
.then((data)=>{
console.log('成功1'+data) //成功1undefined
},(err)=>{
console.log('失败1'+err)
})
eg:抛出错误执行下一个then的失败
let p = new Promise(function(reslove,reject){
reject('失败1')
})
p.then((data)=>{
console.log('成功'+data)
},(err)=>{
console.log('失败'+err) //失败失败1
})
.then((data)=>{
console.log('成功1'+data) //成功1undefined
throw Error('下一个失败')
},(err)=>{
console.log('失败1'+err)
})
.then((data)=>{
console.log('成功2'+data)
},(err)=>{
console.log('失败2'+err) //失败2Error: 下一个失败
})
- catch的用法
catch可以实现错误的捕获 一般写在最后，如果上面有自己的err会走自己的error。如果没有写就会走到catch
let p = new Promise(function(resolve,reject){
reject('失败')
});
p.then((data)=>{
},(err)=>{
throw Error('错误')
})
.then((data)=>{
},(err)=>{
console.log(err+'自己的err') //走自己的（输出：Error: 错误自己的err）
throw Error('错误自己抛出的')
})
.then((data)=>{
//没有自己的失败处理函数，走catch
}).catch(e=>{
console.log(e+'公共的err') //输出：Error: 错误自己抛出的公共的err
})
function demo () {
new Promise(function (resolve, reject) {
let num = Math.random()
if (num > 0.5) {
resolve(num) // 成功调用resolve方法
} else {
reject('失败了!') // 调用reject方法
}
})
.then(res => console.log('成功!' + res))
.catch(err => console.error(err) )
}
// 下面的代码等价于上面的代码
async function asyncDemo() {
try {
let res = await new Promise(function (resolve, reject) {
let num = Math.random()
if (num > 0.5) {
resolve(num) // 成功调用resolve方法
} else {
reject('失败了!') // 调用reject方法
}
})
console.log(res, 'async')
}
catch (err) {
console.log('Error:'+ err)
}
}
asyncDemo()
