1. 声明一个Promise
function Promise(executor) {
this.PromiseState = 'pending'
this.PromiseResult = null
this.callback={};
const self = this
function resolve(data) {
if (self.PromiseState !== 'pending') return;
console.log(this)
self.PromiseState = 'fulfilled'
self.PromiseResult = data
if(self.callback.onResove){
self.callback.onResove(data)
})
}
function reject(data) {
console.log(this)
if (self.PromiseState !== 'pending') return;
self.PromiseState = 'rejected'
self.PromiseResult = data
if(self.callback.onReject){
self.callback.onReject(data)
})
}
try {
executor(resolve, reject);
} catch (e) {
reject(e);
}
}
Promise.prototype.then = function(onResove, onReject) {
if (this.PromiseState === 'fulfilled') {
onResove(this.PromiseResult);
}
if (this.PromiseState === 'rejected') {
onReject(this.PromiseResult);
}
if(this.PromiseState==='pending'){
this.callback={
onResove:onResove,
onReject:onReject,
}
}
}
let p =new Promise((resolve,reject)=>{
setTimeout(() {
resolve('success')
}, 1000);
});
p.then(value=>{
console.log(value)
},reason=>{
console.log(reason)
})
2.状态
进行中,成功,失败,状态的转化只有两种
pending变成resolved
pending变成rejected
状态只能改一次,不论成功还是失败,都会有一个数据结果
3.对象的值
promise结果保存着异步任务失败或者成功的结果
resolve
reject
4.基本流程
创建promise实例对象,执行异步操作,then返回一个新的Promise对象
5.catch的回调,捕获错误
6.promise.resolve() 传入的状态永远都是成功的
当一个函数被期望返回一个 promise 时，这个方法用于兼容性。（译注：这里的兼容性是指，我们直接从缓存中获取了当前操作的结果 value，但是期望返回的是一个 promise，所以可以使用 Promise.resolve(value) 将 value “封装”进 promise，以满足期望返回一个 promise 的这个需求。）
7.promise.resolve() 传入的状态永远都是失败的 用法与promise.resolve()一样
8.Promise.all()；
Promise.all方法用于将多个 Promise 实例，包装成一个新的 Promise 实例
（1）只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。
（2）只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。
9.Promise.race();
Promise.race()方法是将多个Promise实例包装为一个实例；
const p = Promise.race([p1, p2, p3]);
上面代码中，只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数。
Promise.race方法的参数与Promise.all方法一样，如果不是 Promise 实例，就会先调用下面讲到的Promise.resolve方法，将参数转为 Promise 实例，再进一步处理
10.如果修改Promise对象的状态
1)调用resolve函数
2)调用reject函数
3)抛出错误
let p=new Promise((resolve,reject)=>{
resolve('ok');
reject('err');
throw '有错误啦'
})
11.只要Promise状态改变对应的回调都会执行
let p=new Promise((resolve,reject)=>{
resolve('ok');
})
p.then(value=>{
alert(value)
})
p.then(value=>{
alert(value)
})
12.then的返回结果
let p=new Promise((resolve,reject)=>{
resolve('ok');
})
p.then(value=>{
alert(value)
throw '出了问题'
return 521
return new Promise((resolve,reject)=>{
resolve('success')
})
})
p.then(value=>{
alert(value)
})
13.Promise的异常穿透
let p =new Promise((resolve,reject)=>{
setTimeout(()=>{
reject('err')
},1000)
});
p.then(value=>{
console.log(1111)
}).then(value=>{
console.log(2222)
}).catch(reason=>{
console.log(reason)
})
14.中断promise链条
let p =new Promise((resolve,reject)=>{
setTimeout(()=>{
resolve('success')
},1000)
});
p.then(value=>{
console.log(1111)
return new Promise(()=>{})
}).then(value=>{
console.log(2222)
}).catch(reason=>{
console.log(reason)
})
15.await与async
async function main(){
1.如果返回值是一个非promise类型的数据,返回的时成功的promise
2.返回的是promise,由promise的状态决定
3.抛出异常 返回结果就是一个失败的promise
}
let result =main()
console.log(result)
await 右侧表达式一般是promise对象,但也可以是其他形式
1.如果是是promise对象,await返回的是promise成功的值
2.如果表达式是其他值,直接将此值作为await的返回值
await必须写在async中,但是async可以没有await
await的promise失败了,需要通过try...catch()捕获处理
const fs=require('fs')
const until=require('util')
const mineReadFile=util.promisify(fs.readFile)
async function main(){
let data1=await mineReadFile('1.html')
let data2=await mineReadFile('2.html')
let data3=await mineReadFile('3.html')
}
main()
let btn=document.querySelector('btn')
btn.addEventListener('click',async function(){
let duanzi=await sendAjax('url接口')
})
