arr.push(...items) —— 从尾端添加元素，
arr.pop() —— 从尾端提取元素，
arr.shift() —— 从首端提取元素，
arr.unshift(...items) —— 从首端添加元素。
1、删除数组
数组是对象，所以可以使用delete
let arr = ['dd', 'go', 'home']
delete arr[1]
console.log(arr, arr[1]) // ["dd", '', "home"] undefined
delete obj.key 是通过 key 来移除对应的值。对于对象来说是可以的。但是对于数组来说，我们通常希望剩下的元素能够移动并占据被释放的位置。我们希望得到一个更短的数组。
2、splice它可以做所有事情，添加、删除、插入元素
语法：splice(start,[deleteNum, elem1....elemN])
它从索引start开始修改数组，删除deleteNum个元素并在当前位置插入elem1....elemN
let arr = ["I", "study", "JavaScript"];
arr.splice(1,1);// 从索引 1 开始删除 1 个元素
alert( arr ) // ["I", "JavaScript"]
let arr = ["I","study","JavaScript", "right", "now"];
arr.splice(0, 3, "Let's", "dance");
alert( arr ) // ["Let's", "dance", "right", "now"]
let arr = ["I", "study", "JavaScript"];
// 从索引 2 开始, 删除 0 个元素,然后插入 "complex" 和 "language"
arr.splice(2, 0, "complex", "language");
alert( arr ); // "I", "study", "complex", "language", "JavaScript"
3、arr.slice([start], [end])
let arr = ["t", "e", "s", "t"];
alert( arr.slice(1, 3) ); // e,s（复制从位置 1 到位置 3 的元素）
alert( arr.slice(-2) ); // s,t（复制从位置 -2 到尾端的元素）
4、concat数组合并
5、数组搜索
arr.indexOf(item, from) 从索引 from 开始搜索 item，如果找到则返回索引，否则返回 -1。
arr.lastIndexOf(item, from) —— 和上面相同，只是从右向左搜索。
arr.includes(item, from) —— 从索引 from 开始搜索 item，如果找到则返回 true（译注：如果没找到，则返回 false）。
let arr = [1, 0, false];
alert( arr.indexOf(0) ); // 1
alert( arr.indexOf(false) ); // 2
alert( arr.indexOf(null) ); // -1
alert( arr.includes(1) ); // true
请注意，这些方法使用的是严格相等 === 比较。所以如果我们搜索 false，会精确到的确是 false 而不是数字 0。
如果我们想检查是否包含某个元素，并且不想知道确切的索引，那么 arr.includes 是首选。
此外，includes 的一个非常小的差别是它能正确处理NaN，而不像 indexOf/lastIndexOf：
const arr = [NaN];
alert( arr.indexOf(NaN) ); // -1（应该为 0，但是严格相等 === equality 对 NaN 无效）
alert( arr.includes(NaN) );// true（这个结果是对的）
find 和 findIndex
let result = arr.find(function(item,index,array) {
// 如果返回 true，则返回 item 并停止迭代
// 对于假值（falsy）的情况，则返回 undefined
});
如果它返回 true，则搜索停止，并返回 item。如果没有搜索到，则返回 undefined
arr.findIndex 方法（与 arr.find 方法）基本上是一样的，但它返回找到元素的索引，而不是元素本身。并且在未找到任何内容时返回 -1。
6、sort
let arr = [ 1, 2, 15 ];
arr.sort(function(a,b) { return a - b; });
alert(arr); //1, 2, 15
7、arr.reverse 方法用于颠倒 arr 中元素的顺序。
let arr = [1, 2, 3, 4, 5];
arr.reverse();
alert( arr ); // 5,4,3,2,1
8、split和join
let str = "test";
alert( str.split('') ); // t,e,s,t 字符串拆为字母数组
let arr = ['Bilbo', 'Gandalf', 'Nazgul'];
let str = arr.join(';'); // 使用分号 ; 将数组粘合成字符串
alert( str ); // Bilbo;Gandalf;Nazgul
9、reduce/reduceRight 它们用于根据数组计算单个值。
let value = arr.reduce(function(accumulator,item,index,array) {
// ...
}, [initial]);
accumulator —— 是上一个函数调用的结果，第一次等于 initial（如果提供了 initial 的话）。
item —— 当前的数组元素。
index —— 当前索引。
arr —— 数组本身。
initial —— 初始值
应用函数时，上一个函数调用的结果将作为第一个参数传递给下一个函数。
因此，第一个参数本质上是累加器，用于存储所有先前执行的组合结果。最后，它成为 reduce 的结果。
let arr = [1, 2, 3, 4, 5];
let result = arr.reduce((sum,current) => sum + current, 0);
alert(result); // 15
arr.reduceRight 和 arr.reduce 方法的功能一样，只是遍历为从右到左。
let arr = [];
// Error: Reduce of empty array with no initial value
// 如果初始值存在，则 reduce 将为空 arr 返回它（即这个初始值）。
arr.reduce((sum, current) => sum + current, 10);
所以建议始终指定初始值。
10、Array.isArray
数组是基于对象的，不构成单独的语言类型。
所以 typeof 不能帮助从数组中区分出普通对象
alert(typeof {}); // object
alert(typeof []); // object
alert(Array.isArray({})); // false
alert(Array.isArray([])); // true
11、function camelize(str) {
return str.split('-').map((item, index) => {
return index === 0 ? item : item[0].toUpperCase()+item.slice(1)
}).join('')
}
console.log(camelize('background-color')) // backgroundColor
console.log(camelize('list-style-image')) // listStyleImage
console.log(camelize('-webkit-transition')) // WebkitTransition
12、类数组array-like有索引和length属性的对象，所以看起来很像数组
let arrayLike = {
// 有索引和 length 属性 => 类数组对象
0: "Hello",
1: "World",
length: 2
};
// Error (no Symbol.iterator)
for(letitemofarrayLike){}
可迭代对象和类数组对象通常都 不是数组，它们没有 push 和 pop 等方法。
13、Array.from
有一个全局方法 Array.from 可以接受一个可迭代或类数组的值，并从中获取一个“真正的”数组。然后我们就可以对其调用数组方法了。
let arrayLike = {
0: "Hello",
1: "World",
length: 2};
let arr = Array.from(arrayLike);// (*)
alert(arr.pop()); // World（pop 方法有效）
console.log(arr) // ['Hello', 'World']
let str = 'xy';// 将 str 拆分为字符数组
let chars = Array.from(str);
alert(chars[0]); // x
alert(chars[1]); // y
alert(chars.length); // 2
Array.from与split方法不同，它依赖于字符串的可迭代性，因此就i像for...of一样，可以正确的处理代理对。
其实Array.from就跟下面一些代码做着同样的事：
let str = 'xy'
let chars = []
for (let char of str) {
chars.push(char)
}
console.log(chars) // ['x','y']
14、可以应用 for..of 的对象被称为 可迭代的，Symbol.iterator 方法会被 for..of 自动调用，但我们也可以直接调用它。
