JavaScript中的浅拷贝与深拷贝

值类型与引用类型

谈浅拷贝与深拷贝之前，我们需要先理清一个概念，即值类型与引用类型。

什么是值类型与引用类型？这要先从JS中的基本类型说起。

首先我们知道，JS中有六种基本类型，number, string, boolean, null, undefined,object。这几个类型就统共被分为两类，值类型与引用类型。

number,string,boolean,undefined就是值类型；object就是引用类型。object里面涵盖的就多了，我们常用的数组呀，函数呀，还有什么Date对象，Math对象，这些都算在object里面的。

这里面null比较特殊，ECMA标准中将它定义为值类型，当你使用在你的编译器里执行typeof(null)时，它的返回值是object。我个人偏好于将它理解为一个指向空对象的指针，便于理解。

（在stackoverflow上搜索的时候看到这么一个回答

If null is a primitive, why does typeof(null) return "object"?

Because the spec says so.

深以为然哈哈哈哈

）

等等，可能有人要问了，你说null是一个空对象指针，那什么是指针呢？

不着急，让我们从计算机如何存储一个数据说起。

值类型与引用类型的存储

计算机存储值类型和引用类型的方法是不同的。这里我们需要提到两种分配内存的数据结构，堆和栈。

什么是堆和栈呢？这讲起来就复杂了，我们只需要知道，栈和堆都是一种内存的分配方式，栈是后进先出的，堆是先进先出的（这个听起来有点像队列，但实际上它的存储更像是链表）。

栈里面的数据占据空间的大小是固定的（例如JS里的数字就固定为64bit的浮点数），空间也是相对较小的，JS里面会把值类型放到栈里面去存储，而存储的就是这个值本身。

而堆里面的数据占据空间的大小是不固定的，空间相对较大，JS会把引用类型的值放到堆里面去存储，而把这个引用类型的地址存放到栈里面去（这个保存地址的变量就是指针）。

为什么要这样做呢？

你想呀，我们学的很多知识，什么算法呀，什么数据结构呀，都有一个中心思想，节约是美德。而计算机里最宝贵的是什么？内存和CPU呀。

想想我们平常会用到的引用类型，数组元素可以几百上千，对象里面定义几十个成员，函数里面变量表达式几十行。跟值类型比起来，引用类型的大小不定，而且通常还蛮大的。这么些个大家伙，计算可要好好想想怎么存储它们。

于是计算机拿了一个指针指向引用类型，当你想要用到那些引用值时，计算机就会去找指向它们地址的指针，然后再去找到它们的值。

于是，回归正题，当我们想要拷贝一个变量的值得时候，它的存储类型就决定了我们拷贝一个值的方式。

这里偷一张《JavaScript高级程序设计》里面的图，很清晰了表示了两者的区别。

值类型的拷贝 引用类型的拷贝

值类型的拷贝

JS里面，经常有这么一个需求，让你去实现一个函数，可以复制当前传入参数的值，而传入的参数有数字、布尔值、字符串，当然，还有对象。

透过上面的图，我们可以很轻松地就完成一个值类型的拷贝。

上面我们说了，值类型是存储在栈里面的，直接存储的就是这个变量的值。那么要拷贝值类型，很直接的将这个变量赋值给另一个新的变量就行了。

引用类型的浅拷贝与深拷贝

浅拷贝

引用类型与值类型就不同了。

引用类型的浅拷贝，我个人认为就是上图所示，直接拷贝的对象的引用，放到代码里面就长这样。

var obj = {
    "a":"1",
    "b":"2",
    "c":{
        "c1":3,
        "c2":4
    }
}
var newObj = obj;
newObj[a] = 3;
console.log(obj[a]);//3

很容易理解，拷贝了原对象的引用，那么这个新变量的值实际上保存的就是原对象的地址，当新对象对对象中的值进行赋值的时候，同时也改变了原对象的值。

也有人把只拷贝对象中的一层属性的拷贝称为浅拷贝。什么意思呢？像上面的那个对象的a和b属性就只有一层属性，而c属性复杂一些，它代表了一个对象。

但是我决定把这个放在深拷贝里讨论。

深拷贝

深拷贝是一个复杂的命题。何为深拷贝？即复制一个与原对象一模一样的对象，包括里面的每个属性，不论是嵌套了几层的，是日期还是数组还是对象。并且两者的地址不同，是两个独立的对象。与浅拷贝不同，不论你如何修改新对象的值，都不会对旧的对象造成任何的影响。

遍历属性拷贝

最简单也是最容易想到的一个办法，即创建一个新的空对象，把原对象的值遍历一遍，然后赋给新对象。

var obj = {
    "a": 1,
    "object": {
        "b": [2, 3, 4],
        "c": 3
    }
}

function cloneObject(obj) {
    var copy = {};
    for (var prop in obj) {
        if (obj.hasOwnProperty(prop))
            copy[prop] = obj[prop];
    }
    return copy;
}

var newObj = cloneObject(obj);

console.log(newObj);//与obj看起来似乎是相同的

然而事实真是这样吗？让我们改变一下newObj中object属性中的值，然后打印出来原对象object属性的值。

newObj["object"].c = 4;

console.log(obj["object"].c);//变成了4

这是为什么呢？

这是因为当我们遍历到例如（原对象中的）对象或者数组这样引用类型时，进行的却是浅拷贝。

于是问题来了，这种拷贝方式如果要进行真真正正的深拷贝必然是不行的，对于对象中的引用类型，我们还要做一次深拷贝。如何做呢？递归。

递归拷贝

这是我在做百度前端学院的2015春季题的时候写的深拷贝代码，只考虑了对象中出现数组、对象、日期的情况。（这里我也记录了一下做春季题的思路和代码，有兴趣可以看看我的另一篇博文：点我）

function getVarType(data) {
  //确定当前变量的对象
    if (data === undefined) {
        return 'Undefined';
    }
    if (data === null) {
        return 'Null';
    }
    return Object.prototype.toString.call(data).slice(8, -1).toLowerCase();
};

function cloneObject(data) {
    var objectType = getVarType(data);
    //the object for cloning is native object
    if (objectType == "null" || objectType == "undefined") {
        return data;
    }

    if (objectType == "string" || objectType == "number" || objectType == "boolean") {
        var copy = data;
        return copy;
    } else if (objectType == "date") {
        var copy = new Date();
        copy.setTime(data.getTime());
        return copy;
    } else if (objectType == "array") {
        var copy = [];
        for (var i = 0; i < data.length; i++) {
            copy[i] = cloneObject(data[i]);
        }
        return copy;
    } else if (objectType == "object") {
        var copy = {};
        for (var attr in data) {
            if (data.hasOwnProperty(attr)) {
                copy[attr] = cloneObject(data[attr]);
            }
        }
        return copy;
    }
}

前面一大堆完成了对值类型和数组字符串日期的拷贝。最后一个if语句中，完成了对对象的深拷贝。

这里用到递归，相当于再对对象的属性值做一次深拷贝，如果是值类型，直接赋值就好，如果是引用类型，再按分类进行分别的拷贝。

让我们用在这个函数再进行一次上面的检测。

var obj = {
    "a": 1,
    "object": {
        "b": [2, 3, 4],
        "c": 3
    }
}
var newObj = cloneObject(obj);

console.log(newObj);

newObj["object"].c = 4;

console.log(obj["object"].c);//与新对象不同，这里输出的值为3

于是，我们完成了对对象的深拷贝。

但是等等。

是不是还有点东西没考虑？

想想如果对象属性的值有函数呢？让我们来试试这个例子。

var obj = {
    "a": 1,
    "b": {
        "c": 2,
    },
    "c": function hello() {
        console.log("hello,world");
    }
}

console.log(cloneObject(obj));

/*
打印结果如下：
{
    a: 1,
    b: {
        c: 2,
    },
    c: undefined
}

*/

我们这个函数有点小小的遗憾，它不能拷贝函数。

但是仔细想想，我们需要拷贝函数吗？

函数是做什么用的？我们需要它去实现一个功能的，拷贝一个一模一样的函数，它实现的功能不也一模一样吗？拷贝一个函数真的有必要吗？（并不是偷懒哈哈哈哈哈）

自己写完了，让我们也来看看用点其他方法去实现的深拷贝。

jQuery实现深拷贝

jQuery要实现深拷贝，要用到extend这个方法，这是干嘛的呢？让我们看看文档：

Merge the contents of two or more objects together into the first object.

[jQuery.extend( deep ], target, object1 [, objectN ] )

• deep

  Type: Boolean

  If true, the merge becomes recursive (aka. deep copy). Passing false for this argument is not supported.

• target

  Type: Object

  The object to extend. It will receive the new properties.

• object1

  Type: Object

  An object containing additional properties to merge in.

• objectN

  Type: Object

  Additional objects containing properties to merge in.

jQuery怎么做深拷贝？简单粗暴一行代码var newObj = $.extend(true,{},obj);

至于具体的，等博主有力气了再来分析分析源码（躺）。

JSON实现深拷贝

JSON怎么做深拷贝？最开始我挺莫名其妙的，然后看了代码才豁然开朗。

也是简单粗暴的一句代码newObj = JSON.parse( JSON.stringify(obj) );

巧用了JSON的parse和stringify，但是它也没办法实现函数的拷贝。

其他

还有一些工具库，例如lodash，underscore等等，这些对深拷贝的实现，就……等以后再分析分析啦。