本文中的「複製」與「拷貝」視為同義。討論範圍限定在複雜資料型別(Object、Array 等),基本型別(null、undefined、string、number、boolean)不在其中——這些值本身就存在堆疊記憶體裡(字串雖實際存放在堆,但 JS 把它當基本型別處理),不存在參考值的概念。
淺拷貝與深拷貝都能達到「在既有物件基礎上再生一份」的效果,但物件實例是存放在堆記憶體、透過一個參考值來操作的,因此複製時就有兩種可能:複製參考,或複製實例。這正是兩者的分野。
淺拷貝:複製的是參考。拷貝後的多個變數都指向同一個物件實例,彼此的操作會互相牽動。
深拷貝:不只是複製參考,而是在堆中重新配置記憶體,把來源物件的所有屬性都新建一份,確保拷貝出來的物件參考圖中不含任何原有物件。結果是兩者完全隔離。
依深拷貝的定義,若來源物件帶有物件型別的屬性,就必須遞迴下去。不過實務上還存在一種「介於兩者之間」的粒度,也就是 jQuery 的 extend 在 deep 為 false 時所稱的「淺拷貝」:它只做一層複製,若來源物件裡有物件屬性,拷貝結果仍會引用同一個物件。這不符合深拷貝的要求,但確實比單純複製參考要深一層。
本文把淺拷貝定義為最單純的參考複製:
var src = { name: "src" }
var target = src; // 複製 src 的參考
target.name = "target";
console.log(src.name); // target
target 拿到的只是 src 參考值的副本,所以改動 target 也會改到 src。
深拷貝的情況複雜得多,我們從幾個常見方案談起。
這兩個方法都會回傳一個新的陣列實例,但對於陣列中的「物件元素」並沒有執行深拷貝,只是複製了參考:
var array = [1, 2, 3]; var array_shallow = array; var array_concat = array.concat(); var array_slice = array.slice(0); console.log(array === array_shallow); // true console.log(array === array_slice); // false console.log(array === array_concat); // false
可見 concat 與 slice 回傳的確是不同的實例,這點與單純的參考複製不同。但只要元素裡出現物件,破綻就出來了:
var array = [1, [1,2,3], {name:"array"}];
var array_concat = array.concat();
var array_slice = array.slice(0);
// 改動 array_concat 中的陣列元素
array_concat[1][0] = 5;
console.log(array[1]); // [5,2,3] ← 被影響了
console.log(array_slice[1]); // [5,2,3]
// 改動 array_slice 中的物件元素
array_slice[2].name = "array_slice";
console.log(array[2].name); // array_slice
console.log(array_concat[2].name); // array_slice
結論明確:concat 與 slice 都不是真正的深拷貝,陣列中的物件元素只複製了參考。
JSON 物件是 ES5 引入的型別(IE8 起支援)。parse 把 JSON 字串反序列化為 JS 物件,stringify 則反向操作;兩者串起來,就是一個常見的深拷貝捷徑。
var source = { name: "source", child: { name: "child" } };
var target = JSON.parse(JSON.stringify(source));
target.name = "target";
console.log(source.name); // source
console.log(target.name); // target
target.child.name = "target child";
console.log(source.child.name); // child
console.log(target.child.name); // target child
寫法簡單,能覆蓋所有 JSON 表達得掉的型別,但限制也很鮮明:正則表達式、函式等型別無法被複製(數值會直接遺失),而且一旦物件裡存在循環引用,就會直接拋錯。
jQuery 的 extend 用來擴展物件,可傳入 deep 參數(true/false)決定是否遞迴深拷貝。先來看 1.9.1 的源碼:
jQuery.extend = jQuery.fn.extend = function() {
var options, name, src, copy, copyIsArray, clone,
target = arguments[0] || {},
i = 1,
length = arguments.length,
deep = false;
// 處理深拷貝的情況
if ( typeof target === "boolean" ) {
deep = target;
target = arguments[1] || {};
// 跳過 boolean 與 target 本身
i = 2;
}
// 若 target 是字串或其他東西(深拷貝時可能發生),強制改成物件
if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
target = {};
}
// 只傳入一個參數時,視為擴展 jQuery 本身
if ( length === i ) {
target = this;
--i;
}
for ( ; i < length; i++ ) {
// 只處理非 null/undefined 的來源
if ( (options = arguments[ i ]) != null ) {
for ( name in options ) {
src = target[ name ];
copy = options[ name ];
// 避免無限迴圈
if ( target === copy ) { continue; }
// 若正在合併純物件或陣列,則遞迴
if ( deep && copy && ( jQuery.isPlainObject(copy) ||
(copyIsArray = jQuery.isArray(copy)) ) ) {
if ( copyIsArray ) {
copyIsArray = false;
clone = src && jQuery.isArray(src) ? src : [];
} else {
clone = src && jQuery.isPlainObject(src) ? src : {};
}
// 永遠不要搬動原始物件,一律複製一份
target[ name ] = jQuery.extend( deep, clone, copy );
} else if ( copy !== undefined ) {
// 不要把 undefined 帶進來
target[ name ] = copy;
}
}
}
}
return target;
};
逐段拆解:
(1)開頭先把要用到的區域變數一次宣告好,這是所謂的「單 var」模式。
(2)接著修正 deep 參數。因為 jQuery 把 deep 放在第一位,這裡判斷第一個參數是否為布林;若是,就調整 target 與 i 的值,i 代表第一個來源物件的索引。
(3)修正 target:若 typeof 結果既不是物件也不是函式,說明傳進來的是基本型別,改回空物件字面量。
(4)處理只傳一個參數的情形——此時語意是擴展 jQuery 物件或其原型。
(5)從此處開始用 for in 遍歷來源清單,再內嵌一層 for in 走訪每個來源的屬性。
(6)取出 target 與 source 的當前屬性,並用 target === copy 的判斷防止深度遞迴時死循環。但要注意:若來源物件本身就存在循環引用,extend 依然會堆疊溢出。
(7)之後的 if 處理深拷貝:deep 為 true 且當前值為 plainObject 或陣列時,才遞迴。
(8)依 copy 的型別調整 src:copy 是陣列而 src 不是,就改成空陣列;copy 是 plainObject 而 src 不是,就改成 {}。
(9)若上述條件不成立,直接用 copy 覆蓋。
整體而言,extend 以樸素的遞迴完成了深度複製,是 jQuery 插件開發的關鍵基礎方法之一;但它同樣處理不了循環引用,對 Date、Function 等型別也不是真正的深拷貝——所幸這些型別重新賦值時通常直接覆寫,實務上影響有限。
依上述思路,動手實作一個可傳入 deep 的複製函式:
// util 作為判斷變數型別的輔助模組
var util = (function(){
var class2type = {};
["Null","Undefined","Number","Boolean","String","Object","Function","Array","RegExp","Date"]
.forEach(function(item){
class2type["[object " + item + "]"] = item.toLowerCase();
});
function getType(obj){
return class2type[Object.prototype.toString.call(obj)] || "object";
}
function isType(obj, type){
return getType(obj) === type;
}
return { isType: isType, getType: getType };
})();
function copy(obj, deep){
// 若不是物件,直接回傳即可
if (obj === null || typeof obj !== "object") { return obj; }
// 依 obj 的型別決定 target 要用陣列還是物件
var i, target = util.isType(obj, "array") ? [] : {}, value, valueType;
for (i in obj){
value = obj[i];
valueType = util.getType(value);
// 只有明確要求深拷貝,且當前值為陣列或物件時,才遞迴
if (deep && (valueType === "array" || valueType === "object")){
target[i] = copy(value, deep);
} else {
target[i] = value;
}
}
return target;
}
用 Object.prototype.toString 來判型別,比單靠 typeof 可靠得多——後者對陣列、正則、日期一律回報 "object",實在難以勝任。