SOURCE

// 休眠函数

function sleep(time) {
    return new Promise(resolve => {
        console.log('executor 函数立即执行')
        setTimeout(() => resolve(time), time)
    })
}

console.log('1000 ms 之后醒来')
sleep(1000).then(() => { console.log('嗨起来！') })


// 当 executor 函数出异常的时候
// 会将 Promise 状态改变成 rejected
// executor函数的返回值被忽略
// function sleep(time) {
//     return new Promise(resolve => {
//         throw 12
//         // 这里将不会在执行
//         setTimeout(resolve, time)
//     })
// }

sleep(1000).then(null, (e) => { console.log('error', e) })

// Promise.reject(1) 抛出了一个错误异常
// 会被最近的一个 onRejected 函数捕获到
Promise.reject(1).then((body) => {
    console.log('success', body)
    return Promise.reject(2)
}, null).then((body) => {
    console.log('success', body)
    return 3
}, (error) => {
    console.log('error', error)
    // 当返回值不是一个 Promise 对象的时候
    // 默认包装成 Promise 
    // 当 executor 没有出现异常的时候会走到下一个 onFulfilled 函数
    return 4
}).then((body) => {
    console.log('success', body)
    // 当 executor 没有出现异常的时候会走到下一个 onRejected 函数
    return a
}, (error) => {
    console.log('error', error)
}).then((body) => {
    console.log('success', body)
}, (error) => {
    console.log('error', error)
    // 当函数没有显示的设置返回值时
    // 默认返回一个 Promise 值为 undefined
}).then((body) => {
    console.log('success', typeof body)
}, (error) => {
    console.log('error', error)
})


// Promise.all 并发
Promise.all([sleep(100), Promise.resolve(1), 2]).then(body => {
    console.log('success', body) // success [undefined, 1, 2]
    console.log(body)
})

Promise.all([sleep(100), Promise.reject(1), 2]).then(body => {
    console.log('success', body) 
    console.log(body)
}, (error) => {
    console.log('error', error) // error 1
})

Promise.all([]).then(body => {
    console.log('success', body) // success []
    console.log(body)
})

Promise.all('').then(body => {
    console.log('success', body) // success []
    console.log(body)
})


// Promise.race
Promise.race([sleep(100), Promise.reject(1), 2]).then(body => {
    console.log('success', body) 
    console.log(body)
}, (error) => {
    console.log('error', error) // error 1
})

Promise.race([Promise.reject(1), 2]).then(body => {
    console.log('success', body) 
    console.log(body)
}, (error) => {
    console.log('error', error) // error 1
})

Promise.race([sleep(100), sleep(0)]).then(body => {
    console.log('success', body) // success 0
    console.log(body)
}, (error) => {
    console.log('error', error) 
})

// Promise.prototype.finally(onFinally) 不管成功失败都会触发
Promise.resolve(1).finally(() => console.log('finally'))

Promise.reject(1).finally(() => console.log('finally'))

// 链式调用时 只会找到最近的一个错误处理函数执行,即使监听了 catch 也不会触发
Promise.reject(1)
.then()
.then(null, error => console.log('错误处理 then', error))  // '错误处理 then' 1
.catch(error => console.log('错误处理 catch', error))  // '错误处理 catch' 1
.finally(() => console.log('finally'))

//  缓存当前 Promise 示例的情况下 所有的错误处理函数都会触发
const p = Promise.reject(2)
p.then()
p.then(null, error => console.log('错误处理 then', error))  // '错误处理 then' 1
p.catch(error => console.log('错误处理 catch', error))  // '错误处理 catch' 1
p.finally(() => console.log('finally'))