一.ES5新增数组方法及迭代方式
1. ES5静态方法：
(1)isArray()
Array.isArray() 判断是否是一个数组
var arr = [1, 2, 3, 4, 5, 6];
console.log(Array.isArray(arr)); //true
console.log(Array.isArray(null)); //false
2. ES5为数组定义了6个迭代的方法：
每个方法接受两个参数：运行该函数的作用域对象、要在每一项上运行的函数
运行的函数会接受三个参数：获取的所有元素、对应元素的下标、数组本身
(1)forEach() 循环遍历数组，本质上是一个for循环
//遍历
var arr = [1, 6, 20, 8, 75, 86];
arr.forEach(function(ele, index, array) {
console.log(ele, index, array);
})
//求和
var arr = [1, 6, 20, 8, 75, 86];
var sum = 0;
arr.forEach(function(ele, index) {
sum += ele;
})
alert(sum);//输出196
//求最大值
var arr = [1, 6, 20, 8, 75, 86];
var maxNum = -97435794759873479857;
arr.forEach(function(ele, index) {
if (maxNum < ele) {
maxNum = ele
}
})
alert(maxNum);//输出86
//求最小值
var arr = [1, 6, 20, 8, 75, 86];
var minNum = 999999999999999;
arr.forEach(function(ele, index) {
if (minNum > ele) {
minNum = ele
}
})
alert(minNum);//输出1
// 封装一个forEach方法
var arr = [3, 4, 5, 56];
function forEach(arr, callBack) { //相当于callback = function(ele,index,array){}回调函数
for (var i = 0; i < arr.length; i++) {
callBack(arr[i], i, arr);
}
}
forEach(arr, function(ele, index, array) {
console.log(ele, index, array);
});
(2)every() 对数组每一项执行给定的函数，原数组不受影响
every：每一个数组成员都会来执行一个回调，根据回调的返回值来决定结果，返回值是一个布尔值
判断arr中的元素是否都大于0，每一个都大于0，结果才为true
var arr = [3, -6, 4, -7, 8, 9];
var flag = arr.every(function(ele, index, array) {
return ele > 0;
});
console.log(flag); //true或false
(3)some() 有一个满足return后面的条件就可以了，原数组不受影响
some：有一个满足return后的条件就可以了，结果为true,如果所有的不满足才为false
判断arr中是否有小于0的值
var arr = [3, -6, 4, -7, 8, 9];
var flag = arr.some(function(ele, index, array) {
return ele < 0;
});
console.log(flag); //true或false
(4)filter() 过滤元素，返回一个新数组
filter原理:filter是对数组中筛选符合要求的元素，并且用这些符合的元素弄成一个新数组，再返回
每一个数组成员都会执行一个回调
根据这个回调return的条件，如果条件为true,将该元素以新数组的元素返回；如果为false过滤掉这个元素
过滤奇数
var arr = [5, 4, 7, 4, 9, 0, 2];
var newArr = arr.filter(function(ele, index, array) {
return ele % 2 == 0;
})
console.log(newArr);
底层实现
function filter(arr, callBack) {
var flag;
var newArr = [];
for (var i = 0; i < arr.length; i++) {
flag = callBack(arr[i], i, arr);
if (flag) {
newArr.push(arr[i]);
}
}
return newArr;
}
var newArr = filter(arr, function(ele, index, array) {
return ele % 2 == 0;
})
console.log(newArr);
(5)map() 返回一个新数组，新数组是原数组的映射
每一个数组成员都会执行一个回调
根据这个回调return后的处理结果，这个结果以新数组的元素返回
var arr = [5, 4, 7, 4, 9, 0, 2];
var newArr = arr.map(function(ele, index, array) {
return ele + 1;
});
console.log(newArr);
(6)reduce() 收敛，返回值是最后一次函数调用的返回值；
收敛，返回值是最后一次函数调用的返回值；
不写return时，默认返回undefined
二.ES6新增数组方法及迭代方式
1. ES6静态方法：
(1)Array.from()
Array.from():方法用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括ES6新增的数据结构Set和Map）
var obj = {
'0': 'a',
'1': 'b',
'2': 'c',
length: 3
}
var newArr = Array.from(obj); //输出['a', 'b', 'c']
function fn() {
var newArr = Array.from(arguments, function(ele, index) {
return ele + 2;
});
console.log(newArr);//输出6，7，8，9
}
fn(4, 5, 6, 7)
(2)Array.of()
方法用于将一组值转换为数组。Array.of总是返回参数值组成的数组。如果没有参数，就返回一个空数组
var arr1 = Array.of();
var arr2 = Array.of(5, 2)
console.log(arr1); //输出[]
console.log(arr2); //输出[5,2]
Array.of方法可以用下面的代码模拟实现：
function ArrayOf() {
return [].slice.call(arguments);
}
(3)copyWithin(index,start,end)
copyWithin(index,start,end):数组实例的copyWithin方法，在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组。
它接受三个参数:
index（必需）：表示复制的位置
start（可选）：表示复制的起始位置，默认为0，负数为倒数
end（可选） ：表示复制的结束位置（不包含）
var arr = [1, 2, 3, 4, 5, 6, 7];
var arr1 = arr.copyWithin(1);
console.log(arr1); //输出1,1,2,3,4,5,6
var arr = [1, 2, 3, 4, 5, 6, 7];
var arr2 = arr.copyWithin(1, 3);
console.log(arr2); //输出1,4,5,6,7,6,7
var arr = [1, 2, 3, 4, 5, 6, 7];
var arr3 = arr.copyWithin(1, 3, 5);
console.log(arr3); //输出1,4,5,4,5,6,7
2. ES6迭代方法：
find(callBack)和findIndex(callBack):数组实例的迭代方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined
(1)find():找元素
var arr = [1, 2, 3, 4, 5, 6, 7];
var ele = arr.find(function(ele, index, array) {
return ele > 5;
})
console.log(ele); //输出6
(2)findIndex():找下标
var arr = [1, 2, 3, 4, 5, 6, 7];
var index = arr.findIndex(function(ele, index, array) {
return ele > 5;
})
console.log(index); //输出5
(3)fill(val):方法使用给定val值，填充一个数组
接收一个参数时：
fill(val):用val填充完整个数组
var arr = [1, 2, 3, 4, 5, 6, 7];
var newArr = arr.fill("a");
console.log(newArr); //输出["a", "a", "a", "a", "a", "a", "a"]
接收三个参数时：
fill(val,start,end):用于指定填充的起始位置和结束位置(不包含end)
var arr = [1, 2, 3, 4, 5, 6, 7];
var newArr = arr.fill("a", 2, 5);
console.log(newArr); //输出[1,2,'a','a','a',6,7]
(4)includes(val)
includes(val)方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。该方法属于ES7，但Babel转码器已经支持
var arr = [1, 2, NaN, 4, 5, 6, 7];
var flag1 = arr.includes(4);
var flag2 = arr.includes(40);
var flag3 = arr.includes(NaN);
console.log(flag1); //输出true
console.log(flag2); //输出false
console.log(flag3); //输出true
