回调函数 + ERROR + promise --暑假Day8

回调函数

1. 同步回调函数
   不会放入队列中，一上来就执行，比如forEach里面中的回调函数，这个是会立即执行的

2. 异步回调函数
   会放入队列中按顺序执行

setTimeout(() => {
    console.log('定时器里面')
}, 0)
console.log('定时器外面');

如果是一个函数的作用是载入一个js文件，此时在这个函数下面调用js文件里面的内容是做不到的，解决办法是给最开始的函数再传入一个回调函数，让想使用的内容都放在这个回调函数里面，然后在js文件的onload事件里面调用，这样就可以顺利使用

如果想按顺序加载两个脚本，那就在函数里面再加一个回调函数，如果想更多的话，也可以嵌套多个回调函数

如果报错，改进办法是如果报错就让执行函数再加上一个onerror事件

这个是对异步编程的旧的解决方案

关于error

错误类型

1. Error: 所有错误的父类型

2. EvalError:eval()的定义和使用不一致

3. RangeError:数值越界
   也有可能会是死循环

4. ReferenceError:非法或不能识别引用数值

5. SyntaxError:发生语法解析错误

6. TypeError:操作数类型错误

7. URIError:URI处理函数使用不当

错误处理

1. 捕获错误：try … catch
   try的大括号里面放可能会报错的代码，catch的参数是error，大括号内容就是对捕获的error做的一系列行为

2. 抛出错误： throw new Error()
   括号里面填出错了之后想让进行的事，然后通过trycatch捕获后调用message属性来具体进行

错误对象

1. message属性：错误的相关信息
2. stack属性：函数调用栈记录信息

promise

是js中进行异步编程的新的解决方案

具体表达：

• 从语法上说，是一个构造函数
• 从功能上说：promise对象用来封装一个异步操作并可以获取其结果数据

状态

稳定时是pending，也有fulfilled和rejected
状态只有从pending变成fulfilled和pending变成rejected两种，而且一个promise对象只能改变一次
然后会返回一个结果数据，如果成功就是value，失败就是reason

基本使用

首先创建一个新的promise对象
new出来之后传一个回调函数，回调函数的两个参数一般默认传resolve和reject，此时的回调函数还被称为执行器函数，负责执行异步任务
执行完异步任务之后，如果成功了，调用resolve(value),如果失败了，就调用reject(reason)
在上述两个调用结束之后，执行promise对象的then方法，then方法里面有两个函数，value函数接受得到成功的value数据，reason接收得到的reason数据

const p = new Promise((resolve, reject) => {
    setTimeout(() => {
        const time = Date.now();

        if (time % 2 == 0) {
            resolve('成功的数据,time = ' + time);
        }else{
            reject('失败的数据，time =' + time);
        }
    },1000);
})

p.then(
    value => {
        console.log('成功的回调', value);
    },
    reason => {
        console.log('失败的回调', reason);
    }
)

使用纯回调函数的方式要必须先指定回调函数，再执行异步任务
但是使用promise可以恰好反过来，所以说指定回调函数的方式更加灵活

为什么要用promise?

1. 指定回调函数的方式更加灵活
   可以在启动任务后指定回调函数
2. 支持链式调用(连续调用)，可以解决回调地狱问题
   多个串联的回调会造成回调地狱，在早期会造成右金字塔形状，不便于理解和阅读，不便于维护
   

解决回调地狱最终级的办法是async/await

promise的API

API是语法或者前后端交互

Promise的语法

1. Promise构造函数：Promise(excutor) {}
   执行器(excutor)函数，同步执行，两个参数(resolve, reject) => {}
   resolve函数，内部定义成功时我们调用的函数
   reject函数，内部定义失败时我们调用的函数

2. Promise.prototype.then方法：(onResolved, onRejected) => {}
   onResolved函数：成功时的回调(value) => {}
   onRejected函数：失败时的回调(reason) => {}
   都会返回一个新的Promise对象

3. Promise.prototype.catch方法: (onRejected) => {}
   onRejected函数：失败时的回调(reason) => {}
   then的语法糖，相当于then(undefined, onRejected)

4. Promise.resolve方法:(value) => {}
   value: 返回成功的数据或者promise对象
   是语法糖

5. Promise.reject方法：(reason) => {}
   reason: 返回失败的原因，返回失败的promise对象
   是语法糖

6. Promise.all方法：(promises) => {}
   promises:包含n个promise的数组
   返回一个新的promise，只有所有的promise都成功才成功，只要有一个失败就失败

7. Promise.race方法：(promises) => {}
   promises:包含n个promise的数组
   返回一个新的promise，第一个完成的promise的结果就是最终的结果状态,看谁先执行

const p1 = new Promise((resolve, reject) => {
    resolve(1);
})
const p2 = Promise.resolve(2);
const p3 = Promise.reject(3);

p1.then(value => console.log(value));//1
p2.then(value => console.log(value));//2
p3.catch(reason => console.log(reason));//3

const p = Promise.all([Promise.resolve(123),Promise.resolve('str'), Promise.resolve(3)]);
p.then(
    value => {
        console.log('成功' + value);//成功123,str,3
    },
    reason => {
        console.log('失败' + reason);
    }
)

value和reason的值实际上是resolve或者reject括号内的内容