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的核心编程模式，可以根据实际需求进行调整和优化。
