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 記錄已經拷貝過的對象，如果遇到循環引用，直接返回已經拷貝過的對象，避免無限遞歸。
