前言

下方的代码都通过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.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: 12

Array.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: 1

Array.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: false

Array.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: 4

Array.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: 15

Array.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"]

小程序开发中，splice应用的地方非常多，因为更改数组对象时，不会重新渲染页面，必须使用splice修改数组，才会重新渲染。切记切记。

拓展

普通数组去重

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'}]

点击下方“了解更多”！

更多资源敬请关注！