有关promise手撕代码（手写题）

1.Promise的实现：

class MyPromise{
	constructor(executor){
		this.state = 'pending';
		this.value = undefined;
		this.onResolveCallbacks = [];
		this.onRejectCallbacks = [];
		const resolve = (value)=>{
			if(this.state  ==='pending'){
				this.state = 'fullfilled';
				this.value = value;
				this.onResolveCallbacks.forEach((callback)=>callback(this.value));
}
}
		const reject = (reason)=>{
			if(this.state === 'pending'){
				this.state = 'rejected';
				this.value = reason;
				this.onRejectCallbacks.forEach((callback)=>callback(this.value));
}
}
		try{
			excutor(resolve,reject);
}catch(error){
	reject(error);
}
}
then(onResolve, onReject) {
    return new MyPromise((resolve, reject) => {
      if (this.state === 'fulfilled') {
        try {
          const result = onResolve(this.value);
          if (result instanceof MyPromise) {
            result.then(resolve, reject);
          } else {
            resolve(result);
          }
        } catch (error) {
          reject(error);
        }
      } else if (this.state === 'rejected') {
        try {
          const result = onReject(this.value);
          if (result instanceof MyPromise) {
            result.then(resolve, reject);
          } else {
            resolve(result);
          }
        } catch (error) {
          reject(error);
        }
      } else if (this.state === 'pending') {
        this.onResolveCallbacks.push((value) => {
          try {
            const result = onResolve(value);
            if (result instanceof MyPromise) {
              result.then(resolve, reject);
            } else {
              resolve(result);
            }
          } catch (error) {
            reject(error);
          }
        });

        this.onRejectCallbacks.push((reason) => {
          try {
            const result = onReject(reason);
            if (result instanceof MyPromise) {
              result.then(resolve, reject);
            } else {
              resolve(result);
            }
          } catch (error) {
            reject(error);
          }
        });
      }
    });
}
}

2.Promise.all的实现：

function myPromiseAll(promises){
	return new Promise((resolve,reject)=>{
	const results = [];
	let count = 0;
	const addData = (status,value,i)=>{
		res[i] = {status,value};
		count++;
		if(count === promises.length){
			resolve(res);
}
}
promises.forEach((promise,index)=>{
	if(promise instanceof Promise){
		promise.then(res=>{
			addData('fullfilled',res,index);
},err=>{
	addData('rejected',err,index);
})
}
	else{
//若不是promise实例，直接返回当作成功状态		
addData('fullfilled',promise,index);
}
})
})
}

3.Promise.race的实现：

function rece(promises){
	return new Promise((resolve,reject)=>{
		promises.forEach(promise=>{
			if(promise instanceof Promise){
				promise.then(res=>{
					resolve(res);
				},err=>{
					reject(err);
				})
			}else{
			//如果不是promise实例就直接返回
				resolve(promise);
			}
		})
	})
}

4.Promise.retry实现：

function myPromiseRetry(fn, retries) {
  return new Promise((resolve, reject) => {
    const attempt = (currentRetry) => {
      fn()
        .then((result) => {
          resolve(result);
        })
        .catch((error) => {
          if (currentRetry < retries) {
            attempt(currentRetry + 1);
          } else {
            reject(error);
          }
        });
    };

    attempt(0);
  });
}

5.async/await简化版本的实现：

function myAsync(fn) {
  return function () {
    return new Promise((resolve, reject) => {
      const generator = fn();

      const handle = (result) => {
        if (result.done) {
          resolve(result.value);
          return;
        }

        result.value
          .then((res) => {
            handle(generator.next(res));
          })
          .catch((err) => {
            handle(generator.throw(err));
          });
      };

      handle(generator.next());
    });
  };
}

6.实现自定义数组方法push，pop等，返回一个promise对象，判断是否操作成功：

class CustomArray {
  constructor() {
    this.array = [];
  }

  push(value) {
    return new Promise((resolve, reject) => {
      try {
        this.array.push(value);
        resolve(true);
      } catch (error) {
        reject(false);
      }
    });
  }

  pop() {
    return new Promise((resolve, reject) => {
      try {
        const value = this.array.pop();
        resolve(value);
      } catch (error) {
        reject(false);
      }
    });
  }

  // 其他自定义方法...

  length() {
    return this.array.length;
  }
}

// 使用示例
const customArray = new CustomArray();

customArray.push(10)
  .then(success => {
    console.log(success); // true
    console.log(customArray.length()); // 1
  })
  .catch(error => {
    console.error(error);
  });

customArray.pop()
  .then(value => {
    console.log(value); // 10
    console.log(customArray.length()); // 0
  })
  .catch(error => {
    console.error(error);
  });