JS——数组常用方法

1. pop() 和 push() 方法

pop()方法：删除数组里的最后一个元素，并返回删除的元素。

var arr = [1,2,3];
console.log("删除的元素：",arr.pop());
console.log("删除后的数组：",arr);

push()：可向数组尾部添加一个或多个元素，并返回新的长度。

var arr = [1,2,3];
console.log("返回新数组的长度：",arr.push(4,5));
console.log("新数组：",arr);

2. shift() 和 unshift() 方法

shift()方法：删除数组里的第一个元素，并返回删除的元素。

var arr = [1,2,3];
console.log(arr.shift());
console.log("新数组：",arr);

unshift()：方法可向数组的开头添加一个或更多元素，并返回新的长度。

var arr = [1,2,3];
console.log(arr.unshift(-1,0));
console.log("新数组：",arr);

3. splice()方法

splice()： 可以向数组中添加元素或删除元素，然后返回删除的元素构成的新数组。

arr.splice(参数1，参数2，参数3)

参数1：必需 开始删除/添加下标（索引号） 可以为负 -1为倒数第一个元素。

参数2：必需。要删除的元素个数。

参数3：可选 添加的元素 多个元素之间用逗号隔开。

返回值：删除的元素构成的新数组，若没有删除元素则返回一个空数组。

var arr = [1,2,3];
//删除第二个元素
console.log(arr.splice(1,1));
console.log("新数组：",arr);
//添加元素
console.log(arr.splice(2,0,"1","2"));
console.log("新数组：",arr);
//替换  5 替换 3
console.log(arr.splice(1,1,"5",));
console.log("新数组：",arr);

4. sort() 方法

sort()：方法用于对数组元素进行排序

参数：可选 函数 若省略，则按照Unicode编码排序 升序

var arr = [11,2,35,24,56];
//升序
var arr = arr.sort(function(a,b){
	return a - b;      
});
console.log(arr);
//降序
var arr = arr.sort(function(a,b){
	return b - a;      
});
console.log(arr);

5. join() 方法

join()：可将数组转成字符串。
方法只接收一个参数：默认分隔符为逗号（）。

var arr=[1,2,3,4];
console.log(arr.join()); //1,2,3,4
console.log(arr.join(":")); //1:2:3:4
console.log(arr); //[1,2,3,4],原数组不变

6. reverse() 方法

reverse()：方法用于颠倒数组中元素的顺序。
返回值：颠倒后的数组。

var arr=[1,2,3,4];
console.log(arr.reverse()); // [4, 3, 2, 1]
console.log(arr); // [1, 2, 3, 4] (原数组改变)

7. concat() 方法

concat()：用于连接数组。
参数： 可以是数组，元素，多个之间用逗号隔开，无参数时，复制当前数组。
返回值：链接后的数组。

var arr=[1,2,3,4];
var arr2=[11,22,33] 
var arrCopy = arr.concat(arr2);
console.log(arr.concat()); // [1, 2, 3, 4] (复制数组)
console.log(arrCopy); // [1, 2, 3, 4, 11, 22, 33]
console.log(arr); // [1, 2, 3, 4] (原数组未改变)
</script>

8. slice() 方法

arr.slice(参数1，参数2) 参数1不能大于参数2。

参数1：必需 开始截取的位置 可以为负，-1 指最后一个元素。

参数2：可选 结束截取的位置 可以为负 若省略，截取到数组末尾。

返回值：返回一个新的数组，包含从 开始 到 结束 （不包括该元素）的 arr 中的元素。

var arr = [1,2,3,4,5];
var arrCopy1 = arr.slice(1);	
var arrCopy2 = arr.slice(0,4);	
var arrCopy3 = arr.slice(1,-2);
var arrCopy4 = arr.slice(-5,4);
var arrCopy5 = arr.slice(-4,-1)
console.log(arrCopy1);  // [2, 3, 4, 5]
console.log(arrCopy2);  // [1, 2, 3, 4] 
console.log(arrCopy3);  // [2, 3] 
console.log(arrCopy4);  // [1, 2, 3, 4]
console.log(arrCopy5);  // [2, 3, 4]
console.log(arr);  // [1, 2, 3, 4, 5] (原数组) 
</script>

9. forEach() 方法

forEach()：对数组进行遍历循环，没有返回值。

arr.forEach(function(item ,index , arr){ });

item：必需，遍历的数组的当前元素
index： 可选。当前元素的索引值。
arr : 可选。当前元素所属的数组对象。

var Arr = [1,2,3,4];
Arr.forEach(function(currentValue, index, arr){
console.log(index+"--"+currentValue);		
})
</script>

10. map() 方法

map()：指“映射”，方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

arr.map(function(item ,index , arr){ });

item：必需，遍历的数组的当前元素
index： 可选。当前元素的索引值。
arr : 可选。当前元素所属的数组对象。

var arr = [1,2,3,4];
//求数组里每个元素的平方
var arr2 = arr.map(function(item, index){
    return item*item;
});
console.log(arr2); 

11. filter() 方法

filter()： 过滤，方法创建一个新数组, 其包含所有满足条件的所有元素。

var arr = [1,2,3,4,5];
//求大于2的元素
var result = arr.filter(function(item,index){
	return item > 2;
});
console.log(result);
</script>

12. reduce() 方法

方法会迭代数组中的所有项，然后生成一个最终返回值。接收两个参数，第一个参数是每一项调用的函数，函数接受四个参数分别是初始值，当前值，索引值，和当前数组，函数需要返回一个值，这个值会在下一次迭代中作为初始值。第二个参数是迭代初始值，参数可选，如果缺省，初始值为数组第一项，从数组第一个项开始叠加，缺省参数要比正常传值少一次运算。

reduce()语法：arr.reduce(function(res , row , index , arr){ }, value);

res ：必需。初始值, 或者计算结束后的返回值。

row ：必需。当前元素。

index ：可选。当前元素的索引。

arr：可选。当前元素所属的数组对象。

value：可选。传递给函数的初始值。

1. 求和

var arr = [1,2,3,4,5];
//求和
var result = arr.reduce(function(res, row, index, arr){
	console.log("res：" + res + ", row：" + row + ", index:"+index);
	return res + row;
});
console.log(result);

2. reduce 去重

var arr = [1,2,3,2,3]
let result = arr.reduce(function(res,row ,index){
	if(!res.includes(row)){     //includes()： 表示数组中是否包含某个元素
		res.push(row)
	}
	return res;
}, [])
console.log(result);

3. reduce 求最大值

var arr = [1,2,3,4,5]
let max = arr.reduce(function(res, row, index){
	return Math.max(res, row);
})
console.log(max);