手写代码实现符合A+规范的Promise，完美通过测试

最新推荐文章于 2023-03-01 22:28:51 发布
最新推荐文章于 2023-03-01 22:28:51 发布
阅读量562 收藏
点赞数 1
分类专栏： 前端 文章标签： javascript es6 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42250413/article/details/115728991
版权

目录

前言

在学习过程中建议配合参考MDN promise和Promise/A+规范(中文翻译)、Promise/A+规范(中文翻译)，可以使用MDN中案例或者promises-aplus-tests来测试。
我会在最底下放promises-aplus-tests的测试方法和完整代码。

实现Promise

构造函数

const PENDING = 'pending'
const FULFILLED = 'fulfilled'
const REJECTED = 'rejected'

class Promise {
  constructor(executor) {
    //状态
    this.status = PENDING;
    //成功值
    this.value = undefined;
    //失败值
    this.reason = undefined;
    //then回调数组
    this.onResolveCallBacks = []
    this.onRejectCallBacks = []

    const resolve = (value) => {
      if (this.status === PENDING) {
        this.status = FULFILLED
        this.value = value
  
        //执行then resolve回调方法
        this.onResolveCallBacks.forEach(fn => fn())
      }
    };
    const reject = (reason) => {
      if (this.status === PENDING) {
        this.status = REJECTED
        this.reason = reason
  
        //执行then reject回调方法
        this.onRejectCallBacks.forEach(fn => fn())
      }
    };

    try {
      executor(resolve, reject)
    } catch (error) {
      reject(error)
    } 
  }

Promise.prototype.then方法

then() 方法返回一个 Promise 。它最多需要有两个参数：Promise 的成功和失败情况的回调函数。返回Promise可以进行链式调用。
then方法是最重要也是最难的地方，弄懂了其他都简单了。

then(onFulfilled, onRejected) {
  //如果没有回调函数则将上个resolve/reject结果返回给下一个
  onFulfilled =
    typeof onFulfilled === "function" ? onFulfilled : (value) => value;
  onRejected =
    typeof onRejected === "function"
      ? onRejected
      : (reason) => {
          throw reason;
        };
  //返回promise对象
  let promise2 = new Promise((resolve, reject) => {
    const resolveMicrotask = () => {
      queueMicrotask(() => {
        try {
          let x = onFulfilled(this.value);
          resolvePromise(promise2, x, resolve, reject);
        } catch (error) {
          reject(error);
        }
      });
    };
    const rejectMicrotask = () => {
      queueMicrotask(() => {
        try {
          let x = onRejected(this.reason);
          resolvePromise(promise2, x, resolve, reject);
        } catch (error) { 
          reject(error);
        }
      });
    };
    if (this.status === FULFILLED) {
      //异步（微任务）调用回调函数
      resolveMicrotask();
      return;
    }
    if (this.status === REJECTED) {
      rejectMicrotask();
      return;
    }
    if (this.status === PENDING) {
      this.onResolveCallBacks.push(resolveMicrotask);
      this.onRejectCallBacks.push(rejectMicrotask);
      return;
    }
  });

  return promise2;
}
/**
 * Promise解决程序
 */
const resolvePromise = (promise2, x, resolve, reject) => {
  if (promise2 === x) {
    reject(new TypeError("Chaining cycle detected for promise #<Promise>"));
  }
  //x是函数或者对象
  else if ((typeof x === "object" && x != null) || typeof x === "function") {
    //x.then取出或者调用抛出异常返回错误
    let called = false; // 标记 resolve或reject只执行一次,优先采用首次调用
    try {
      let then = x.then;
      //如果这个值是thenable（即带有"then" 方法），返回的promise会“跟随”这个thenable的对象，采用它的最终状态
      if (typeof then === "function") {
        then.call(x,
          (y) => {
            if (called) return;
            called = true;
            //thenable 的y可能会返回promise 所有再进一步处理
            return resolvePromise(promise2, y, resolve, reject);
          },
          (r) => {
            if (called) return;
            called = true;
            reject(r);
          }
        );
      }
      //then不是函数返回x
      else {
        resolve(x);
      }
    } catch (error) {
      //若promise已解决或拒绝则忽略异常
      if (called) return;
      reject(error);
    }
  }
  //x不是函数或者对象
  else {
    resolve(x);
  }
};

Promise.prototype.catch()方法

catch() 方法返回一个Promise ，并且处理拒绝的情况。它的行为与调用Promise.prototype.then(undefined, onRejected) 相同。

//等于只有onRejected的then
catch (onRejected) {
   return this.then(null, onRejected)
 }

Promise.prototype.finally()方法

  • finally() 方法返回一个Promise。在promise结束时，无论结果是fulfilled或者是rejected，都会执行指定的回调函数。这为在Promise是否成功完成后都需要执行的代码提供了一种方式。
  • finally的回调函数中不接收任何参数，它仅用于无论最终结果如何都要执行的情况。
  • finally的回调函数如果返回一个resultPromise，那么Promise的结果根据resultPromise的执行结果来决定，否则回上一个Promise的执行结果
finally(callback) {
  //如果回调函数返回promise，则返回此promise的resolve/reject结果
  //如果回调函数不返回promise,则返回上一个promise的resolve/reject结果
  return this.then(value => {
    return Promise.resolve(callback()).then(()=>value)
  }, reason => {
    return Promise.reject(callback()).then(()=>reason)
  })
}

resolve()方法

Promise.resolve(value)方法返回一个以给定值解析后的Promise 对象。

  • 如果这个值是一个 promise ，那么将返回这个 promise
  • 如果这个值是thenable（即带有"then" 方法），返回的promise会“跟随”这个thenable的对象，采用它的最终状态
  • 否则返回的promise将以此值完成。
resolve(value) {
  //如果这个值是一个 promise ，那么将返回这个 promise
  if (value instanceof Promise) {
    return value
    //如果这个值是thenable（即带有"then" 方法），返回的promise会“跟随”这个thenable的对象，采用它的最终状态；
  } else if (value && value.then && typeof value.then === 'function') {
    let p = new Promise((resolve, reject) => {
      resolve()
    })
    p.then = value.then
    return p
  } else {
    return new Promise((resolve, reject) => {
      resolve(value)
    })
  }
}

reject()方法

Promise.reject()方法返回一个带有拒绝原因的Promise对象。

reject(reason) {
  return new Promise((resolve, reject) => {
    reject(reason)
  })
}

all()方法

Promise.all() 方法接收一个promise的iterable类型（注：Array，Map，Set都属于ES6的iterable类型）的输入，并且只返回一个Promise实例， 那个输入的所有promise的resolve回调的结果是一个数组。

  • 如果传入的参数是一个空的可迭代对象，则会同步地返回一个已完成（already resolved）状态的 Promise。
  • 如果传入的参数不包含任何 promise，则返回一个异步完成（asynchronously resolved） Promise。
  • 其它情况下返回一个处理中（pending）的Promise。这个返回的 promise 之后会在所有的 promise 都完成或有一个 promise 失败时异步地变为完成或失败。返回值将会按照参数内的 promise 顺序排列，而不是由调用 promise 的完成顺序决定。
all(array) {
  //判断iterator类型
  if (typeof array[Symbol.iterator] !== 'function') {
    throw (new TypeError(`${array} is not iterable`))
  }
  let resultArr = []
  let flag = 0
  
  return new Promise((resolve, reject) => {
  	//空迭代时同步返回完成状态的Promise
    if (array.length === 0) {
      resolve(array)
      return
    }
    const processResultByKey = (value, index) => {
      resultArr[index] = value
      flag++
      //所有处理完返回成功结果
      if (flag === array.length) {
        resolve(resultArr)
      }
    }
    //遍历执行
    for (let i = 0; i < array.length; i++) {
      let item = array[i]
      if (item instanceof Promise) {
        item.then(r => {
          processResultByKey(r, i)
        }, e => {
          //如果有任何一个promise返回reject，则 all直接返回reject
          reject(e)
        })
      } else {
        //如果不是promise 则异步返回
        queueMicrotask(() => {
          processResultByKey(item, i)
        });
      }
    }
  })
}

allSettled()方法

Promise.allSettled()方法返回一个在所有给定的promise都已经fulfilled或rejected后的promise，并带有一个对象数组，每个对象表示对应的promise结果。

allSettled(array) {
  //判断iterator类型
  if (typeof array[Symbol.iterator] !== 'function') {
    throw (new TypeError(`${array} is not iterable`))
  }
  let resultArr = []
  let flag = 0
  return new Promise((resolve, reject) => {
    if (array.length === 0) {
      resolve(array)
      return
    }
    const processResultByKey = (item, index, type) => {
      //结果返回对象数组
      if (type === 1) {
        resultArr[index] = {
          status: item.status,
          value: item.value
        }
      } else {
        resultArr[index] = {
          status: item.status,
          reason: item.reason
        }
      }
      flag++
      if (flag === array.length) {
        resolve(resultArr)
      }
    }
    for (let i = 0; i < array.length; i++) {
      let item = array[i]
      if (item instanceof Promise) {
        item.then(() => {
          processResultByKey(item, i, 1)
        }, () => {
          processResultByKey(item, i, 2)
        })
      } else {
        let p = Promise.resolve(item)
        p.then(() => {
          processResultByKey(p, i, 1)
        })
      }
    }
  })
}

测试代码

const promise1 = Promise.resolve(3);
const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, 'foo'));
const promises = [promise1, promise2];

Promise.allSettled(promises).then((results) => {
  console.log(results);
});

在这里插入图片描述

any()方法

Promise.any() 接收一个Promise可迭代对象，只要其中的一个 promise 成功，就返回那个已经成功的 promise 。

  • 如果传入的参数是一个空的可迭代对象, 这个方法将会同步返回一个已经完成的 promise。
  • 如果传入的任何一个 promise 已成功, 或者传入的参数不包括任何 promise, 那么 Promise.any 返回一个异步成功的 promise。
  • 如果所有传入的 promises 都失败, Promise.any 将返回异步失败，和一个 AggregateError 对象，它继承自 Error，有一个 error 属性，属性值是由所有失败值填充的数组。
any(array) {
  //判断iterator类型
  if (typeof array[Symbol.iterator] !== 'function') {
    throw (new TypeError(`${array} is not iterable`))
  }
  let resultArr = []
  let flag = 0
  return new Promise((resolve, reject) => {
    if (array.length === 0) {
      reject(array)
      return
    }
    const processResultByKey = (value, index) => {
      resultArr[index] = value
      flag++
      if (flag === array.length) {
        reject(new AggregateError(resultArr,'All promises were rejected'))
      }
    }
    for (let i = 0; i < array.length; i++) {
      let item = array[i]
      if (item instanceof Promise) {
        item.then(r => {
          //如果有任何一个promise返回resolve，则all直接返回resolve
          resolve(r)
        }, e => {
          processResultByKey(e, i)
        })
      } else {
        //如果不是promise 则异步返回
        queueMicrotask(() => {
          processResultByKey(item, i)
        });
      }
    }
  })
}

race()方法

Promise.race(iterable) 方法返回一个 promise，一旦迭代器中的某个promise解决或拒绝，返回的 promise就会解决或拒绝。

  • 它可以是完成（ resolves），也可以是失败（rejects），这要取决于第一个完成的方式是两个中的哪个。
  • 如果传的迭代是空的，则返回的 promise 将永远等待。
  • 如果迭代包含一个或多个非承诺值和/或已解决/拒绝的承诺，则 race 将解析为迭代中找到的第一个值。
race(array) {
  //判断iterator类型
  if (typeof array[Symbol.iterator] !== 'function') {
    throw (new TypeError(`${array} is not iterable`))
  }
  return new Promise((resolve, reject) => {
    if (array.length === 0) {
      return
    }
    for (let i = 0; i < array.length; i++) {
      let item = array[i]
      if (item instanceof Promise) {
        item.then(r => {
          resolve(r)
        }, e => {
          //如果有任何一个promise返回reject，则all直接返回reject
          reject(e)
        })
      } else {
        //如果不是promise 则异步返回
        queueMicrotask(() => {
          resolve(r)
        });
      }
    }
  })
}
}

测试

使用promises-aplus-tests库进行测试
1.安装

yarn add promises-aplus-tests

2.在package.json中加入脚本

"scripts": {
    "testPromise": "promises-aplus-tests /promise.js"
  },

3.在promise.js中插入以下代码

Promise.defer = Promise.deferred = function() {
  let deferred = {};

  deferred.promise = new Promise((resolve, reject) => {
    deferred.resolve = resolve;
    deferred.reject = reject;
  });
  return deferred;
};

module.exports = Promise;

4.结果
通过全部测试
在这里插入图片描述

完整代码

const PENDING = "pending";
const FULFILLED = "fulfilled";
const REJECTED = "rejected";

class Promise {
  constructor(executor) {
    //状态
    this.status = PENDING;
    //成功值
    this.value = undefined;
    //失败值
    this.reason = undefined;
    //then回调数组
    this.onResolveCallBacks = [];
    this.onRejectCallBacks = [];

    const resolve = (value) => {
      if (this.status === PENDING) {
        this.status = FULFILLED;
        this.value = value;

        //执行then resolve回调方法
        this.onResolveCallBacks.forEach((fn) => fn());
      }
    };
    const reject = (reason) => {
      if (this.status === PENDING) {
        this.status = REJECTED;
        this.reason = reason;

        //执行then reject回调方法
        this.onRejectCallBacks.forEach((fn) => fn());
      }
    };

    try {
      executor(resolve, reject);
    } catch (error) {
      reject(error);
    }
  }

  then(onFulfilled, onRejected) {
    //如果没有回调函数则将上个resolve/reject结果返回给下一个
    onFulfilled =
      typeof onFulfilled === "function" ? onFulfilled : (value) => value;
    onRejected =
      typeof onRejected === "function"
        ? onRejected
        : (reason) => {
            throw reason;
          };
    //返回promise对象
    let promise2 = new Promise((resolve, reject) => {
      const resolveMicrotask = () => {
        queueMicrotask(() => {
          try {
            let x = onFulfilled(this.value);
            resolvePromise(promise2, x, resolve, reject);
          } catch (error) {
            reject(error);
          }
        });
      };
      const rejectMicrotask = () => {
        queueMicrotask(() => {
          try {
            let x = onRejected(this.reason);
            resolvePromise(promise2, x, resolve, reject);
          } catch (error) { 
            reject(error);
          }
        });
      };
      if (this.status === FULFILLED) {
        //异步（微任务）调用回调函数
        resolveMicrotask();
        return;
      }
      if (this.status === REJECTED) {
        rejectMicrotask();
        return;
      }
      if (this.status === PENDING) {
        this.onResolveCallBacks.push(resolveMicrotask);
        this.onRejectCallBacks.push(rejectMicrotask);
        return;
      }
    });

    return promise2;
  }
  //等于只有onRejected的then
  catch(onRejected) {
    return this.then(null, onRejected);
  }

  finally(callback) {
    //如果回调函数返回promise，则返回此promise的resolve/reject结果
    //如果回调函数不返回promise,则返回上一个promise的resolve/reject结果
    return this.then(
      (value) => {
        return Promise.resolve(callback()).then(() => value);
      },
      (reason) => {
        return Promise.reject(callback()).then(() => reason);
      }
    );
  }

  static resolve(value) {
    //如果这个值是一个 promise ，那么将返回这个 promise
    if (value instanceof Promise) {
      return value;
      //如果这个值是thenable（即带有"then" 方法），返回的promise会“跟随”这个thenable的对象，采用它的最终状态；
    } else if (value && value.then && typeof value.then === "function") {
      let p = new Promise((resolve) => {
        resolve();
      });
      p.then = value.then;
      return p;
    } else {
      return new Promise((resolve) => {
        resolve(value);
      });
    }
  }

  static reject(reason) {
    return new Promise((resolve, reject) => {
      reject(reason);
    });
  }

  static all(array) {
    //判断iterator类型
    if (typeof array[Symbol.iterator] !== "function") {
      throw new TypeError(`${array} is not iterable`);
    }
    let resultArr = [];
    let flag = 0;
    return new Promise((resolve, reject) => {
      if (array.length === 0) {
        resolve(array);
        return;
      }
      const processResultByKey = (value, index) => {
        resultArr[index] = value;
        flag++;
        if (flag === array.length) {
          resolve(resultArr);
        }
      };
      for (let i = 0; i < array.length; i++) {
        let item = array[i];
        if (item instanceof Promise) {
          item.then(
            (r) => {
              processResultByKey(r, i);
            },
            (e) => {
              //如果有任何一个promise返回reject，则all直接返回reject
              reject(e);
            }
          );
        } else {
          //如果不是promise 则异步返回
          queueMicrotask(() => {
            processResultByKey(item, i);
          });
        }
      }
    });
  }

  static allSettled(array) {
    //判断iterator类型
    if (typeof array[Symbol.iterator] !== "function") {
      throw new TypeError(`${array} is not iterable`);
    }
    let resultArr = [];
    let flag = 0;
    return new Promise((resolve) => {
      if (array.length === 0) {
        resolve(array);
        return;
      }
      const processResultByKey = (item, index, type) => {
        //结果返回对象数组
        if (type === 1) {
          resultArr[index] = {
            status: item.status,
            value: item.value,
          };
        } else {
          resultArr[index] = {
            status: item.status,
            reason: item.reason,
          };
        }
        flag++;
        if (flag === array.length) {
          resolve(resultArr);
        }
      };
      for (let i = 0; i < array.length; i++) {
        let item = array[i];
        if (item instanceof Promise) {
          item.then(
            () => {
              processResultByKey(item, i, 1);
            },
            () => {
              processResultByKey(item, i, 2);
            }
          );
        } else {
          let p = Promise.resolve(item);
          p.then(() => {
            processResultByKey(p, i, 1);
          });
        }
      }
    });
  }

  static any(array) {
    //判断iterator类型
    if (typeof array[Symbol.iterator] !== "function") {
      throw new TypeError(`${array} is not iterable`);
    }
    let resultArr = [];
    let flag = 0;
    return new Promise((resolve, reject) => {
      if (array.length === 0) {
        reject(array);
        return;
      }
      const processResultByKey = (value, index) => {
        resultArr[index] = value;
        flag++;
        if (flag === array.length) {
          reject(resultArr, "All promises were rejected");
        }
      };
      for (let i = 0; i < array.length; i++) {
        let item = array[i];
        if (item instanceof Promise) {
          item.then(
            (r) => {
              //如果有任何一个promise返回resolve，则all直接返回resolve
              resolve(r);
            },
            (e) => {
              processResultByKey(e, i);
            }
          );
        } else {
          //如果不是promise 则异步返回
          queueMicrotask(() => {
            processResultByKey(item, i);
          });
        }
      }
    });
  }

  //一旦迭代器中的某个promise解决或拒绝，返回的 promise就会解决或拒绝。
  static race(array) {
    //判断iterator类型
    if (typeof array[Symbol.iterator] !== "function") {
      throw new TypeError(`${array} is not iterable`);
    }
    return new Promise((resolve, reject) => {
      if (array.length === 0) {
        return;
      }
      for (let i = 0; i < array.length; i++) {
        let item = array[i];
        if (item instanceof Promise) {
          item.then(
            (r) => {
              resolve(r);
            },
            (e) => {
              //如果有任何一个promise返回reject，则all直接返回reject
              reject(e);
            }
          );
        } else {
          //如果不是promise 则异步返回
          queueMicrotask(() => {
            resolve(item);
          });
        }
      }
    });
  }
}

const resolvePromise = (promise2, x, resolve, reject) => {
  if (promise2 === x) {
    reject(new TypeError("Chaining cycle detected for promise #<Promise>"));
  }
  //x是函数或者对象
  else if ((typeof x === "object" && x != null) || typeof x === "function") {
    //x.then取出或者调用抛出异常返回错误
    let called = false; // 标记 resolve或reject只执行一次,优先采用首次调用
    try {
      let then = x.then;
      //如果这个值是thenable（即带有"then" 方法），返回的promise会“跟随”这个thenable的对象，采用它的最终状态
      if (typeof then === "function") {
        then.call(x,
          (y) => {
            if (called) return;
            called = true;
            //thenable 的y可能会返回promise 所有再进一步处理
            return resolvePromise(promise2, y, resolve, reject);
          },
          (r) => {
            if (called) return;
            called = true;
            reject(r);
          }
        );
      }
      //then不是函数返回x
      else {
        resolve(x);
      }
    } catch (error) {
      if (called) return;
      called = true;
      reject(error);
    }
  }
  //x不是函数或者对象
  else {
    resolve(x);
  }
};

Promise.defer = Promise.deferred = function() {
  let deferred = {};

  deferred.promise = new Promise((resolve, reject) => {
    deferred.resolve = resolve;
    deferred.reject = reject;
  });
  return deferred;
};

module.exports = Promise;
blingg
关注
专栏目录
手写实现promise以及promise.all和promise.race
qq_40619263的博客
05-15 3462
之前写的一个promise太多了，面试写下来的话。。。。emmm,所以在复习时又写一个简单的。 promise class Promsie { constructor(fn) { //三个状态 this.status = 'pending', this.resolve = undefined; this.reject = undefined; let resolve = value => {
手把手一行一行代码教你“手写Promise“，完美通过 Promises/A+ 官方872个测试用例
圆圆的 JavaScript 博客
12-20 1703
保姆级教程，看完还不懂的私聊我亲自教！
手写一个符合Promise A+规范的Promise
qq_43792937的博客
05-07 290
手写Promise 此为本人学习手写Promise的笔记，如有错误欢迎指出与讨论！ 参考文章：https://juejin.cn/post/6945319439772434469 前置知识点 宏任务与微任务 JS是单线程的，因此一些高耗时的操作将会导致进程阻塞。为解决这个问题，JS有两种任务的执行模式： 同步模式 和 异步模式 。 在异步模式下，创建的异步任务分为如下两种： 宏任务 和 微任务 。ES6规范中，宏任务（Macrotask）称为Task，是由宿主（浏览器或者Node）发起的，微任务（Micro
40分钟教你手写符合promise/A+规范的promise
qq_40511157的博客
11-21 642
我们都知道实现异步有四种方法：回调、promise、async await、generator和co。而我们这篇文章主要讲promise的实现，不涉及另外三个方法。然后在编码过程中也会严格遵守promise/A+规范。注意：最终的代码可能与文章中代码略微不同，请以最后的源代码为主。 一、promise的基本实现 首先，我们首先在promise.js中实现promise的以下四个状态。 解决（fulfill）：指一个 promise 成功时进行的一系列操作，如状态的改变、回调的执行。虽然规范中用 fulfi
手写实现promise，promise.all，race等的实现
Zyrzka的博客
03-29 364
一步一步，直接开始，yeah！ 1、首先来个架子，几大件先摆上，首先是状态三个，方法两个（resolve和reject），then方法。 //弄点变量当作状态，假装很高级的样子 const PENDING = 'pending' const FULFILLED = 'fulfilled' const REJECTED = 'rejected' // 开始了 class myPromise{ constructor(exec){ //状态初始化为pending this.state
手写一个Promise/A+,完美通过官方872个测试用例
dennis_jiang的博客
04-08 1658
前段时间我用两篇文章深入讲解了异步的概念和Event Loop的底层原理，然后还讲了一种自己实现异步的发布订阅模式： setTimeout和setImmediate到底谁先执行，本文让你彻底理解Event Loop 从发布订阅模式入手读懂Node.js的EventEmitter源码 本文会讲解另一种更现代的异步实现方案：Promise。Promise几乎是面试必考点，所以我们不能仅仅会用，还得知道...
按照 Promise/A+ 规范逐行注释并实现 Promise
Asheng 的前端笔记
04-01 331
现在前端越来越卷，不会手写 Promise 都不好意思面试了。这次我们一起按照 Promise/A+ 规范逐行注释并实现 Promise。
深入理解promise - promise实现(注释版 - 通过promise A+ test全部测试用例) promisify ES6中的promise promise使用
weixin_43758603的博客
11-12 2049
学习资料 promise 基础 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise promises A+规范 https://github.com/promises-aplus/promises-spec PromiseA+规范(中文) https://www.jianshu.com/p/e0f91e03d6c1 promises A+规范测试工具用例工具 htt
JavaScript手写代码总结
weixin_40643543的博客
06-08 339
1. 实现一个new操作符 new操作符做了这些事： • 它创建了一个全新的对象。 • 它会被执行[[Prototype]]（也就是__proto__）链接。 • 它使this指向新创建的对象。。 • 通过new创建的每个对象将最终被[[Prototype]]链接到这个函数的prototype对象上。 • 如果函数没有返回对象类型Object(包含Functoin, Array, Date, RegExg, Error)，那么new表达式中的函数调用将返回该对象引用。 function New(func)
手写promise race 方法
weixin_44098552的博客
11-11 953
race方法：顾名思义，Promse.race就是赛跑的意思，意思就是说，Promise.race([p1, p2, p3])里面哪个结果获得的快，就返回那个结果，不管结果本身是成功状态还是失败状态。 Promise.race = function (values) { return new Promise((resolve, reject) => { for (let i = 0; i < values.length; i++) { let p = values[i
参考 Promise/A+ 规范和测试用例手写 Promise
最新发布
无
03-01 542
这可能是手写promise较清晰的文章之一。由浅至深逐步分析了原生测试用例，以及相关Promise/A+规范。阅读上推荐以疑问章节为切入重点，对比Promise/A+规范与ECMAScript规范的内在区别与联系，确定怎样构建异步任务和创建promise实例。然后开始手写章节，过程中代码与测试可参考仓库。也试着回答以下关键问题。什么是广义对象？如何检验promise类型？promise与thenable两类型有何区别？Promise有多种社区规范，例如Promise/APromise/B。
PromiseA+规范之手写Promise
程邓楠的博客
11-04 4021
@[TOC](文章目录) 前言 1、Promise 的意义？ 在javascript的世界中，所有代码都是单线程执行的，由于这个“缺陷”，导致JavaScript的所有网络操作，浏览器事件，都必须是异步执行。Ajax可以解决这个问题，但是并不好复用。JQuery的链式调用同样可以解决，每次调用都会返回一个JQuery对象。为了更好的处理Promise 出现了，并且ECMAScript 对其进行了规范。 2、PromiseA+规范是什么？ 其实Promise规范有很多，如Promise/A，...
promise原理
楠姐的博客
03-03 3347
Promise 是使用回调函数，是把回调封装在了内部，使用上一直通过 then方法的链式调用，使得多层的回调嵌套看起来变成了同一层的，书写上以及理解上会更直观和简洁一些。 promise 实现原理 const PENDING = 'pending'; //初始状态 const FULFILLED = 'fulfilled'; // 成功状态 const REJECTED = 'rejected'; // 成功 function Promise(extutor){ let self = this; .
手写Promise.race方法
weixin_43484007的博客
06-08 527
Promise.race(iterable) 方法返回一个 promise，一旦迭代器中的某个 promise 解决或拒绝，返回的 promise 就会解决或拒绝。Promise.race(iterable);iterable :可迭代对象，类似Array。详见 iterable。一个待定的 Promise 只要给定的迭代中的一个 promise 解决或拒绝，就采用第一个 promise 的值作为它的值，从而异步地解析或拒绝（一旦堆栈为空）。该方法的参数是 Promise 实例数组, 然后其 then 注册
手写promise实现promiseA+规范，通过了官方的872个测试用例
程序员哆啦A梦，蓝胖子
05-14 744
地址 ⬇️github.com/webVueBlog/…promise是具有then行为符合本规范的方法或函数thenable是定义then方法的对象或函数value是任何合法的js值(undefined, thenable, promise)异常是使用throw语句抛出的值reason是一个值，表示一个承诺被拒绝的原因npm init -ynpm i promises-...
58同城python_Python实战计划爬虫作业第一周作业:爬58同城
weixin_39982017的博客
12-15 290
作业要求：作业要求1.1作业要求2作业要求更改说明：由于58同城页面改版，二手商品的个人卖家均改为了“转转”，因此，本次爬虫作业，无法屏蔽转转卖家，而是直接从转转卖家的页面爬取信息。我的代码from bs4 import BeautifulSoupimport requestsimport timeimport os'''本作业是完成爬取http://bj.58.com/shouji上的商品信息,...
手写一个完美符合 Promise/A+规范的Promise以及扩展 5 个静态方法、2 个实例方法
qq_41161604的博客
02-27 1138
目录写在前面Promise/A+ 规范Promise的使用实现自己的Promise状态then()实现异步的promisePromise 解决过程，resolvePromise函数Promise 解决过程resolvePromise函数的实现deferPromise 规范测试测试结果扩展Promise 5 个静态方法、2 个实例方法静态方法Promise.resolvePromise.rejectPromise.allPromise.allSettledPromise.race实例方法catchfinall
手写Promise系列之Promise.race
lyxgoodLucky的博客
12-12 1538
手写promise系列之Promise.race Promise.race(iterable) 方法返回一个 promise 迭代器中的promise谁先执行完毕就用谁的结果，那个率先改变的 Promise 实例的返回值，就传递那个给p的回调函数。
手写Promise/A+，通过872个测试用例解析异步实现
"本文主要介绍了如何手写一个符合Promise/A+规范的Promise实现，并通过官方872个测试用例进行验证。作者首先强调了理解Promise的底层原理对于面试和实际开发的重要性，然后提供了实现Promise的思路和相关代码示例。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值