面试算法题

promise

是什么

Promise 是用于处理异步操作的对象。它有三种状态：pending（进行中）、fulfilled（已成功）和 rejected（已失败）。我们可以手写一个简化版的 Promise，实现其基本功能。

实现思路：
Promise 构造函数接收一个执行器函数，该函数有两个参数 resolve 和 reject，用于改变 Promise 的状态。
then 方法用于注册回调函数，在 Promise的状态改变后执行。
使用状态机来管理 pending、fulfilled 和 rejected 状态。

实现

class MyPromise {hexp
  constructor(executor) {
    this.state = 'pending';   // 初始状态
    this.value = undefined;    // 成功的值
    this.reason = undefined;   // 失败的原因
    this.onFulfilledCallbacks = []; // 存储成功回调
    this.onRejectedCallbacks = [];  // 存储失败回调

    // resolve 函数
    const resolve = (value) => {
      if (this.state === 'pending') {
        this.state = 'fulfilled';   // 状态转为 fulfilled
        this.value = value;         // 传递成功的值
        this.onFulfilledCallbacks.forEach(fn => fn(this.value)); // 执行成功回调
      }
    };

    // reject 函数
    const reject = (reason) => {
      if (this.state === 'pending') {
        this.state = 'rejected';   // 状态转为 rejected
        this.reason = reason;      // 传递失败的原因
        this.onRejectedCallbacks.forEach(fn => fn(this.reason)); // 执行失败回调
      }
    };

    // 执行 executor，并捕获异常
    try {
      executor(resolve, reject);
    } catch (error) {
      reject(error);
    }
  }

  // then 方法
  then(onFulfilled, onRejected) {
    // 如果 `onFulfilled` 不是函数，默认返回 value
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
    // 如果 `onRejected` 不是函数，默认抛出 reason
    onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason };

    if (this.state === 'fulfilled') {
      onFulfilled(this.value);
    }

    if (this.state === 'rejected') {
      onRejected(this.reason);
    }

    if (this.state === 'pending') {
      this.onFulfilledCallbacks.push(onFulfilled);
      this.onRejectedCallbacks.push(onRejected);
    }
  }
}

// 测试 MyPromise
const promise = new MyPromise((resolve, reject) => {
  setTimeout(() => {
    resolve('Success!');
  }, 1000);
});

promise.then(
  value => console.log('Fulfilled:', value),
  reason => console.log('Rejected:', reason)
);

promise.all

是什么

Promise.all() 是一个用于并行处理多个 Promise 的方法，它接受一个包含多个 Promise 的可迭代对象，并返回一个新的 Promise。只有当所有 Promise 都成功时，这个新的 Promise 才会 resolve；如果其中任何一个 Promise 失败，Promise.all() 就会 reject，并返回第一个失败的 Promise 的原因。

实现

// promise.all
function promiseAll(promises){
  return new Promise((resolve,reject)=>{
    if(!Array.isArray(promises)) return reject(new TypeError('参数类型应该为数组'))
    if (promises.length==0) return resolve([])
    let resultArr = []
    let completedPromises = 0
    promises.forEach((promise,index)=>{
      Promise.resolve(promise)
      .then(result=>{
        resultArr[index] = result
        completedPromises ++
        if (completedPromises==promises.length) resolve(resultArr)
      })
      .catch(error=> reject(error))
    })
  })
}
// 示例
const p1 = Promise.resolve(3)
const p2 = new Promise((resolve) => setTimeout(resolve, 1000, 'foo'))
const p3 = Promise.resolve(42)

promiseAll([p1, p2, p3])
  .then((results) => console.log(results)) // 输出 [3, "foo", 42]
  .catch((err) => console.log(err))

promise.race

是什么

Promise.race() 方法会返回一个新的 Promise，一旦传入的 Promise 中有一个完成（无论是 resolved 还是 rejected），就会立即以那个 Promise 的结果（resolved 或 rejected）进行决议。

实现

function promiseRace(promises) {
  return new Promise((resolve, reject) => {
    if (!Array.isArray(promises)) {
      return reject(new TypeError('Argument must be an array'));
    }

    // 如果传入的数组为空，Promise 将永远不会 resolve 或 reject
    if (promises.length === 0) {
      return;  // 不返回任何内容，Promise 将保持 pending 状态
    }

    // 遍历每个 Promise
    promises.forEach(promise => {
      // 使用 Promise.resolve 将所有项处理为 Promise
      Promise.resolve(promise)
        .then(resolve)   // 一旦某个 Promise resolve，立即 resolve 结果
        .catch(reject);  // 一旦某个 Promise reject，立即 reject 错误
    });
  });
}

// 示例
const p1 = new Promise((resolve) => setTimeout(resolve, 500, "First"));
const p2 = new Promise((resolve) => setTimeout(resolve, 100, "Second"));
const p3 = new Promise((resolve, reject) => setTimeout(reject, 200, "Error"));

promiseRace([p1, p2, p3])
  .then(result => console.log(result))  // 输出 "Second" 因为 p2 最先完成
  .catch(err => console.log(err));