promise

支持链式调用，解决回调地狱的问题
ajax、fs、定时器

var fs=require("fs");
let p = new Promise((resolve,reject)=>{
  fs.readFile("./public/01.txt",(err,data)=>{
      if (err){
          reject(err);
      }
      resolve(data);
  })
});
p.then((data)=>{
    console.log(data.toString());
},(err)=>{
    console.log(err);
})

用promise封装异步任务，用then函数执行异步任务的结果

Promise状态

promise方法体中函数是顺序执行的
pending变为resolved或pending变为rejected，而且状态只能改变一次
promise的prototype有catch方法，传入reason参数的箭头函数，执行失败的回调
Promise.resolve()传入的参数非promise类型的对象返回成功promise对象，传入promise类型对象，则依赖该对象的状态
reject的返回的状态永远是失败的
all方法传入参数，promise类型的数组，返回结果是promise类型对象，数组中promise类型的数组都成功才算成功
race方法传入的promise类型的数组，返回结果是最先改变状态的promise对象
throw也可以改变promise的状态
promise状态和then回调函数不一定谁先执行，看是promise函数体运行代码同步还是异步
then方法中要得到数据必须是resolve或reject方法执行之后

异常穿透

promise在最后用catch捕获就可以，then只穿一个函数就可以

中断promise链

返回一个pending状态的promise对象

async 和awit

async function ff() {
     return new Promise((resolve,reject)=>{
         resolve("ss");
     })
}

返回promise类型对象，状态同then方法
await 只能在async函数中，右侧可以直接写promise
可以获取右侧promise返回的结果，resolve状态直接获取，rejected状态抛出异常，需要try catch处理下，catch中依旧可以得到rejected状态的promise返回的值
其他类型数据，是什么就返回什么

api将读文件函数转换promise函数

手写

function MyPromise(executor) {

    this.PromiseState = 'pending'
    this.PromiseResult = null
    this.callbacks = {}

    let resolve = (data) => {
        if (this.PromiseState == 'pending') {
            this.PromiseState = 'fulfilled'
            this.PromiseResult = data
        }
        this.callbacks.forEach(item => {
            item.onResolved(data)
        })
    }
    let reject = (data) => {
        if (this.PromiseState == 'pending') {
            this.PromiseState = 'rejected'
            this.PromiseResult = data
        }

        this.callbacks.forEach(item => {
            item.onRejected(data)
        })
    }

    try {
        executor(resolve, reject)
    } catch (e) {
        reject(e)
    }
}

MyPromise.prototype.then = function (onResolved, onRejected) {
    if (this.PromiseState == 'fulfilled') {
        try {
            let result = onResolved(this.PromiseResult)
            if (result instanceof Promise) {
                result.then(v => {
                    resolve(v)
                }, r => {
                    reject(r)
                })
            } else {
                resolve(result)
            }
        } catch (e) {
            reject(e)
        }

    }
    if (this.PromiseState == 'rejected') {
        onRejected(this.PromiseResult)
    }
    if (this.PromiseState == 'pending') {
        this.callbacks.push({onResolved: ()=> {
                let result = onResolved(this.PromiseResult)
                if (result instanceof Promise){
                    result.then(v => {
                        resolve(v)
                    }, r => {
                        reject(r)
                    })
                }else {
                    resolve(result)
                }
            }, onRejected: () => {
                let result = onRejected(this.PromiseResult)
                if (result instanceof Promise){ //返回数据类型判断，没有写默认undefined，promise状态改变成功
                    result.then(v => {
                        resolve(v)
                    }, r => {
                        reject(r)
                    })
                }else {
                    resolve(result)
                }
            }})
    }
}
MyPromise.prototype.catch=function(onResolved,onRejected){
    return this.then(undefined,onRejected)
}

let p = new MyPromise((resolve, reject) => {
    resolve('sucess')

});
p.then((value) => {
    alert(value)
}, (value) => {

})
console.log(p)