javascript数组
数组概念
数组的遍历
数组是一个引用类型
数组的常见方法
数组的头尾操作pop()、push()、shift()、unshift()
数组的合并与拆分 concat()、slice()
多功能splice()插入、删除、替换
逆序reverse();
排序sort()
转为字符串

数组概念
数组(array)是一个有序的数据集合。说白了，数组就是一组数。
	var arr = [16,33,23,12,53];

数组的字面量就是方括号，这是定义数组的最简单的方式。至于更多创建数组的方式，我们等到高级JS再学。

里面用逗号隔开了很多值，最后一项没有逗号。

变量a就是一个数组变量，里面存储的不是一个数字，而是一组数。可以使用下标，或称为索引值index来精确访问数组中的某一个项，下标从0开始。
	console.log(arr[0]);   //输出16
	console.log(arr[1]);   //输出33
	console.log(arr[4]);   //输出53

数组中并不规定保存相同类型的项，但实际应用中，我们一般还是将相同类型的项保存在其中。

下面的数组中，存储的内容类型都是不一样的是合法的。
	var arr = [1,"哈哈",true,undefined,"么么哒"];

数组有一个属性，就是length，英语是长度的意思，表示这个数组的项的个数。

先说说什么是“属性”，数组是对象（放心里，后面高级JS课我们就会知道这个事情），对象有属性，属性就是描述这个对象的特点、特性、特征。用点来表示一个对象的属性：
	arr.length

var arr = [34,563,4576,334,46,433];
alert(arr.length);		//6，数组里面一共有6项

数组中有几项，那么就会弹出几。
现在我们发现，数组最后一项的下标，是length-1。
arr[arr.length - 1]  //表示数组的最后一项

数组的最大下标是arr.length - 1，尝试输出一个大于这个数字的下标：
arr[100];   //undefined;

尝试比length-1还大的下标，就是undefined。
好玩儿的是，我们可以跳跃着指定数组：
arr[66] = 88;

那么此时其他没有指定的项目就是undefined。数组的	arr.length;  //67了，我们设置了下标为66的项，强制“抻长”了数组

写一个小于数组元素数量的值会缩短数组，写0会彻底清空数组。数组我们现在arr.length = 2;

那么它就会有两项a[0]、a[1]其他项就丢失了。
数组的遍历
数组里面存放的是一组数，那么我们经常需要对这些数字都进行一些操作。

就需要用for循环语句来遍历它。这是一个经典的for壳子：
for(var i = 0 ; i <= arr.length - 1 ; i++){
	就可以对arr[i]来进行操作、判断……
}

数组是一个引用类型
var arr = [1,2,3,4];
console.log(typeof arr);	//object

用typeof arr来检测，你会发现数组输出object。数组是对象。



所以保存数组的变量，实际上保存是数组内存地址：
	var a = [1,2,3,4];
	var b = a;
	b[0] = 88;		//修改的是数组b下标为0的项
	console.log(a); //数组a的下标为0的项也改为88





都是数组[1,2,3]内容、长度、项的位置完全一样，但是不 ==  如下
	var a = [1,2,3];
	var b = [1,2,3];
	console.log(a == b);

这是因为引用类型比较的是地址，变量a和变量b指向的位置不一样，不能判相等。
如果a里面存储的是基本类型，那么语句b=a就是把a的值赋值一份给b。如果a里面存储的是引用类型，那么b将指向a现在指向的位置，a的值不会赋值一份，a、b指向同一个地方。
数组的常见方法
数组是对象，现在你要知道对象都有属性和方法。

属性已经介绍了，数组有length属性。属性就是描述对象的特点的，比如“性别”、“姓名”、“身高”

方法就是对象能够执行的事情。比如“吃饭”、“睡觉”、“打dota”

我们现在就要来学数组能执行什么方法。


数组的头尾操作pop()、push()、shift()、unshift()
push()方法，在数组的末尾添加项目，可以添加1个，也可以添加多个。
	var arr = ["东","西","南","北"];
	arr.push("中","发","白");		//在数组最后添加项
	console.log(arr);

push就是推的意思，推入。


pop()方法，删除数组的最后一项，只能删除最后一项，无法删除多项。能够返回被删除的元素。

push 尾插 pop 尾删 unshift 头插 shift 头删

数组的合并与拆分 concat()、slice()
concat()方法就是合并两个数组
	var arr1 = ["东","西","南","北"];
	var arr2 = ["一条","二条"];
	
	arr1.concat(arr2);   //这里有一个超级大坑，concat是把arr1和arr2合并为一个新数组返回
	console.log(arr1);   //不变

所以必须：
	arr1 = arr1.concat(arr2);

concat()的参数非常灵活，可以是数组变量、数组字面量、散的值也行：
	var arr1 = ["东","西","南","北"];
	var arr2 = ["一条","二条"];
	
	arr1 = arr1.concat(arr2,["一筒","八条"],"幺鸡");
	console.log(arr1);



slice()方法可从已有的数组中返回选定的元素。arr.slice(start,end)
	var arr = ["东","西","南","北","中","发","白"];
	var arr2 = arr.slice(1,4); //截取下标为1、2、3的为一个新数组返回
	console.log(arr2);   //["西", "南", "北"]

arr.slice(start,end) 返回一个新的数组，包含从 start 到 end （不包括该元素）的元素。

只有开头：
	var arr = ["东","西","南","北","中","发","白"];
	var arr2 = arr.slice(3); //  从下标为3的项目开始截取后面全部了
	console.log(arr2);   // ["北", "中", "发", "白"]

slice(a,b)取出了b-a项
多功能splice()插入、删除、替换
我们先确认一个事情，
	arr.splice(3,2,"斑马","骆驼");

一旦应用，arr立即改变。并不需要重新复制，换句话说，这个函数不返回新的数组。
	var arr = ["A","B","C","D","E","F","G"];
	arr.splice(3,2,"X","Y","Z","思密达"); //从数组下标为3开始这项，连数2项，改为……
	console.log(arr);


// ***************插入一些项 ***************
var arr = ["A","B","C","D","E","F","G"];
arr.splice(2,0,"嘻嘻","哈哈");		//插入到下标为2的项前，不删除项目
console.log(arr);



splice依据参数的多少，和参数是什么，有多功能。现在你要能反应过来。

删除数组的最后8项。
	arr.pop();
	arr.pop();
	arr.pop();
	arr.pop();
	arr.pop();
	arr.pop();
	arr.pop();
	arr.pop();

简化为：
	for(var i = 1 ; i <= 8 ; i++){
	arr.pop();3	}

也可以：
	arr.splice(-8);	

逆序reverse();
reverse()方法就是立即让数组倒置：
	var arr = ["A","B","C","D","E","F","G"];
	arr.reverse();   //不需要赋值
	console.log(arr);  //["G", "F", "E", "D", "C", "B", "A"]


排序sort()
sort()方法排序
	var arr = ["G","A","C","B","I","H","G","I","B"];
	arr.sort();
	console.log(arr);


	//sort函数默认是按照字符顺序排的，隐式将数字转为string
	//比字符编码顺序
	var arr = [23,435,456,23,2,345,2,32,11,324,32,43,65,667,78,43];
	arr.sort();
	console.log(arr);



sort()里面有一个参数，这个参数是一个函数。
	arr.sort(function(a,b){
		//如果a要放在b前面，那么返回负数
		//如果a要放在b后面，那么返回正数
		//如果a和b不区分大小，那么返回0
		if(a < b){
			return -1;
		}else if(a > b){
			return 1;
		}else if(a == b){
			return 0;
		}
	});

转为字符串
	var arr = [1,2,3,4,5,6,7];
	var str = arr.join("★");
	console.log(str);



语法
	var str = arr.join(分隔符);

如果不写分隔符，那么等价于用逗号分开
	var arr = [1,2,3,4,5,6,7];
	var str = arr.join();
	console.log(str);	

数组、对象、值都适用
参考

在vue中 this.A = this.B,没有进行深层赋值，只是把this.A的地址指向了与this.B相同的地址，所有对于A的修改会影响到B
	
解决相互影响的思路是在this.A必须是新建的一个对象，这样才能保证不被指向同一地址，属性修改不会相互影响。
 this.A=JSON.parse(JSON.stringify(this.B));


1
将对象转成字符串剔除对象属性后,再转换成对象赋值，这样能解决指向相同地址修改会相互影响的问题。里面的this.A= JSON.parse(JSON.stringify(this.B)); 如果是直接this.A= this.B的话会把 this.A替换为this.B然后再把this.B赋值给this.A相当于 this.A= this.A所以先转json字符串 再转数组 然后赋值给this.A这样不会相互影响

 

1.浅拷贝

对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础数据类型的拷贝，其中一个对象修改该值，不会影响另外一个。
对于引用类型，比如数组或者类对象，因为引用类型是引用传递，所以浅拷贝只是把内存地址赋值给了成员变量，它们指向了同一内存空间。改变其中一个，会对另外一个也产生影响。  

2.深拷贝

对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个（和浅拷贝一样）。
对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。改变其中一个，不会对另外一个也产生影响。



我们在实际项目中往往会遇到对象拷贝的问题，我们在与数据库交互的类对象往往不会暴露出来，往往会转化为DTO 暴露给我们的前端。

我们一般会采用spring BeanUtils.copyProperties() 进行拷贝。
BeanUtils.copyProperties() 遇到的坑
1.copyProperties()利用发射的原理，进行的是浅拷贝。修改目标对象的引用类型，源对象的引用对象的值会发生改变。
2.copyProperties() 不支持泛型，T id 这种数据类型的变量无法进行拷贝。

什么是浅拷贝？
浅拷贝只是拷贝一层, 更深层次对象级别的只拷贝引用（地址）。
浅拷贝的特点
(1) 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个。
(2) 对于引用类型，比如数组或者类对象，因为引用类型是引用传递，所以浅拷贝只是把内存地址赋值给了成员变量，它们指向了同一内存空间。改变其中一个，会对另外一个也产生影响。
例如：
var obj = {
    id:1,
    name:'andy',
    mes:{
        age:18
    }
};

var o ={};

for(var k in obj){
    //k是属性名 obj[k]是属性值
    o[k] = obj[k];
}

console.log(o);

o.mes.age = 20;
console.log(obj);
打印结果：



为什么第一个输出的不是18，百度得出结论：因为console.log打印的是当前的值，展开后是最新修改后的值。
可以发现，把 obj 的mes属性赋值给 o 的时候赋值的是mes的地址，修改obj或o其中一个的mes，另一个的mes也会发生变化。
示意图：



es6新增的浅拷贝语法糖：Object.assign(o,obj);  等价于上面的for循环内容。
什么是深拷贝？
深拷贝拷贝多层，每一级别的数据都会拷贝。
深拷贝的特点
(1) 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个（和浅拷贝一样）。
(2) 对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。改变其中一个，不会对另外一个也产生影响。
(3) 对于有多层对象的，每个对象都需要实现 Cloneable 并重写 clone() 方法，进而实现了对象的串行层层拷贝。
(4) 深拷贝相比于浅拷贝速度较慢并且花销较大。
如：
//深拷贝拷贝多层，每一级别的数据都会拷贝
var obj = {
    id:1,
    name:'andy',
    mes:{
        age:18
    },
    color:['pink','red'],
};

var o ={};

//封装函数

function deepCopy(newObj, oldObj){
    for(var k in oldObj){
        //判断我们的属性值属于哪种数据类型
        //1、获取属性值 oldObj[k]
        var item = oldObj[k];

        //2、判断这个值是否是数组
        if(item instanceof Array){
            newObj[k] = [];
            deepCopy(newObj[k], item);
        }else if(item instanceof Object){
            //3、判断这个值是否是对象

            newObj[k] = {};
             deepCopy(newObj[k], item);
        }else{
            //4、属于简单数据类型
            newObj[k] = item;
        }
    }
}
deepCopy(o,obj);
console.log(o);
示意图如下：
引用类型的值都是 Object 的实例。引用类型有：Object类型，Array类型，Date类型，RegExp类型（正则），function类型。还有基本包装类型，也是一种引用类型。ECMAScript还提供了 3个特殊的引用类型：Boolean、Number和String。



附：

引用类型的值都是 Object 的实例。引用类型有：Object类型，Array类型，Date类型，RegExp类型（正则），function类型。还有基本包装类型，也是一种引用类型。ECMAScript还提供了 3个特殊的引用类型：Boolean、Number和String。