js 经典实现

以下是 JavaScript 中一些经典实现方法，涵盖常见编程场景和功能需求：

防抖（Debounce）

限制函数在短时间内频繁触发，确保只在最后一次触发后执行：

function debounce(func, delay) {
  let timeoutId;
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

节流（Throttle）

确保函数在一定时间间隔内只执行一次：

function throttle(func, limit) {
  let inThrottle;
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

深拷贝（Deep Clone）

递归复制对象的所有层级：

function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj;
  const clone = Array.isArray(obj) ? [] : {};
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      clone[key] = deepClone(obj[key]);
    }
  }
  return clone;
}

数组去重

多种方法实现数组去重：

// 使用Set
const uniqueArray = [...new Set(array)];

// 使用filter
const uniqueArray = array.filter((item, index) => 
  array.indexOf(item) === index
);

柯里化（Currying）

将多参数函数转换为单参数函数链：

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    } else {
      return function(...moreArgs) {
        return curried.apply(this, args.concat(moreArgs));
      };
    }
  };
}

Promise.all实现

并行执行多个Promise：

Promise.all = function(promises) {
  return new Promise((resolve, reject) => {
    const results = [];
    let completed = 0;
    promises.forEach((promise, index) => {
      Promise.resolve(promise).then(
        value => {
          results[index] = value;
          completed++;
          if (completed === promises.length) {
            resolve(results);
          }
        },
        error => reject(error)
      );
    });
  });
};

事件发布订阅模式

实现简单的事件系统：

class EventEmitter {
  constructor() {
    this.events = {};
  }

  on(event, listener) {
    (this.events[event] || (this.events[event] = [])).push(listener);
  }

  emit(event, ...args) {
    (this.events[event] || []).forEach(listener => listener(...args));
  }

  off(event, listener) {
    if (!this.events[event]) return;
    this.events[event] = this.events[event].filter(l => l !== listener);
  }
}

这些实现展示了JavaScript的核心编程模式，可以根据实际需求进行调整和优化。