一、基础巩固
1.实例对象和函数对象
（1）普通对象都是实例对象，即由 new关键字 创建出来的对象。
（2）函数本身也是对象，具体体现为 将函数当做对象来使用。
（3）括号前面是函数，点前面是对象。
function Fn(){} //Fn是函数
const fn = new Fn() //Fn是构造函数，fn是构造函数的实例对象
console.log(Fn.prototype);//将Fn函数当做对象使用，所以Fn是函数对象
$('#app') //$代表jquery函数
$.get() // 发送ajax请求时将$函数当做对象使用，所以$是函数对象。
2.两种类型的回调函数
（1）回调函数可以理解为 自己定义，但不是由自己调用的函数。
（2）同步回调函数：立即执行的回调函数，结束后再执行后面的内容。不会加入异步回调队列。
// 1.同步回调函数：立即执行的回调函数，结束后再执行后面的内容。不会加入异步回调队列。
// 例如：数组遍历相关的回调函数 || Promise的excutor函数
const arr = [1, 2, 3];
arr.forEach((item) => {
console.log(item);
});
console.log('遍历后面的内容执行');
（3）异步回调函数：回调函数不会立即执行，会放入回调队列在将来执行。
// 2.异步回调函数：回调函数不会立即执行，会放入回调队列在将来执行。
// 例如：定时器的回调函数 || Promise的成功或失败的回调。
setTimeout(() => {
console.log('定时器的回调函数执行');
}, 0);
console.log('定时器后面的内容执行');
3.错误处理
（1）写函数时，对可能的错误手动抛出，具体处理有调用者决定。
（2）用 try{ }catch(err){ } 代码块包裹可能出现错误的代码，并对错误进行捕获。
function fn() {
const num = Math.round(Math.random());
if (num === 0) {
console.log('随机数是0');
} else {
throw new Error('随机数是1'); //throw error抛出异常，具体的处理有调用者决定
}
}
//捕获异常
try {
fn();
} catch (error) {
alert(error);
}
二、Promise的理解和使用
1.什么是Promise
抽象表达：
Promise 是 JS 中进行异步编程的新解决方案（旧方案是单纯使用回调函数）
具体表达:
（1）从语法上来说: Promise 是一个 构造函数。
（2）从功能上来说: promise 对象用来封装一个异步操作并可以获取其成功/失败的结果值。
（3）Promise构造函数（的回调函数）是同步执行的，我们将异步操作放到回调函数体内，成功和失败时分别调用resolve和reject函数，这两个函数是异步调用的，且这两个函数内部会调用then方法中声明的成功和失败的回调函数。
2. promise 的状态改变
（1） pending 变为 resolved
（2） pending 变为 rejected
说明:
① 只有这 2 种情况, 且一个 promise 对象 只能改变一次。
② 无论变为成功还是失败, 都会有一个结果数据。
③ 成功的结果数据一般称为 value, 失败的结果数据一般称为 reason。
3.Promise 的注意点
（1）Promise构造函数本身是同步执行的，它处理的异步操作依然是异步执行的，但是可以通过 then()方法 或者 async、await 处理这个异步操作。
const p1 = new Promise((resolve)=> {
setTimeout(()=> {
console.log("定时器结束"); // 第二
resolve();
},1000)
})
p1.then(()=> {
console.log("then代码"); // 第三
})
console.log("普通同步代码"); // 第一
（2）Promise的 执行器函数 是一个 同步回调函数，即 new Promise(()=>{}) 时会立即执行该回调函数。
（3）成功和失败的回调是 异步回调函数。就是resolve()方法内部 异步调用then()指定的onResolved()回调函数。（手写Promise）
（4）直接挂载到函数对象上的方法只能被 构造函数使用；挂载到原型对象上的方法由 实例对象使用。
Promise.all() 和 Promise.prototype.then()
三、Promise的API的使用
1.Promise构造函数
格式：Promise (excutor) {}
（1）excutor 执行器函数: 同步执行的回调函数 (resolve, reject) => {}
（2）resolve 函数: 内部定义成功 时我们要调用的函数 value => {}
（3）reject 函数: 内部定义失败 时我们要调用的函数 reason => {}
说明: excutor 会在 Promise 内部立即同步回调,异步操作会在执行器中执行
2. Promise.prototype.then 方法
格式：(onResolved, onRejected) => {}
（1）onResolved 函数: 成功 的回调函数 (value) => {}
（2）onRejected 函数: 失败 的回调函数 (reason) => {}
说明:
① 指定 用于得到成功 value 的成功回调函数，和用于得到失败 reason 的失败回调函数
② then()方法会返回一个新的 promise 对象
3. Promise.prototype.catch 方法
格式：(onRejected) => {}
（1）onRejected 函数: 失败 的回调函数 (reason) => {}
说明: then()的语法糖, 相当于 then(null, onRejected)
new Promise((resolve, reject) => {
setTimeout(() => {
resolve('成功的数据');
// reject('失败的数据'); //只会执行其中一个，因为promise的状态只能改变一次
}, 1000);
})
.then((value) => {
console.log('操作成功，接收的数据为：' + value);
})
.catch((reason) => {
console.log('操作失败，接收的数据为：' + reason);
});
4. Promise.resolve 方法
格式： (value) => {}
（1）参数value： 成功的数据 或 promise 对象。
说明: 返回一个 成功或失败 的 promise 对象。
5. Promise.reject 方法
格式：(reason) => {}
（1）参数reason： 失败的原因。
说明: 返回一个 失败的 promise 对象。
// 生成一个成功数据为1的Promise对象：两种方式对比
const p1 = new Promise((resolve, reject) => {
resolve(1);
});
const p2 = Promise.resolve(2);
const p3 = Promise.reject(3);
6. Promise.all 方法
格式：([promise1，promise2]) => {}
（1）参数： 包含 n 个 promise 的 数组
（2）返回一个 新的 promise, 只有所有的 promise 都成功才成功, 只要有一个失败了就直接失败。
（3）返回的数组中的结果顺序和 传入的promise顺序 一致，与执行完成的先后顺序无关。
// 接上面代码
const pAll = Promise.all([p1, p2]);
pAll.then(
(values) => {
console.log('所有promise都成功了，结果为：', values); // 执行成功的回调函数，因为p1,p2都是成功的Promise
},
(reasons) => {
console.log('至少一个promise失败了，结构为：', reasons);
}
);
7.Promise.race 方法
格式：([promise1，promise2]) => {}
（1） 参数： 包含 n 个 promise 的数组
（2） 返回一个 新的 promise, 第一个完成的 promise 的结果状态就是最终的结果状态
（3）最终结果只和 实际执行顺序有关，与传入的promise顺序无关
// 接上面代码
const pRace = Promise.race([p3, p2, p1]);
pRace.then(
(value) => {
console.log('race结果是成功的：', value);
},
(reason) => {
console.log('race结果是失败的：', reason); //执行失败的回调函数，因为三个promise都没有异步操作，p3首先执行完成
}
);
四、Promise的几个关键问题
1.如何改变 promise 的状态
(1) 调用回调函数resolve(value)：如果当前是 pending 就会变为 resolved
(2) 调用回调函数reject(reason)：如果当前是 pending 就会变为 rejected
(3) 抛出异常：如果当前是 pending 就会变为 rejected
const p = new Promise((resolve, reject) => {
// resolve(1); // promise变为resolved成功状态
// reject(2); // promise变为rejected失败状态
// throw new Error(3); // promise变为rejected失败状态，reason为抛出的内容
throw 4;
});
2.一个 promise 指定多个成功或失败回调函数, 都会被调用
（1）当 promise 改变状态时 会调用 所有 对应的回调函数
const p = new Promise((resolve, reject) => {
resolve(1);
})
p.then(
(value) => {
console.log('成功：', value);
},
);
// 重新指定回调函数
p.then(
(value) => {
console.log('重新指定成功的回调函数:', value);
},
);
3.改变 promise 状态和指定回调函数谁先谁后
(1) 都有可能, 正常情况下是 先指定回调再改变状态, 但也可以先改状态再指定回调。
(2) 如何先改状态再指定回调?
① 在执行器中直接调用 resolve()/reject()
② 延迟更长时间才调用 then()
(3) 什么时候才能得到数据?
① 如果先指定的回调，先将回调函数保存； 当状态发生改变时, 回调函数就会调用, 得到数据。
② 如果先改变的状态, 那当指定回调时, 回调函数就会调用, 得到数据。
const p1 = new Promise((resolve, reject) => {
setTimeout(() => {
resolve(1); // 后改变状态(同时指定成功的数据)，异步执行回调函数
}, 1000);
});
//先指定回调函数，保存当前指定的回调函数
p1.then((value) => {
console.log('成功：', value);
});
const p2 = new Promise((resolve, reject) => {
resolve(2); //先改变状态(同时指定成功的数据)
}).then((value) => {
// 后指定回调函数，异步执行回调函数
console.log('成功：', value);
});
4.promise.then()返回的新 promise 的结果状态由什么决定
(1) 简单表达： 由 then()指定的回调函数 【执行的结果】决定，即then()返回的 promise 的结果决定。
(2) 详细表达：
① 如果返回的是 非 promise 的任意值, 新 promise 变为 resolved成功状态, value 为返回的值。
② 如果返回的是另一个 新 promise, 此 promise 的结果就会成为新 promise 的结果。
③ 如果 抛出异常, 新 promise 变为 rejected失败状态, reason 为抛出的异常。
new Promise((resolve, reject) => {
resolve(1);
})
.then(
(value) => {
console.log('onResolved()1:', value);
return 2; // 返回非promise，相当于返回一个成功的promise
// return Promise.resolve(3); //返回成功的promise
// return Promise.reject(4); // 返回失败的promise
// throw 5; // 抛出异常，相当于返回一个失败的promise
},
(reason) => {
console.log('onRejected()1:', reason);
})
.then(
(value) => {
console.log('onResolved()2:', value); // 前面then()方法最终返回的是一个成功的promise,成功结果为 2
},
(reason) => {
console.log('onRejected()2:', reason);
}
);
5.promise 串连多个操作任务
(1) promise 的 then()返回一个新的 promise, 可以看成 then()的链式调用。
(2) 通过 then 的链式调用串连多个同步 或 异步任务。
new Promise((resolve, reject) => {
//异步任务1
setTimeout(() => {
console.log('执行任务1(异步)');
resolve(1);
}, 1000);
})
.then((value) => {
console.log('任务1的结果：', value);
console.log('执行任务2(同步)'); //同步任务2
return 2;
})
.then((value) => {
console.log('任务2的结果：', value);
// 异步任务3,返回一个新的promise对象
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('执行任务3(异步)');
resolve(3);
}, 1000);
});
})
.then((value) => {
console.log('任务3的结果：', value);
});
6.promise 异常穿透
(1) 当使用 promise 的 then 链式调用时, 可以只在 最后 指定一个失败的回调。
(2) 前面任何操作出了异常, 都能够传到最后失败的回调中进行处理。
new Promise((resolve, reject) => {
reject(1);
})
.then(
(value) => {}
// then链式调用时不对失败进行处理，相当于执行了下面代码
// (reason) => {
// throw reason;
// return Promise.reject(reason);
// }
)
.then((value) => {})
.then((value) => {})
.catch((reason) => {
console.log('捕捉到异常：', reason);
});
7.如何中断 promise 链式调用
(1) 当使用 promise 的 then 链式调用时, 在中间中断, 不再调用后面的回调函数。
(2) 在回调函数中返回一个 pendding 状态的 promise 对象。
new Promise((resolve, reject) => {
resolve(1);
})
.then((value) => {
console.log('onResolved1():', value);
return new Promise(() => {}); // 返回一个pending状态的promise,后面的回调函数就不会被调用
})
.then((value) => {
console.log('onResolved2():', value);
});
