javascript 的 extend 功能核心是对象属性复制，能实现对象合并与功能扩展。1. 最基础的是浅拷贝，通过遍历源对象属性并复制到目标对象，但嵌套对象会共享引用；2. 深拷贝则递归复制所有层级，确保嵌套对象也被复制，避免引用共享；3. 实际开发中推荐使用 lodash 或 jquery 提供的稳定方法；4. 可通过修改原型或 object.assign 扩展对象功能，但前者有冲突风险；5. 性能优化需减少不必要的拷贝或采用更高效算法如 json 序列化；6. 为避免属性覆盖，可在复制前检测冲突并警告；7. 针对循环引用，可用 weakmap 记录已拷贝对象，防止无限递归。合理使用 extend 能提升代码灵活性和可维护性。
JavaScript 的 extend 功能，本质上就是对象合并，把一个或多个对象的属性复制到另一个对象上。这玩意儿看似简单，但用起来灵活得很，能解决不少实际问题。
解决方案
extend 核心就是属性的复制，但要考虑的情况还真不少。最基本的，就是浅拷贝和深拷贝的区别。浅拷贝只复制对象的引用，深拷贝会创建一个新的对象，递归复制所有属性。
先来个最简单的浅拷贝版本：
function extend(target, ...sources) {
for (const source of sources) {
for (const key in source) {
if (source.hasOwnProperty(key)) {
target[key] = source[key];
}
}
}
return target;
}
这个版本够直接，遍历所有源对象的属性，然后复制到目标对象上。hasOwnProperty 用来过滤掉原型链上的属性。
但是，这有个问题，如果源对象的属性也是个对象呢？那目标对象只会拿到这个对象的引用，修改目标对象的属性，源对象也会跟着变。这就是浅拷贝的局限性。
要实现深拷贝，就得递归处理：
function deepExtend(target, ...sources) {
for (const source of sources) {
for (const key in source) {
if (source.hasOwnProperty(key)) {
if (typeof source[key] === 'object' && source[key] !== null) {
if (Array.isArray(source[key])) {
target[key] = target[key] || []; // 确保目标属性也是数组
} else {
target[key] = target[key] || {}; // 确保目标属性也是对象
}
deepExtend(target[key], source[key]); // 递归调用
} else {
target[key] = source[key];
}
}
}
}
return target;
}
这个 deepExtend 函数，在遇到对象类型的属性时，会递归调用自身，确保所有嵌套的对象都被复制。注意，这里加了数组的判断，确保数组也能正确复制。
当然，实际项目中，更推荐使用成熟的库，比如 Lodash 的 _.merge 或 jQuery 的 $.extend，它们已经处理了很多边界情况，更稳定可靠。自己手写 extend 主要是为了理解其原理。
如何使用 JavaScript Extend 扩展现有对象的功能？
JavaScript 的 extend 功能不仅仅是合并对象，更重要的是扩展对象的功能。比如，你想给所有对象都加上一个 log 方法，方便调试：
Object.prototype.log = function() {
console.log(this);
return this; // 链式调用
};
let obj = { a: 1, b: 2 };
obj.log().a; // 输出 { a: 1, b: 2 }，并返回 obj
这样，任何对象都可以直接调用 log 方法了。当然，直接修改 Object.prototype 有风险，可能会和其他库冲突，所以要谨慎使用。
另一种方式是使用 Object.assign：
const logMixin = {
log() {
console.log(this);
return this;
}
};
Object.assign(obj, logMixin);
obj.log(); // 输出 { a: 1, b: 2, log: [Function: log] }
Object.assign 会把 logMixin 里的属性复制到 obj 上，但不会修改 Object.prototype，更安全。
JavaScript Extend 的性能考量与优化
extend 函数的性能，主要取决于对象属性的数量和嵌套的深度。如果对象非常大，深拷贝可能会很慢。
一个优化思路是，尽量避免不必要的拷贝。如果只是想修改目标对象的部分属性，可以直接修改，而不是全部拷贝。
另一个优化思路是，使用更高效的拷贝算法。比如，可以使用 JSON.parse(JSON.stringify(obj)) 来实现深拷贝，虽然简单粗暴，但在某些情况下性能还不错。
function deepClone(obj) {
return JSON.parse(JSON.stringify(obj));
}
let obj2 = deepClone(obj);
但是，这种方法有局限性，不能拷贝函数和循环引用的对象。
如何避免 JavaScript Extend 引起的潜在问题？
使用 extend 最常见的问题是属性覆盖。如果源对象和目标对象有同名属性，源对象的属性会覆盖目标对象的属性。
为了避免这个问题，可以在 extend 函数中加入冲突检测：
function extendSafe(target, ...sources) {
for (const source of sources) {
for (const key in source) {
if (source.hasOwnProperty(key)) {
if (target.hasOwnProperty(key)) {
console.warn(`属性 ${key} 冲突，目标对象已存在该属性`);
} else {
target[key] = source[key];
}
}
}
}
return target;
}
这个 extendSafe 函数，在遇到同名属性时，会输出警告信息，而不是直接覆盖。
另一个潜在问题是循环引用。如果对象之间存在循环引用，深拷贝可能会导致无限递归，最终栈溢出。
为了避免这个问题，需要在深拷贝函数中记录已经拷贝过的对象，防止重复拷贝：
function deepExtendWithCycle(target, ...sources) {
const visited = new WeakMap(); // 记录已经拷贝过的对象
function clone(obj) {
if (typeof obj !== 'object' || obj === null) {
return obj;
}
if (visited.has(obj)) {
return visited.get(obj); // 如果已经拷贝过，直接返回
}
let clonedObj = Array.isArray(obj) ? [] : {};
visited.set(obj, clonedObj); // 记录已经拷贝过的对象
for (const key in obj) {
if (obj.hasOwnProperty(key)) {
clonedObj[key] = clone(obj[key]); // 递归调用
}
}
return clonedObj;
}
for (const source of sources) {
for (const key in source) {
if (source.hasOwnProperty(key)) {
target[key] = clone(source[key]);
}
}
}
return target;
}
这个 deepExtendWithCycle 函数，使用 WeakMap 记录已经拷贝过的对象，如果遇到循环引用，直接返回已经拷贝过的对象，避免无限递归。
暂无评论内容