关于javascript:Promise小结

38次阅读

共计 2536 个字符，预计需要花费 7 分钟才能阅读完成。

每个 Promise 都有本人的一个生命周期，开始未解决而后变成已解决。开始 pedding 状态示意进行中，操作完结后。Promise 可能进入以下两种状态某一个：

Fuiflled Promise 操作实现。
Rejected 程序谬误或者其余起因 Promise 为能够实现。

外部 [[PromiseState]] 用来示意三个状态:pending,fulfilled 及 rejected。这个属性并没有裸露在 Promise 对象上，所以检测不到。Promise 状态扭转的时候通过 then 取得。

所有 Promise 都有 then 办法，两个参数：第一个是 Promise 的状态变为 fulfilled 时候调用的函数，与异步操作无关数据传递给这个参数。第二个是变为 rejected 时执行的函数，失败相干附加数据能够通过参数传递给这个回绝函数。

Tips

留神 new Promise 的时候传递函数会立刻执行并且函数体内的操作是一个同步操作。
new Promise((res,rej) =>{}), 接管一个函数作为参数，函数有两个参数是两个 callback 示意胜利和失败的时候执行的。

    let p = new Promise((res,rej) => {console.log(1,'1')
        res("success")
        console.log(2,'2')
    })
    p.then((resolve)=>{console.log(resolve,'resolve')
    },(reject)=> {console.log(reject,'reject')
    })
    console.log(4)
    // 输入程序 1 2 4 success

Promise 链的一个重要个性就是能够给上游 Promise 传递数据，如果在实现处理程序中指定一个返回值，则能够沿着这条链持续传递数据。

Tips:

Promise 链中的返回值如果是 Promise 对象的话依据返回的 Promise 状态进行执行对应 then 和 catch，如果 return 一个非 Promise 那么会把它应用 Promise.resolve 包装成为一个 fulfilled 状态的 Promise。

如果 then 中没有 return 值，那就相当于 return 一个空的 Promise 对象(已实现状态)。比方:

let a = new Promise((res,rej) => {res(6)
})
a.then((res) => {console.log(res,'第一个执行实现')
    // 6
}).then(res=> {console.log("第二个返回打印",res)
    // 第二个返回打印 undefined
})

链式调用 Promise:

let p1 = new Promise(function (resolve,reject) {resolve(42)
})

p1.then(function(value) {console.log(value)
    // return 一个常量 then 中的 return 会主动包装为 Promise.resolve(xx)
    return value+1
}).then((res) => {console.log(res) // 43
})

// 回绝处理程序中是同样的
let p1 = new Promise((reslove,reject) => {reject(42)
})

p1.catch((rej) => {console.log(rej)
    return rej+1 // return 非 Promise 对象，应用 Promise.resolve 包装
}).then((value) => {console.log(value) //43
})

Promise 的谬误捕获有两种形式

then 函数的第二个参数。

let a = new Promise((res,rej) => {rej(2)
})

a.then((res) => {// success do},(rej) => {
    // reject do
    console.log(2) // 2
})

catch 函数

let a = new Promise((res,rej) => {rej(2)
})
a.then(res => {// success do}).catch(err => {// do sth})

catch 函数能够在链式调用的时候当作整个链的 Promise 谬误处理程序。

a.then(res=> {}).then(res=> {}).then((res) => {}).catch(rej => {
    // 任意一个环节走到谬误都会走到.catch 这里
    // 并且无 return 中断环节的执行（因为曾经 catch 失败，第一个 then 就调用不到了，所以链式完结）。})

Promise 类和其余内建类型统一，也能够作为基类派生类，所以也能够定义本人的 Promise 变量来扩大 Promise 的性能。

class MyPromise extends Promise {
    // 应用默认的 Promise 构造函数
    success(resolve,reject) {return this.then(reslove,reject)
    }
    failure(reject) {return this.catch(reject)
    }
}
let promise = new MyPromise(function (resolve,reject) {resolve(42)
})
promise.success(function(value) {console.log(value)
},function(value) {console.log(value)
})

// or
promise.failure(function (value) {console.log(value)
})

这个例子中扩大了两个 success 和 failure 办法。这两个办法都通过 this 调用它模拟的办法，派生 Promise 与内建 Promise 性能统一，只不过多了 success 和 failure 这两个能够调用的办法。

用于静态方法会也会被继承，因而派生的 Promise 也都存在 MyPromise.resolve(),MyPromise.reject(),MyPromise.all(),MyPromise.race()静态方法。
后两者与内建办法齐全不同，前两个稍有不同。

正文完