Promise 和 Async

1. Promise 和 Callback 有什么区别

   - 深度和宽度的区别都能解决异步

   - Promise 是 ES6 标准提出异步编程解决方案

2. Promise 有几个状态

   - pending 等待、fulfilled 成功、rejected 失败

3. Promise 构造函数是同步还是异步执行，then 那

   - Promise 构造函数是同步,then 是异步

4. Promise 如何实现

5. Promise 的优缺点

   **优点**

   promise 对象，可以将 **异步操作** 以 **同步操作的流程** 表达出来，避免层层嵌套

   **缺点**

   1. 无法取消 Promise，一旦新建它就会立即执行，无法中途取消。

   2. 如果不设置回调函数，Promise 内部抛出的错误，不会反映到外部。

   3. 处于 pending 状态时，是不能知道目前进展到哪个阶段的 ( 刚开始？，即将结束？)

6. 如何设计 Promise.all()

7. Promise 怎么异常捕获

   1. reject

   2. catch（推荐）

      > 因为 catch 可以捕获执行中的错误，也更接近同步的写法(try/catch)

   3. 捕获不了异步错误 因为 try catch 只能捕获同步错误

8. Async/Await 和 Promise 的区别

   1. 简洁不用写匿名参数调用

   2. Async/Await 让 try/catch 可以同时处理同步和异步错误

   3. Async/Await 可以让程序中断

   4. 条件语句

   5. 错误栈

9. Async/Await 内部实现原理

   ​ Generator+CO 模块

   1. 内置执行器，不需要使用 next()手动执行。

   2. await 命令后面可以是 Promise 对象或原始类型的值，yield 命令后面只能是 Thunk 函数或 Promise 对象。

   3. 返回值是 Promise。返回非 Promise 时，async 函数会把它包装成 Promise 返回。(Promise.resolve(value))

const fs = require("fs");
const util = require("util");
let readFile = util.promisify(fs.readFile);

let isPromise = (x) => {
  if ((typeof x === "object" && x != null) || typeof x === "function") {
    if (typeof x.then === "function") {
      return true;
    }
  }
  return false;
};

Promise.all = (promises) => {
  console.log("all");
  return new Promise((resolve, reject) => {
    let arr = [];
    let idx = 0;
    let promisesData = (value, index) => {
      arr[index] = value;
      if (++idx === promises.length) {
        resolve(arr);
      }
    };
    for (let i = 0; i < promises.length; i++) {
      let x = promises[i];
      if (isPromise(x)) {
        x.then((y) => {
          promisesData(y, i);
        }, reject);
      } else {
        promisesData(x, i);
      }
    }
  });
};

Promise.all([
  1,
  readFile("./name.txt", "utf-8"),
  readFile("./age.txt", "utf-8"),
  3,
]).then((data) => {
  console.log(data);
});

new Promise(function (resolve, reject) {
  setTimeout(() => {
    throw new Error("Whoops!");
  }, 1000);
}).catch(alert);
// 正如本章所讲， 函数代码周围有个“ 隐式的
// try..catch”。 所以， 所有同步错误都会得到处理。

// 但是这里的错误并不是在 executor 运行时生成的， 而是在稍后生成的。 因此， promise 无法处理它。