Promise简单了解

Error

1、错误的类型

• Error：所有错误的父类型
• ReferenceError：引用的变量不存在
• TypeError：数据类型不正确的错误
• RangeError：数据值不在其所允许的范围内
• SyntaxError：语法错误

2、错误处理

• 捕获错误：try … catch
• 抛出错误：throw error

3、错误对象

• message属性：错误相关信息
• stack属性：函数调用栈记录信息
  try … catch 用法

    try {
        // 可能会出错的代码，即使出错也不会终止程序执行
        let d
        console.log(d.xxx)
    } catch(error) {
        console.log(error.message)
        console.log(message.stack)
    }
    console.log('出错之后')

throw error 用法

    function something() {
        console.log(Date.now());
        if (Date.now()%2 === 1) {
            console.log('当前时间为奇数，可以执行任务')
        } else {
            throw new Error('当前无法执行任务')
        }
    }
    // 捕获处理异常
    try {
        something()
    } catch (error) {
        alert(error.message)
    }

Promise的基本使用

Promise本身是同步的所以先执行打印111

    // 创建Promise对象
    const p = new Promise((resolve, reject) => {
        console.log('111')
        // 执行异步任务
        setTimeout(() => {
            const time = Date.now() // 当前时间为偶数就代表成功，奇数代表失败
            if (time % 2) { // 成功， resolve(value) 
                resolve('成功的数据，time =' + time)
            } else { // 失败， reject(reason)
                reject('失败的数据，time = ' + time)
            }
        }, 1000)
    })
    // 写法1
    p.then(
        value => { // 成功的数据
            console.log(value)
        },
        reason => { // 失败的数据
            console.log(reason)
        }
    )
    // 写法2
    p.then(value => {
        console.log(value)
    }).catch(reason => {
        console.log(reason)
    })
    console.log('promise执行之后')

Promise与回调函数对比

1、更加灵活

回调函数：必须在异步任务启动前指定
Promise：启动异步任务 => 返回Promise对象 => 给Promise对象绑定回调函数(甚至可以在异步任务执行结束后)

2、支持链式调用，可以解决回调地狱问题

回调地狱：回调函数嵌套调用，内部回调函数的参数是外部回调函数的返回值
async await 方法

    async function request() {
        try {
            const result = await doson()
        } catch(error) {
            console.log(error)
        }
    } 

如何使用Promise？

Promise的API

1、Promise 构造函数：Promise(excutor){}

• exector 函数：执行器 (resolve, reject) => {}
• resolve 函数：内部定义成功时我们调用的函数，value => {}
• reject 函数：内部定义失败时我们调用的函数，reason => {}
• 说明：exector会在Promise内部立即同步调用，异步操作在执行器中执行

2、Promise.prototype.then 方法： (onReaolved, onRejected) => {}

• onReaolved 函数：成功的回调函数 (value) => {}
• onRejected 函数：失败的回调函数 (reason) => {}
• 说明指定用于成功和失败的回调，并返回一个新的Promise对象

3、Promise.prototype.catch 方法：(onRejected) => {}

• onRejected 函数：失败的回调函数 (reason) => {}

4、Promise.resolve 方法：(value) => {}, (reson) => {}

• value, reason: 返回 成功/失败 的Promise的对象

5、Promise.reject() 方法：(reason) => {}

• reason返回一个失败的Promise对象

6、Promise.all 方法：(promises) => {}

• promises：包含n个Promise的数组
• 返回一个新的Promise，所有的成功才算成功，有一个失败就算失败

7、Promise.race 方法：(promises) => {}

• promises：包含n个Promise的数组
• 返回一个新的Promise，第一个完成的状态就是结果状态

Promise 的几个关键性问题

1、如何改变 promise 的状态?
(1) resolve(value): 如果当前是 pending 就会变为 resolved
(2) reject(reason): 如果当前是 pending 就会变为 rejected
(3) 抛出异常: 如果当前是 pending 就会变为 rejected

2、一个 promise 指定多个成功/失败回调函数, 都会调用吗?
当 promise 改变为对应状态时都会调用
3、改变Promise和指定回调函数谁先谁后？
（1）都有可能，正常情况下先指定回调再改变状态，也可以先改状态再指定回调
（2）如何先改状态在指定回调？

• 在执行器中直接调用resolve()/reject()
• 延迟更长时间调用

4、 Promsie.then() 返回新的 promise 的结果状态由什么决定？
（1）简单表达：由then()指定的回调函数执行的结果决定
（2）详细表达：

• 如果抛出异常，新的 promise 变为 reject, reason 为抛出的异常
• 如果返回的是非 promise 的值，新 promise 变为 resolved，value 为返回的值
• 如果返回一个新的 promise，此 promise 的结果就会成为新 promise 的结果

5、promise 如何串联多个操作任务？
（1）promise 的 then() 返回一个新的 promise，可以分开成 then 的链式调用
（2）通过 then 的链式调用可以串联多个同步 / 异步任务
6、promise 异常传透?
（1） 当使用 promise 的 then 链式调用时, 可以在最后指定失败的回调
（2）前面任何操作出了异常, 都会传到最后失败的回调中处理
7、中断 promise 链?
（1）当使用 promise 的 then 链式调用时, 在中间中断, 不再调用后面的回调函数
（2） 办法: 在回调函数中返回一个 pendding 状态的 promise 对象