Promise 重写 （第一部分）

最新推荐文章于 2024-07-12 09:36:48 发布
最新推荐文章于 2024-07-12 09:36:48 发布
阅读量323 收藏
点赞数
文章标签： javascript 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shaoyahu/article/details/134430619
版权

学习关键语句：
promise 重写

写在前面

重新学习了怎么重写 promise ， 我觉得最重要的就是要有思路，不然有些 A+ 规范是完全想不到的

开始

重写函数的过程中, 最重要的是有思路
我们从哪里获取重写思路? 从正常的代码中
我们先看正常的代码

const p1 = new Promise((resolve, reject) => {
  resolve();
  console.log("1");
}).then(() => {
  console.log("2");
});

我们的思路就来了:

  1. promise 是一个类
  2. 初始化的时候传入的是一个函数, 函数里面有两个参数, resolve, reject
  3. 这说明类的构造器中有这两个函数声明
  4. 实例化后的每一个 promise 都有自己的状态, 说明有实例属性 state

想到这里马上开始重写, 完成以上 1\2\3\4 点

// 1. promise 是一个类
class MyPromise {
  constructor(executor) {
    // 4. 实例化后的每一个 promise 都有自己的状态, 说明有实例属性 state
    this.state = "pending";
    // 3. 这说明类的构造器中有这两个函数声明
    let resolve = () => {};
    let reject = () => {};
    // 2. 初始化的时候传入的是一个函数, 函数里面有两个参数, resolve, reject
    executor(resolve, reject);
  }
}
let p = new MyPromise((resolve, reject) => {});

接下来我们知道 resolve 和 reject 函数中有参数 value 和 reason
所以我们马上就又有思路了:

  1. 执行器函数中调用 resolve 会传入参数, reject 同样也是
  2. 需要一个 then 方法来链式调用, 所以 then 方法是一个原型方法
  3. then 方法中有两个参数, 一个成功回调一个失败回调

完成以上 5\6\7 点

class MyPromise {
  constructor(executor) {
    this.state = "pending";
    // 5. 执行器函数中调用 resolve 会传入参数, reject 同样也是
    let resolve = (value) => {};
    let reject = (reason) => {};

    executor(resolve, reject);
  }
  // 6. 需要一个 then 方法来链式调用, 所以 then 方法是一个原型方法
  // 7. then 方法中有两个参数, 一个成功回调一个失败回调
  then(onFulfilled, onRejected) {}
}
let p = new MyPromise((resolve, reject) => {});

我们知道只有在构造器函数中调用了 resolve 或者 reject 方法后才会进入 then 方法, 同时我们也知道一旦调用 resolve 或者 reject 方法就会改变 promise 实例的状态, 所以我们接下来的思路就是:

  1. 调用 resolve 或者 reject 方法后改变状态
  2. 成功或者失败回调需要拿到对应的 resolve 和 reject 函数中的参数, 这需要我们在实例上新增相应的属性存储
  3. 在 resolve 和 reject 方法中要赋值给实例属性
  4. 在 then 方法中判断状态调用方法

完成以上 8\9\10\11 点

class MyPromise {
  constructor(executor) {
    this.state = "pending";
    // 9. 成功或者失败回调需要拿到对应的 resolve 和 reject 函数中的参数, 这需要我们在实例上新增相应的属性存储
    this.value = undefined;
    this.reason = undefined;
    let resolve = (value) => {
      // 8. 调用 resolve 或者 reject 方法后改变状态
      this.state = "fulfilled";
      // 10. 在 resolve 和 reject 方法中要赋值给实例属性
      this.value = value;
    };
    let reject = (reason) => {
      // 8. 调用 resolve 或者 reject 方法后改变状态
      this.state = "rejected";
      // 10. 在 resolve 和 reject 方法中要赋值给实例属性
      this.reason = reason;
    };

    executor(resolve, reject);
  }
  then(onFulfilled, onRejected) {
    // 11. 在 then 方法中判断状态调用方法
    if (this.state === "fulfilled") {
      onFulfilled(this.value);
    }
    if (this.state === "rejected") {
      onRejected(this.reason);
    }
  }
}
let p = new MyPromise((resolve, reject) => {});

好完成到这里的时候, 不涉及异步的操作我们已经完成了, 现在我们尝试使用一下我们重写的 promise

const p1 = new MyPromise2((resolve, reject) => {
  resolve(2);
  console.log("1");
}).then((value) => {
  console.log(value);
});

在这里插入图片描述

接下来考虑异步的问题, 即如果执行器函数中存在异步的话, 进入 then 方法时状态其实还是 pending , 所以需要考虑当进入 then 方法时状态为 pending 就是异步, 我们要将异步时候的回调函数保存起来当真正执行的时候再调用 , 由于同一个 promise 可以多次调用 then 方法 , 所以需要用一个数组来保存所有可能的回调函数 , 我们从这出发 , 给出以下思路:

  1. 在实例上添加属性来保存成功回调和失败回调
  2. 在 then 方法中遇到 pending 状态就是有异步情况 , 真正的执行回调将不在这里发生 , 存到实例的属性上

完成以上 12\13 点

class MyPromise {
  constructor(executor) {
    this.state = "pending";
    this.value = undefined;
    this.reason = undefined;
    // 12. 在实例上添加属性来保存成功回调和失败回调
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];
    let resolve = (value) => {
      this.state = "fulfilled";
      this.value = value;
    };
    let reject = (reason) => {
      this.state = "rejected";
      this.reason = reason;
    };

    executor(resolve, reject);
  }
  then(onFulfilled, onRejected) {
    if (this.state === "fulfilled") {
      onFulfilled(this.value);
    }
    if (this.state === "rejected") {
      onRejected(this.reason);
    }
    // 13. 在 then 方法中遇到 pending 状态就是有异步情况, 真正的执行回调将不在这里发生, 存到实例的属性上
    if (this.state === "pending") {
      this.onFulfilledCallbacks.push(() => {
        onFulfilled(this.value);
      });
      this.onRejectedCallbacks.push(() => {
        onRejected(this.reason);
      });
    }
  }
}
let p = new MyPromise((resolve, reject) => {});

那么真正的回调函数执行到底在哪里呢? 我们来看一下一个出现了异步的情况代码, 看以下代码:

由于构造器函数中出现一个定时器, 所以会在 1 秒后才打印出 2

const p1 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve(2);
  }, 1000);
  console.log("1");
}).then((value) => {
  console.log(value);
});

上面这个代码中能执行回调函数的地方只有在 resolve 函数中了, 所以我们就又有思路了:

  1. 在 resolve 和 reject 方法中执行回调函数

完成以上 14 点

class MyPromise {
  constructor(executor) {
    this.state = "pending";
    this.value = undefined;
    this.reason = undefined;
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];
    let resolve = (value) => {
      this.state = "fulfilled";
      this.value = value;
      // 14. 在 resolve 和 reject 方法中执行回调函数
      this.onFulfilledCallbacks.forEach((fn) => fn());
    };
    let reject = (reason) => {
      this.state = "rejected";
      this.reason = reason;
      // 14. 在 resolve 和 reject 方法中执行回调函数
      this.onRejectedCallbacks.forEach((fn) => fn());
    };

    executor(resolve, reject);
  }
  then(onFulfilled, onRejected) {
    if (this.state === "fulfilled") {
      onFulfilled(this.value);
    }
    if (this.state === "rejected") {
      onRejected(this.reason);
    }
    if (this.state === "pending") {
      this.onFulfilledCallbacks.push(() => {
        onFulfilled(this.value);
      });
      this.onRejectedCallbacks.push(() => {
        onRejected(this.reason);
      });
    }
  }
}
let p = new MyPromise((resolve, reject) => {});

我们知道 promise 实例是可以链式调用的, 这意味每一个方法的最后都会返回一个新的 promise 来提供给下一次调用 promise 原型方法, 所以我们就考虑到在 then 方法中直接返回一个新的 promise 对象, 同时, 由于执行器函数执行是同步代码, 所以我们可以直接将 then 中的代码放入到新的 promise 中, 但是我们知道链式调用 then 方法时我们可以拿到上一次 then 返回的值, 所以在成功回调返回的值, 我们将再次使用新的 promise 中的 resolve 方法去调用, 以下就是这次的思路:

  1. 在 then 方法中新声明一个 promise 对象并返回, 将 then 方法中代码放入执行器函数中
  2. 将第一次 then 的回调的结果赋值给一个变量, 使用新声明的 promise 来调用 resolve 和 reject 方法

完成以上 15\16 点

class MyPromise {
  constructor(executor) {
    this.state = "pending";
    this.value = undefined;
    this.reason = undefined;
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];
    let resolve = (value) => {
      this.state = "fulfilled";
      this.value = value;
      this.onFulfilledCallbacks.forEach((fn) => fn());
    };
    let reject = (reason) => {
      this.state = "rejected";
      this.reason = reason;
      this.onRejectedCallbacks.forEach((fn) => fn());
    };

    executor(resolve, reject);
  }
  then(onFulfilled, onRejected) {
    // 15. 在 then 方法中新声明一个 promise 对象并返回, 将 then 方法中代码放入执行器函数中
    const p2 = new MyPromise((resolve, reject) => {
      let x;
      if (this.state === "fulfilled") {
        // 16. 将第一次 then 的回调的结果赋值给一个变量, 使用新声明的 promise 来调用 resolve 方法
        x = onFulfilled(this.value);
        resolve(x);
      }
      if (this.state === "rejected") {
        // 16. 将第一次 then 的回调的结果赋值给一个变量, 使用新声明的 promise 来调用 resolve 方法
        x = onRejected(this.reason);
        reject(x);
      }
      if (this.state === "pending") {
        this.onFulfilledCallbacks.push(() => {
          // 16. 将第一次 then 的回调的结果赋值给一个变量, 使用新声明的 promise 来调用 resolve 方法
          x = onFulfilled(this.value);
          resolve(x);
        });
        this.onRejectedCallbacks.push(() => {
          // 16. 将第一次 then 的回调的结果赋值给一个变量, 使用新声明的 promise 来调用 resolve 方法
          x = onRejected(this.reason);
          reject(x);
        });
      }
    });
    return p2;
  }
}
let p = new MyPromise((resolve, reject) => {});

好的这样就已经完成了链式调用的问题了, 但是现在又有一个新的问题了, 那就是如果第一次的回调函数返回的是一个 promise 对象呢? 那就需要对 x 进行判断和处理, 我们思路如下:

  1. 声明一个 resolvePromise 专门处理判断 x 的问题, 根据 promise A+ 规范, 返回的 promise 不能与新增的 promise 相同, 在 resolvePromise 方法中需要传入 p2 进行判断
  2. 由于 p2 此时没有初始化完毕所以无法调用, 使用定时器包裹延后执行
  3. 由于 resolvePromise 中可能会抛出错误, 所以使用 try.catch 包裹
  4. 同样的, 在构造器中, 对执行器函数使用 try.catch 包裹

完成以上 17\18\19\20 点

class MyPromise {
  constructor(executor) {
    this.state = "pending";
    this.value = undefined;
    this.reason = undefined;
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];
    let resolve = (value) => {
      this.state = "fulfilled";
      this.value = value;
      this.onFulfilledCallbacks.forEach((fn) => fn());
    };
    let reject = (reason) => {
      this.state = "rejected";
      this.reason = reason;
      this.onRejectedCallbacks.forEach((fn) => fn());
    };
    // 20. 同样的, 在构造器中, 对执行器函数使用 try.catch 包裹
    try {
      executor(resolve, reject);
    } catch (err) {
      reject(err);
    }
  }
  then(onFulfilled, onRejected) {
    const p2 = new MyPromise((resolve, reject) => {
      let x;
      if (this.state === "fulfilled") {
        // 18. 由于 p2 此时没有初始化完毕所以无法调用, 使用定时器包裹延后执行
        setTimeout(() => {
          // 19. 由于 resolvePromise 中可能会抛出错误, 所以使用 try.catch 包裹
          try {
            x = onFulfilled(this.value);
            // 17. 声明一个 resolvePromise 专门处理判断 x 的问题, 根据 promise A+ 规范, 返回的 promise 不能与新增的 promise 相同, 在 resolvePromise 方法中需要传入 p2 进行判断
            resolvePromise(p2, x, resolve, reject);
          } catch (err) {
            reject(err);
          }
        }, 0);
      }
      if (this.state === "rejected") {
        // 18. 由于 p2 此时没有初始化完毕所以无法调用, 使用定时器包裹延后执行
        setTimeout(() => {
          // 19. 由于 resolvePromise 中可能会抛出错误, 所以使用 try.catch 包裹
          try {
            x = onRejected(this.reason);
            // 17. 声明一个 resolvePromise 专门处理判断 x 的问题, 根据 promise A+ 规范, 返回的 promise 不能与新增的 promise 相同, 在 resolvePromise 方法中需要传入 p2 进行判断
            resolvePromise(p2, x, resolve, reject);
          } catch (err) {
            reject(err);
          }
        }, 0);
      }
      if (this.state === "pending") {
        this.onFulfilledCallbacks.push(() => {
          // 18. 由于 p2 此时没有初始化完毕所以无法调用, 使用定时器包裹延后执行
          setTimeout(() => {
            // 19. 由于 resolvePromise 中可能会抛出错误, 所以使用 try.catch 包裹
            try {
              x = onFulfilled(this.value);
              // 17. 声明一个 resolvePromise 专门处理判断 x 的问题, 根据 promise A+ 规范, 返回的 promise 不能与新增的 promise 相同, 在 resolvePromise 方法中需要传入 p2 进行判断
              resolvePromise(p2, x, resolve, reject);
            } catch (err) {
              reject(err);
            }
          }, 0);
        });
        this.onRejectedCallbacks.push(() => {
          // 18. 由于 p2 此时没有初始化完毕所以无法调用, 使用定时器包裹延后执行
          setTimeout(() => {
            // 19. 由于 resolvePromise 中可能会抛出错误, 所以使用 try.catch 包裹
            try {
              x = onRejected(this.reason);
              // 17. 声明一个 resolvePromise 专门处理判断 x 的问题, 根据 promise A+ 规范, 返回的 promise 不能与新增的 promise 相同, 在 resolvePromise 方法中需要传入 p2 进行判断
              resolvePromise(p2, x, resolve, reject);
            } catch (err) {
              reject(err);
            }
          }, 0);
        });
      }
    });
    return p2;
  }
}
// 17. 声明一个 resolvePromise 专门处理判断 x 的问题, 根据 promise A+ 规范, 返回的 promise 不能与新增的 promise 相同, 在 resolvePromise 方法中需要传入 p2 进行判断
function resolvePromise(p2, x, resolve, reject) {
  if (p2 === x) {
    return reject(new Error("Error: p2 is x"));
  }
}
let p = new MyPromise((resolve, reject) => {});

接下来我们要继续完善 resolvePromise 中的逻辑, 我们需要判断 x 到底是不是 promise 对象, 我们使用是否是带 then 属性的对象来判断, 是就是, 不是就不是, 当是 promise 对象后, 直接调用 x 的 then 方法, 在成功回调和失败回调中分别调用 resolvePromise 传入的 resolve 和 reject

  1. x 需要是个对象或者函数
  2. x 为普通数据类型就直接 resolve
  3. 获取 x 的 then 属性, 是函数才是 promise 对象
  4. 获取 x.then 可能会报错, 使用 try.catch 包裹

完成以上 21\22\23\24 点

class MyPromise {
  constructor(executor) {
    this.state = "pending";
    this.value = undefined;
    this.reason = undefined;
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];
    let resolve = (value) => {
      this.state = "fulfilled";
      this.value = value;
      this.onFulfilledCallbacks.forEach((fn) => fn());
    };
    let reject = (reason) => {
      this.state = "rejected";
      this.reason = reason;
      this.onRejectedCallbacks.forEach((fn) => fn());
    };
    try {
      executor(resolve, reject);
    } catch (err) {
      reject(err);
    }
  }
  then(onFulfilled, onRejected) {
    const p2 = new MyPromise((resolve, reject) => {
      let x;
      if (this.state === "fulfilled") {
        setTimeout(() => {
          try {
            x = onFulfilled(this.value);
            resolvePromise(p2, x, resolve, reject);
          } catch (err) {
            reject(err);
          }
        }, 0);
      }
      if (this.state === "rejected") {
        setTimeout(() => {
          try {
            x = onRejected(this.reason);
            resolvePromise(p2, x, resolve, reject);
          } catch (err) {
            reject(err);
          }
        }, 0);
      }
      if (this.state === "pending") {
        this.onFulfilledCallbacks.push(() => {
          setTimeout(() => {
            try {
              x = onFulfilled(this.value);
              resolvePromise(p2, x, resolve, reject);
            } catch (err) {
              reject(err);
            }
          }, 0);
        });
        this.onRejectedCallbacks.push(() => {
          setTimeout(() => {
            try {
              x = onRejected(this.reason);
              resolvePromise(p2, x, resolve, reject);
            } catch (err) {
              reject(err);
            }
          }, 0);
        });
      }
    });
    return p2;
  }
}
function resolvePromise(p2, x, resolve, reject) {
  if (p2 === x) {
    return reject(new Error("Error: p2 is x"));
  }
  // 21. x 需要是个对象或者函数
  if ((typeof x === "object" && x !== null) || typeof x === "function") {
    // 24. 获取 x.then 可能会报错, 使用 try.catch 包裹
    try {
      // 23. 获取 x 的 then 属性, 是函数才是 promise 对象
      let then = x.then;
      if (typeof then === "function") {
        then.call(
          x,
          (y) => {
            resolve(y);
          },
          (r) => {
            reject(r);
          }
        );
      } else {
        resolve(x);
      }
    } catch (err) {
      reject(err);
    }
  } else {
    // 22. x 为普通数据类型就直接 resolve
    resolve(x);
  }
}
let p = new MyPromise((resolve, reject) => {});

好, 这样看起来已经很完美了, 返回的是 promise 对象我们也能解决了, 但是紧接着又有一个问题, 要是里面的 promise 再返回一个 promise 呢? 我们就想到用递归来解决这个问题, 同时我们还要解决一个问题, 那就是一个 promise 的执行器函数中只会执行遇到的第一个 resolve 或者 reject 方法, 我们用新增变量来避免重复调用

  1. 当每次返回的都是 promise 对象时, 我们递归调用判断 x 的类型的函数
  2. 声明一个变量来防止构造器函数中重复执行 resolve 和 reject 方法
  3. 每次进入 then 方法时, 如果没有参数, 就直接返回一个返回参数的函数
class MyPromise {
  constructor(executor) {
    this.state = "pending";
    this.value = undefined;
    this.reason = undefined;
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];
    let resolve = (value) => {
      this.state = "fulfilled";
      this.value = value;
      this.onFulfilledCallbacks.forEach((fn) => fn());
    };
    let reject = (reason) => {
      this.state = "rejected";
      this.reason = reason;
      this.onRejectedCallbacks.forEach((fn) => fn());
    };
    try {
      executor(resolve, reject);
    } catch (err) {
      reject(err);
    }
  }
  then(onFulfilled, onRejected) {
    // 27. 每次进入 then 方法时, 如果没有参数, 就直接返回一个返回参数的函数
    onFulfilled =
      typeof onFulfilled === "function" ? onFulfilled : (value) => value;
    onRejected =
      typeof onRejected === "function"
        ? onRejected
        : (reason) => {
            throw reason;
          };
    const p2 = new MyPromise((resolve, reject) => {
      let x;
      if (this.state === "fulfilled") {
        setTimeout(() => {
          try {
            x = onFulfilled(this.value);
            resolvePromise(p2, x, resolve, reject);
          } catch (err) {
            reject(err);
          }
        }, 0);
      }
      if (this.state === "rejected") {
        setTimeout(() => {
          try {
            x = onRejected(this.reason);
            resolvePromise(p2, x, resolve, reject);
          } catch (err) {
            reject(err);
          }
        }, 0);
      }
      if (this.state === "pending") {
        this.onFulfilledCallbacks.push(() => {
          setTimeout(() => {
            try {
              x = onFulfilled(this.value);
              resolvePromise(p2, x, resolve, reject);
            } catch (err) {
              reject(err);
            }
          }, 0);
        });
        this.onRejectedCallbacks.push(() => {
          setTimeout(() => {
            try {
              x = onRejected(this.reason);
              resolvePromise(p2, x, resolve, reject);
            } catch (err) {
              reject(err);
            }
          }, 0);
        });
      }
    });
    return p2;
  }
}
function resolvePromise(p2, x, resolve, reject) {
  // 26. 声明一个变量来防止构造器函数中重复执行 resolve 和 reject 方法
  let called = false;
  if (p2 === x) {
    return reject(new Error("Error: p2 is x"));
  }
  if ((typeof x === "object" && x !== null) || typeof x === "function") {
    try {
      let then = x.then;
      if (typeof then === "function") {
        then.call(
          x,
          (y) => {
            if (called) return;
            called = true;
            // 25. 当每次返回的都是 promise 对象时, 我们递归调用判断 x 的类型的函数
            resolvePromise(p2, y, resolve, reject);
          },
          (r) => {
            if (called) return;
            called = true;
            reject(r);
          }
        );
      } else {
        resolve(x);
      }
    } catch (err) {
      if (called) return;
      called = true;
      reject(err);
    }
  } else {
    resolve(x);
  }
}
let p = new MyPromise((resolve, reject) => {});

总结

ok 这样就重写完了最基本的 promise , 之后我们再来补充上 promise 上面的方法包括 catch \ race \ all 等等

我觉得虽然挺难的 ， 但是如果你有思路的话，顺着思路写下来其实是没问题的

结束

学习之路漫漫啊~

不可名状邵雅虎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用Promise解决多个异步Ajax请求导致的代码嵌套问题(完美解决方案)
10-20
第一个请求的响应更新了`someData.attr1`，而第二个请求依赖于这个值。如果按照原始顺序执行，可能会出现`action2`先于`action1`完成，导致`someData.attr1`未被正确设置。此外，两个请求的错误处理逻辑也存在重复。...
如何将Node.js中的回调转换为Promise
12-16
例如，Node.js中的`fs.readFile()`函数用于读取文件，它接受一个回调函数作为第三个参数，当文件读取完成后，回调函数会被调用，处理读取到的数据或错误。在下面的例子中，我们展示了如何使用回调读取文件： ```...
Promise笔记promise重写
qq_30258495的博客
08-21 459
util.promisify()参数为一个错误优先的回调函数，即(err,data)=>{}状态改变，为他所定义多有回调都会执行（就是多个。一个对象只能改变一次状态一般成功的结果是。只能由pending变为成功或者失败。不管执行哪个回调都是这4点。
ES6-22【Promise源码重写】
小管打天下的博客
05-11 291
一、Promise源码实现
Promise的运行原理以及重写Promise内置类
mister、奎
07-19 960
1.为什么用？ 假设我们需要发三次请求A,B,C,B请求需要用到A请求回来的数据，C需要用到B请求回来的数据，怎么发送？ $.ajax({ url:'jsonA.json', success(data) { $.ajax({ url:'jsonB.json', success(data) { ...
重写promise 写一个类似于promise的方法
致我逝去的青春的博客
03-05 551
1.重写promise 写一个类似于promise的方法 // promise 内置类 //重写promise 写一个类似于promise的方法 class MyPromise{ constructor(excutor){//当new Mypromise constructor执行l //this -》Promise 的实例 ...
[JS]把函数改写为Promise
林毅洋
08-14 5112
把函数改写为PromiseJSvar 选择函数 = function(str,success,faild){ if(confirm(str)){ if(typeof success == 'function'){ success(); } }else{ if(typeof faild == 'function')
command.ts-rewrite：command.ts重写版本
02-11
重写这一部分代码可能涉及到以下几个方面的改进： 1. **类型检查**：TypeScript的一大优势在于其静态类型系统。重写`command.ts`为`command.ts-rewrite`可能引入了更严格的类型检查，有助于发现潜在的类型错误，...
async-modular:当然，用于教育的caolanasync的重写
05-18
// 第一个任务 callback(null, 'One'); }, function(callback) { // 第二个任务，'One'是上一个任务的结果 callback(null, 'Two'); } ], function(err, results) { // 结果数组：['One', 'Two'] }); ``` 2....
node_sherpa:在 Node 中重写的 Redditsherpa gem - 正在进行中
06-13
本篇文章将探讨一个正在进行的项目——node_sherpa，它是对Ruby gem Redditsherpa的重写，目标是将这一功能强大的Reddit API客户端移植到Node.js环境中。这不仅展示了JavaScript在服务器端的强大能力，还体现了跨...
Promise - （四）Promise其他方法实现
伏城之外的博客
12-05 775
(5条消息) 随笔-对Promise的深入理解_qfc_128220的博客-CSDN博客 前面完成了Promise构造函数和Promise.prototype.then方法的重写 但是还有如下方法没有重写 Promise.prototype.catch Promise.prototype.finally Promise.resolve Promise.reject Promise.all Promise.race 这里我们先用es6 class语法将之前重写Promise构造函数和Pr
node.js学习笔记--HTTP之Promise重写小爬虫
sriting的博客
03-20 446
注：此博客是在学习进击Node.js基础（一）这门课程时的学习笔记，感谢Scott老师的课程。 一、使用Promise处理异步、嵌套 1. 用传统的回调来按顺序执行小球动画 <!doctype> <html> <head> <title>Promise animation</title> <style&...
Webkit简介以及工作流程
读心悦
07-10 310
WebKit是一个开源的浏览器引擎，最初由苹果公司基于KHTML（K Desktop Environment的HTML渲染引擎）开发，并广泛应用于Safari浏览器。随着时间的推移，WebKit也被其他多款浏览器和应用所采用，成为Web技术生态中的重要一员。WebKit的核心功能包括解析HTML、CSS、JavaScript等网页内容，并将其渲染为可视化的网页页面。它主要由WebCore（负责HTML解析、CSS样式计算和布局）和JavaScriptCore（负责JavaScript解释执行）两大部分组成。
vue引入sm-crypto通过sm4对文件进行加解密，用户输入密码
最新发布
cc1314_工作、学习有感
07-12 185
通过sm4对文件进行加解密，用户输入密码
vue2 、 vue3首屏优化，减少白屏时间
m0_56104994的博客
07-09 305
vue2、vue3首屏优化,减少白屏时间
前端 JS 经典：迭代器
weixin_64684095的博客
07-12 162
如果在最后一个值返回后再调用 next()方法，那么返回的对象中属性 done 的值为 true，属性 value 则包含迭代器最终返回的值（如果没有相关数据则返回 undefined）。可迭代对象具有 Symbol.iterator 属性，通过指定的函数可以返回一个作用于附属对象的迭代器。JavaScript 中有一些内置的可迭代对象，如数组、字符串、集合（Set）、映射（Map）等，它们都具有默认的迭代器。在 JavaScript 中，迭代器是一个对象，它定义了一个序列，并在终止时可能返回一个返回值。
javascript高级部分笔记
喵喵的博客
07-09 1267
javascript高级部分 Function方法 与 函数式编程 call 语法：call([thisObj[,arg1[, arg2[, [,.argN]]]]]) 定义：调用一个对象的一个方法，以另一个对象替换当前对象。 说明：call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。 如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。 let myName = 'goudan
什么是vue的计算属性
weixin_56187723的博客
07-12 190
Vue的计算属性（Computed Properties）是Vue组件中的一个非常强大的功能，它们允许组件基于它们的响应式依赖进行缓存的派生值。只有当相关响应式依赖发生改变时，计算属性才会重新求值。这意味着只要依赖的响应式数据没有发生变化，多次访问计算属性会立即返回之前的计算结果，而不必再次执行计算函数。
重写promise.all
10-19
重写Promise.all的目的是为了解决原生Promise.all存在的两个问题：传递的参数可能不是Promise类型，可能不存在then方法；如果中间发生错误，应该直接返回错误，不执行后面操作。下面是一个改造版本的实现： Promise...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值