数组方法

//		数组的添加
		var arr=[];
		
//		push()在数组的末端添加一个或者多个元素,并且返回添加了新元素的数组长度;
		var num = arr.push("1","2","3");//push，在数组的末端添加，返回的是数组的长度
		console.log(num,arr);
		
		var arr01 = [1,2,3,4,5,6];
		var arr02 = [];
		//把arr01 的元素拷贝到arr02里面（使用push）
//		var arr01 = [1,2,3,4];
//		var arr02 = [];
//		for(var i=0;i<arr01.length;i++){
//			console.log(arr02.push(arr01[i]));
//		} 
		
		//unshift()在数组的第一个位置添加 一个或者多个元素，并且返回添加的了新元素的数组长度；
		
		var num01=arr.unshift("a","b","c");
		console.log(num01,arr);//6,["a","b","c","1","2","3"];
		
		//数组的删除
		
//		pop()删除数组的最后一个元素,并且返回被删除的那个元素
		
		var str=arr.pop();
		console.log(str,arr);//3,["a","b","c","1","2"];
		
//		shift()删除数组的一个元素,并且返回被删除的那个元素

		var str01 = arr.shift();
		console.log(str01,arr);//a,["b","c","1","2"];
		
		//fill（）清空数组元素，不改变数组长度，数组的元素使用undefined去补齐
		
		console.log(arr.fill());//["undefined","undefined","undefined","undefined"]
		
		//从后往前删除4个
		//从前往后删除2个
//		var arr03 = [1,2,3,4,5,6,7,8,9,10,11,12];
//		for(var i=0;i<=3;i++){
//			console.log(arr03.pop(arr03[i]));
//		}
//		for(var i=0;i<=1;i++){
//			console.log(arr03.shift(arr03[i]));
//		}
//		console.log(arr03);
		
		/*
		 * splice（）添加/删除数组元素
		 * 删除原数组的一部分，并且可以在被删除的位置添加新成员，返回的是被删除的元素
		 * splice(index，数量，添加的新元素)；
		 * index：规定从那个元素的位置开始删除，或者添加，必须是数组类型（数组下标）
		 * 数量：规定删除的个数，如果是0，就不执行删除操作
		 * 添加的新元素，可以当做、替换来看
		 */
		
		var arr04=[1,2,3,4,5,6,7,8];
		var arr05 = arr04.splice(0,1);//删除操作包含起始位置
		console.log(arr04,arr05);
		var arr06 = arr04.splice(0,0);//第二个参数为0，不执行删除操作
		var arr07 = arr04.splice(arr094.length-1,0,"a","b","c");//添加的元素可以是多个，只有用逗号隔开就行
		
		//数组的排序
		//reverse()用于颠倒数组中的元素的顺序，不做值的比较，返回改变后的数组；
		var arr08 = [1,2,3,4];
		console.log(arr08.reverse());
		
		/*
		 * sort():不是按照大小去排序，是安装对应字符的编码（unicode）顺序去排序；
		 * 如果需要做其他顺序的排序，需要提供一个函数，函数中要提供两个参数，对这两个参数做比较，比参数a，b为例
		 * a>b(从小到大) a在b的后面
		 * a<b(从大到小) a在b的前面
		 * a=b 把数组倒过来排序，第一个变成最后一个，最后一个变成第一个
		 */
		console.log(arr08.sort());
		var color = ["red","yellow","green"];
		console.log(color.sort());
		
		var numbers= [1,10,20,5,30];
		function myFun(a,b){
			//return a-b;//从大到小
			return b-a ;//从大到小
		}
		console.log(numbers);
		console.log(numbers.sort(myFun));
		
//		copyWithin(ind1,ind2,ind3)指定位置的成员复制到其他的位置
		/*ind01：必选，从这个位置开始替换数据，如果是负数，表示倒数
		 *ind02：可选，从这个位置开始读取数据，默认为0，如果是负数，表示倒数
		 *ind03，可选，从这个位置前停止读取数据，默认是数组的长度，使用负数可以从数组的结尾处规定元素
		 *
		 * 不改变数组的长度，替换数组的元素
		 */
		var arr03 = [1,2,3,4,5,6,7,8,9,0,11];
		var arr04 = arr03.copyWithin(1);//参数二和参数三是默认值
		console.log(arr03);//[1,1,2,3,4,5,6,7,8,9,0]
		var arr05 = arr03.copyWithin(1,-9,5);
		console.log(arr05);//[1,4,5,3,4,5,6,7,8,9,0]

		//		Array.of()返回由所有参数组成的数组
//		解决了构造函数中参数不同产生的差异
		var arr01 =new Array(3);//3代表数组的长度
		console.log(arr01);//["undefined"]
		var arr02 = Array.of(3,3,1,3);
		console.log(arr02);//[3]
		
//		Array.from()将两类对象转化成真正的数组
		var atr = "123456789";//字符串（string对象）
		var str01 = Array.from(str);
		console.log(str01);
		var obj = {0:"a",1:"b",3:"c","length":5}//加上长度，对象key必须是数组（数组类型，字符串都行）
		var obj01 = Array.from(obj);
		console.log(obj01);
		
//		copyWithin(ind1,ind2,ind3)指定位置的成员复制到其他的位置
		/*ind01：必选，从这个位置开始替换数据，如果是负数，表示倒数
		 *ind02：可选，从这个位置开始读取数据，默认为0，如果是负数，表示倒数
		 *ind03，可选，从这个位置前停止读取数据，默认是数组的长度，使用负数可以从数组的结尾处规定元素
		 *
		 * 不改变数组的长度，替换数组的元素
		 */
		var arr03 = [1,2,3,4,5,6,7,8,9,0,11];
		var arr04 = arr03.copyWithin(1);//参数二和参数三是默认值
		console.log(arr03);//[1,1,2,3,4,5,6,7,8,9,0]
		var arr05 = arr03.copyWithin(1,4,6);
		console.log(arr05);[1,4,5,3,4,5,6,7,8,9,0]
		
		/*
		 * fill(ind1,ind2,ind3):填充数组
		 * ind1：要填充的值
		 * ind2：填充开始位置，默认为0
		 * ind3：填充结束的位置，不包括选中的位置，默认是数组的长度
		 * 
		 */
		
		var arr06=["1","2","3","4"];
		console.log(arr06.fill(1,1,5));//["1",1,1,1]
		
		/*
		 *join(ind):将数组转为字符串
		 * ind：可选，指定要使用的分隔符，默认使用逗号作为分隔符
		 */
		
		var arr07 = ["123","12321"];
		var str02 = arr07.join("");
		console.log(str02);
		var arr08 = ["a","b","c"];
		console.log(arr08,join(""));
		//toString()--数组转化为字符串，不能指定分隔符
		console.log(arr08.toString());
		
		/*
		 * concat(ind)--合并；两个或者多个数组，返回一个新数组
		 * ind：必须，可以是具体的值，可以是数组，可以是任意多个
		 */
		var arr =["a","b","c","d"];
		var arr01 = [1,2,3,4,5];
		var arr02 = arr01.concat(arr,6,7,8,9);
		console.log(arr02,arr02,arr);
		
		/*
		 * ES6扩充运算符，...合并数组
		 */
		
		var arr03 = [7,8,9,...arr,...arr01,"aa","bb"]
		console.log(arr03);
		
		/*
		 * indexOf(ind1,ind2)--查找数组是否存在某个元素，存在放回下标，不存在放回-1
		 * ind1：必须，被查找的元素
		 * ind2：可选，开始查找的位置（不能大于数组的长度，返回-1）接受负数，默认是0
		 * 在数组中indexOf是严格（绝对）相等的（===）的搜索，值和；类型都匹配上，才算查找成功
		 */
		var arr04 = ["文字",1,2,3,"4",undefined];
		console.log(arr04.indexOf("文"));// -1 类型相等，值不等
		console.log(arr04.indexOf(4));//-1,值相等，类型不等
		
//		lastIndexOf()--从后往前查找，用法和indexOf()一致,负数的倒数
		console.log(arr04.lastIndexOf(2,-2));
		
		/*
		 * filter()--在特点条件下缩小数组的内容（按条件过滤（筛选数组）数组）
		 * 在回调函数指定的条件下判断单个元素，查找个条件匹配的元素
		 * 语法：filter（callback）
		 * 回调函数里面可以指定数组判断单个元素，查找和条件匹配的元素
		 * 回调函数中放回true的元素将会生成新的数组，没有返回true的就直接跳过，不会包含在新数组里面
		 * 
		 */
		
		var arr05 = [1,2,3,4,8,20,21,35];
		var arr06 = arr03.filter(function(val){
			return val%2===0;//return 定义函数的返回值
		});
		console.log(arr06);
		
		var arr07=[1,2,3,4,5,6,7,8,9,0];
		function myFun(val){
			return (val<5);
		}
		var arr08=arr07.filter(myFun);
		console.log(arr08);