ES6中Array数组你应该知道的操作
前言
上一次我们讲解了JavaScript的Array，了解了很多关于Array的属性，方法等。相信大家收益颇多，今天为大家带来更深次的了解，希望您可以学习更多。如果您还没有了解上一课程，请点击：你对JavaScript的Array对象了解有多少？ 下方的代码都通过ES6语法，所以您需要先熟悉它。下面我们直奔主题。
Array.from()
Array.from() 方法从一个类似数组或可迭代对象中创建一个新的数组实例。
console.log(Array.from('Javan'));
// output: Array ["J", "a", "v", "a", "n"]
console.log(Array.from([1, 2, 3], x => x + x));
// output: Array [2, 4, 6]Array.isArray()
Array.isArray(obj) 用于确定obj是否是一个 Array。
Array.isArray([1, 2, 3]);
// true
Array.isArray({foo: 123});
// false
Array.isArray("Javan");
// false
Array.isArray(undefined);
// falseArray.every()
Array.every() 测试数组的所有元素是否都通过了指定函数的测试。
let array1 = [2, 30, 39, 29, 10, 13];
console.log(array1.every(currentValue=>currentValue>1));
// output: true判断array1里面的每一个元素是否都大于1， 是返回true，否返回false
Array.fill()
arr.fill(value[, start[, end]]) 用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。
1. 用来填充数组元素的值。
2. 起始索引，默认值为0(可选)。
3. 终止索引，默认值为 this.length。
填充的元素区间是 [start, end) , 一个半开半闭区间
let array1 = [1, 2, 3, 4];
// 用0替换array1从下标2到4的元素，不等于4
console.log(array1.fill(0, 2, 4));
// output: [1, 2, 0, 0]
// 用5替换array1从下标1后面的所有元素
console.log(array1.fill(5, 1));
// output: [1, 5, 5, 5]
// 6替换array1所有元素
console.log(array1.fill(6));
// output: [6, 6, 6, 6]Array.filter()
let new_array = arr.filter(callback(element[, index[, array]])[, thisArg]) 方法创建一个新数组, 通过callback函数过滤所有元素。
let names = ['Javan', 'Owen', 'Jim', 'Nova'];
let result = names.filter(name => name.length > 4);
console.log(result);
// output: Array ["Javan"]只取数组names里面元素长度大于4的，所以得到只有Javan
Array.find()
arr.find(callback[, thisArg]) 返回数组中满足callback函数的第一个元素的值，否则返回 undefined。
let array1 = [5, 12, 8, 110, 88];
let found = array1.find(element => {
return element > 10;
});
console.log(found);
// output: 12Array.findIndex()
arr.findIndex(callback[, thisArg]) 看方法名字就知道和上面的find()对应，上面直接输出元素，findIndex()肯定是输出满足条件元素的下标。
let array1 = [5, 12, 8, 110, 88];
let index = array1.findIndex(element => {
return element > 10;
});
console.log(index);
// output: 1Array.forEach()
Array.forEach() 遍历数组
let array1 = ['j', 'a', 'v', 'a', 'n'];
array1.forEach(element=> {
console.log(element);
});
// output: "j"
// output: "a"
// output: "v"
// output: "a"
// output: "n"Array.includes()
Array.includes() 用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。
let array1 = [1, 2, 3];
console.log(array1.includes(2));
// output: true
let names = ['Javan', 'Owen', 'Jim'];
console.log(names.includes('Javan'));
// output: true
console.log(names.includes('Nova'));
// output: falseArray.keys()
Array.keys() 方法返回一个新的Array迭代器，它包含数组中每个索引的键。
let array1 = ['j', 'a', 'v', 'a', 'n'];
let iterator = array1.keys();
for (let key of iterator) {
console.log(key);
}
// output: 0
// output: 1
// output: 2
// output: 3
// output: 4Array.map()
Array.map() 创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
let array1 = [2, 4, 6, 8];
let map1 = array1.map(item => item * 2);
console.log(map1);
// output: Array [4, 8, 12, 16]Array.reduce()
arr.reduce(callback[, initialValue]) 数组中的每个元素（从左到右）应用一个函数，将其减少为单个值。
1. accumulator 累加器累加回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（如下所示）。
2. currentValue 数组中正在处理的元素。
3. currentIndex 数组中正在处理的当前元素的索引。 如果提供了initialValue，则索引号为0，否则为索引为1。
4. initialValue 用作第一个调用 callback的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。
let array1 = [1, 2, 3, 4];
let reducer = (accumulator, currentValue) => accumulator + currentValue;
// 1 + 2 + 3 + 4
console.log(array1.reduce(reducer));
// output: 10
// 5 + 1 + 2 + 3 + 4
console.log(array1.reduce(reducer, 5));
// output: 15Array.reduceRight()
Array.reduceRight() 与 Array.reduce() 对应，不过是从右至左。
let array1 = [[0, 1], [2, 3], [4, 5]].reduceRight(
(accumulator, currentValue) => accumulator.concat(currentValue)
);
console.log(array1);
// output: Array [4, 5, 2, 3, 0, 1]Array.some()
Array.some() 测试数组中的某些元素是否通过由提供的函数实现的测试。
let array = [1, 2, 3, 4, 5];
console.log(array.some(item=> item > 4));
// output: true判断array是否有元素大于4，有返回true， 无返回false。
Array.sort()
Array.sort() 对数组的元素进行排序，并返回数组。 sort 排序不一定是稳定的。默认排序顺序是根据字符串Unicode码点。
let months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);
// output: Array ["Dec", "Feb", "Jan", "March"]
let nums = [1, 30, 4, 21];
nums.sort();
console.log(nums);
// output: Array [1, 21, 30, 4]
let names = ['Javan', 'Owen', 'Jim'];
names.sort();
console.log(names);
// output: Array ["Javan", "Jim", "Owen"]Array.splice()
array.splice(start[, deleteCount[, item1[, item2[, ...]]]]) 通过删除现有元素和/或添加新元素来更改一个数组的内容。
1. start 指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从-1计数）；如果负数的绝对值大于数组的长度，则表示开始位置为第0位。
2. deleteCount 整数，表示要移除的数组元素的个数。如果 deleteCount 是 0，则不移除元素。这种情况下，至少应添加一个新元素。如果 deleteCount 大于start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。
3. item1, item2, ... 要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。
// 从第2位开始删除0个元素，插入“Nova”
let names1 = ['Javan', 'Owen', 'Jim'];
names1.splice(2, 0, "Nova");
console.log(names1);
// output: Array ["Javan", "Owen", "Nova", "Jim"]
// 删除第2个元素
let names2 = ['Javan', 'Owen', 'Jim'];
names2.splice(2, 1);
console.log(names2);
// output: Array ["Javan", "Owen"]
// 删除第2个开始删除1个元素，插入“Nova”
let names3 = ['Javan', 'Owen', 'Jim'];
names3.splice(2, 1, 'Nova');
console.log(names3);
// output: Array ["Javan", "Owen", "Nova"]
// 从第1位开始删除所有元素
let names4 = ['Javan', 'Owen', 'Jim'];
names4.splice(1);
console.log(names4);
// output: Array ["Javan"]拓展
普通数组去重
let arr = [1, 2, 3, 3];
let resultarr = [...new Set(arr)];
console.log(resultarr);
// output Array [1,2,3]JSON数组去重
let emps = [{
name: 'Javan',
age: '28'
},{
name: 'Owen',
age: '25'
},{
name: 'Javan',
age: '23'
}];
// 根据name去重
let hash = {};
emps = emps.reduce((item, next) => {
if (hash[next.name] ? '' : hash[next.name] = true) {
item.push(next);
}
return item;
}, []);
console.log(emps);
// output Array [{name: 'Javan',age: '28'},{name: 'Owen',age: '25'}]