js数组赋值、引用、深复制、浅复制

如：
var a = [1,2,3,4];
var b= [];
b = a;
这个不是把值赋值过去而是b作为a的引用，b改变的是a
如何b指向的是一个新数组，a把元素值全部赋值过去?

1、普通数组可以使用   var b = [].concat(a);

-----------------------------------------------------------------------------------------------------

2、我遇到一个jquery对象类型的数组是[Object(Array)]类型，其拼接的数组字符串为：

[{
                name: 'Berlin-new',
                type: 'column',
                id: 'berlin', 
                data: [-0.9, 0.6, 3.5, 8.4, 13.5, 17.0, 18.6, 17.9, 14.3, 9.0, 3.9, 1.0]
            },{
                name: 'Tokyo-new',
                type: 'spline', 
                data: [7.0, 6.9, 9.5, 14.5, 18.2, 21.5, 25.2, 26.5, 23.3, 18.3, 13.9, 9.6]
            }]

想将array赋给array2，然后将array2中的data截取一部分，返回array2

var array2= [].concat(array);
                $.each(array2, function (i, obj) {
                    var data = obj.data;
                    obj.data = data.slice(data.length - num, data.length);
                });

这样截取成功，但仍然影响array本身的data；

采用 var arr = $.makeArray( obj );后仍不起作用；

最后用循环创建新数组解决

var result = [];        

$.each(array, function (i, obj) {

            var c = {};   

          $.each(obj, function (key, val) {

                if (key == 'data') {  

                   c[key] = val.slice(val.length - num, val.length);

                } else {  

                   c[key]=val;

                }

            }) ；

            result.push(c);

        });

 

一、push与concat

 

push的定义是:像数组末尾添加一个或更多元素，并返回新的长度。该方法会改变数组的长度。

concat的定义是：连接两个或更多的数组，并返回结果，该方法不会改变现有数组，而仅仅会返回数组的一个副本。

1. var a = [1,2];  
2. a.push([3,4]);  
3. a.concat(5);  
4. //a为1 2 3,4 5  

var a = [1,2];
a.push([3,4]);
a.concat(5);
//a为1 2 3,4 5

 

二、深拷贝与浅拷贝

1.浅拷贝

JavaScript存储对象都是存地址的，所以浅复制会导致 a 和 b 指向同一块内存地址

数组的赋值其实相当于给了索引，改变其中一个变量其他引用都会改变

1. var a = [1,2,3];  
2. var b = a;  
3. b[0] = 4;  
4. //a为4 2 3  
5. //b为4 2 3  

var a = [1,2,3];
var b = a;
b[0] = 4;
//a为4 2 3
//b为4 2 3

 

根据上面存储对象的问题，这里就可以解决另一个问题：

    原始参数（比如一个具体的数字）被作为值传递给函数；值被传递给函数，如果被调用函数改变了这个参数的值，这样的改变不会影响到全局或调用函数。

    你传递一个对象（在js里数组不是简单数据类型，而是对象）到一个函数，如果在函数里面改变了这个参数的内容，在外部这个变化是可见的。

 

2.深拷贝

 

（1）slice 函数

（2）concat 函数

（3）assgin

 

三个函数的原理都是返回数组的一个副本（相当于另外开辟内存空间），所以并不会改变数组本身的的值

 

但是这里有一点不同，就是assgin与其他两点的不同

虽然说assgin也是深拷贝，但是他只是第一层深拷贝，第二层之后还是进行浅拷贝，例子如下：

1. var a = {  
2.     a1:{  
3.         aa1:'11',  
4.         aa2:'22'  
5.     }  
6. }  
7. var b = object.assgin({},a);  
8. var c = object.assgin({},a);  
9. b.a1.aa1 = 33;  
10. /*  
11. b:{  
12.     a1:{  
13.         aa1:'33',  
14.         aa2:'22'  
15.     }  
16. }  
17. c:{  
18.     a1:{  
19.         aa1:'33',  
20.         aa2:'22'  
21.     }  
22. }  
23. */  

var a = {
	a1:{
		aa1:'11',
		aa2:'22'
	}
}
var b = object.assgin({},a);
var c = object.assgin({},a);
b.a1.aa1 = 33;
/*
b:{
	a1:{
		aa1:'33',
		aa2:'22'
	}
}
c:{
	a1:{
		aa1:'33',
		aa2:'22'
	}
}
*/