1、数组方法

创建数组

使用数组字面量[]创建数组： const ninjas = ["Kuma", "Hattori", "Yagyu"];

使用内置 Array 构造函数创建数组： const samurai = new Array("Oda", "Tomoe");

数组字面量与数组构造函数

使用数组字面量创建数组优于数组构造函数。主要原因很简单：[]与 new Array()（2 个字符与 11 个字符）。此外，由于 JavaScript 的高度动态特性，无法阻止修改内置的 Array 构造函数，也就意味着 new Array()创建的不一定是数组。因此，推荐坚持使用数组字面量。

改变数组长度

对超出数组边界的索引写入元素将扩充数组：

let arr = [1,2]; 
arr.length = 3;
// arr: [1,2,, empty]

手动修改数组的 length 属性为更小数值，将会删除多余的元素：

let arr = [1,2,3,4]
arr.length = 2
// arr: [1,2]

在数组两端添加、删除元素

在每个数组中，可以使用内置的 push 方法在数组末尾添加元素，同时改变数组的长度：

ninjas.push("Kuma"); // ninjas: ["Kuma"]; 
ninjas.push("Hattori"); // ninjas: ["Kuma", "Hattori"];

使用内置的 unshift 方法可以在数组起始位置添加元素：

ninjas.unshift("Yagyu");// ninjas: ["Yagyu", "Kuma", "Hattori"];

调用pop方法从数组末尾删除元素，减小数组长度：

var lastNinja = ninjas.pop(); // ninjas:["Yagyu", "Kuma"] // lastNinja: "Hattori"

使用 shift 方法从数组起始位置删除元素：

var firstNinja = ninjas.shift(); //ninjas: ["Kuma"]
//firstNinja: "Yagyu"

性能考虑：

pop 和 push 与 shift 和 unshift pop 和 push 方法只影响数组最后一个元素：pop 移除最后一个元素，push 在数组末尾增加元素。shift 和 unshift 方法修改第一个元素，之后的每一个元素的索引都需要调整。因此， pop 和 push 方法比 shift 和 unshift 要快很多，非特殊情况不建议使用 shift 和 unshift 方法。

在数组任意位置添加、删除元素

删除数组元素的粗略方法，使用 delete 操作符删除元素

const ninjas = ["Yagyu", "Kuma", "Hattori", "Fuma"]; 
delete ninjas[1];

虽然删除了元素的值，但是数组长度仍然为 4。我们在数组中创建了一个空元素；这种删除数组元素的方法无效，只是在数组中创建了一个空元素。数组仍然有 4 个元素，其中我们想要删除的元素是 undefined；

在数组任意位置删除、添加元素

splice 具有两个参数：起始索引和需要移除的元素个数（这个参数如果不传，会一直删除元素直到数组末尾的元素）。，索引是 1 的元素被删除，后续元素自动相应移动。同时，splice 方法返回被移除的元素数组。

removedItems = ninjas.splice(1, 2, "Mochizuki", "Yoshi", "Momochi"); 

//ninjas: ["Yagyu", "Mochizuki", "Yoshi", "Momochi"] 

//removedItems: ["Hattori", "Fuma"]

2、数组常用操作

数组遍历

使用 forEach 方法：

const ninjas = ["Yagyu", "Kuma", "Hattori"]; 
ninjas.forEach(ninja => { 
    assert(ninja !== null, ninja); 
));

提供回调函数（本例中是箭头函数），遍历每一个数组元素时立即执行。不需要考虑起始索引、结束条件和计步器。JavaScript 引擎解决了全部问题。这段代码更易理解，并且会减小缺陷的发生。

映射数组

是将数组中的每个元素的属性映射到新数组的元素上，JavaScript 的 map 函数可以实现便捷操作，内置的 map 方法创建了一个全新的数组，然后遍历输入的数组。对输入数组的每个元素，在新建的数组上，都会基于回调函数的执行结果创建一个对应的元素。

验证数组元素是否匹配指定的条件

处理集合的元素时，常常遇到需要知道数组的全部元素或部分元素是否满足某些条件。为了尽可能有效地编写这段代码，JavaScript 数组具有内置的 every 和 some 方法：

const ninjas = [ 
{name: "Yagyu", weapon: "shuriken"},
{name: "Yoshi" },
{name: "Kuma", weapon: "wakizashi"}
];
const allNinjasAreNamed = ninjas.every(ninja => "name" in ninja); 
const allNinjasAreArmed = ninjas.every(ninja => "weapon" in ninja);

内置的 every 方法接收回调函数作为参数，会对每个元素执行该回调函数。如果所有数组元素的回调结果都返回 true 时，every 方法将返回 true，否则返回 false；

const someNinjasAreArmed = ninjas.some(ninja => "weapon" in ninja);

内置的 some 方法接收回调函数作为参数。只要至少有一项元素的回调结果返回 true， some 方法就返回 true，否则返回 false；

查找特定数组元素

find

const ninjas = [ 
    {name: "Yagyu", weapon: "shuriken"},
    {name: "Yoshi" },
    {name: "Kuma", weapon: "wakizashi"}
]; 
const ninjaWithWakizashi = ninjas.find(
    ninja => { 
        return ninja.weapon === "wakizashi";
})

使用 find 方法查找满足回调函数中指定条件的第 1 个元素

const ninjaWithKatana = ninjas.find(
    nina => { 
        return ninja.weapon === "katana"; 
   });

如果未查找到满足条件的元素，使用 find 方法返回 undefined;查找满足一定条件的数组元素很容易：使用内置的 find 方法，传入回调函数，针对集合中的每个元素调用回调函数，直到查找到目标元素。由回调函数返回 true; 如果数组中没有一项返回 true 的元素，则查找的结果是 undefined。

filter

const armedNinjas = ninjas.filter(ninja => "weapon" in ninja);

使用filter方法查找满足条件的多个元素;

如果需要查找满足条件的多个元素，可以使用 filter 方法，该方法返回满足条件的多个元素的数组。

indexOf

使用内置的 indexOf 方法查找特定元素的索引，传入目标元素作为参数:ninjas.indexOf("Yoshi")

有时在数组中具有多个指定的元素（如 Yoshi），查找最后一次 Yoshi 出现的索引，可以使用 lastIndexOf 方法 ninjas.lastIndexOf("Yoshi")

在大多数情况下，当不具有目标元素的引用时，可以使用 findIndex 方法查找索引: const yoshiIndex = ninjas.findIndex(ninja => ninja === "Yoshi");

findIndex 方法接收回调函数，并返回第一个回调函数返回 true 的元素。本质上 findIndex 与 find 方法类似，唯一的区别是 find 方法返回元素本身，而 findIndex 方法返回元素的索引.

数组排序

array.sort((a, b) => a – b);

JavaScript 引擎实现了排序算法。我们需要提供回调函数，告诉排序算法相邻的两个数组元素的关系。可能的结果有如下几种:

● 如果回调函数的返回值小于 0，元素 a 应该出现在元素 b 之前。

● 如果回调函数的返回值等于 0，元素 a 和元素 b 出现在相同位置。

● 如果回调函数的返回值大于 0，元素 a 应该出现在元素 b 之后。

使用 reduce 合计数组元素

const numbers = [1, 2, 3, 4];
const sum = numbers.reduce((aggregated, number) => aggregated + number, 0);
assert(sum === 10, "The sum of first four numbers is 10");

educe 方法接收初始值，对数组每个元素执行回调函数，回调函数接收上一次回调结果以及当前的数组元素作为参数。最后一次回调函数的结果作为 reduce 的结果;

JS之集合篇