unshift、push、shift、pop

• 这4个要领都邑转变原数组
• unshift() 从前面增添元素，push() 从背面追加元素，返回数组长度
• shift() 删除第0个元素，pop() 删除末了一个元素，返回被删除的元素

slice

• 不转变原数组
• slice(m, n)返回原数组索引m（包含）到n（不包含）的元素数组。不传参数默许悉数截取，只传一个参数，从该位置截取到末位。类似于String.prototype.substring

let arr = [1,2,3,4,5]
console.log(arr.slice()); // [ 1, 2, 3, 4, 5 ]
console.log(arr.slice(1)); // [ 2, 3, 4, 5 ]
console.log(arr.slice(2,4)); // [ 3, 4 ]
console.log(arr); // [1,2,3,4,5]

splice

• 转变原数组。
• splice(m,n,e1,e2,e3) 从索引m（包含）到n（不包含）的元素删除数组，再在该位置处增添e1，e2，e3。若n传入0，则只增添；若只传m和n，则只删除；若只传m，则从m位置删除到末位。放回删除元素数组

let arr = [1,2,3,4,5];
console.log(arr.splice(2), arr); // [ 3, 4, 5 ] [ 1, 2 ]
console.log(arr.splice(0,1,2), arr); // [ 1 ] [ 2, 2, 3, 4, 5 ]

concat

• 拼接，不转变原数组

let arr = [1,2,3], arr1 = [4];
console.log(arr.concat(arr1, 5), arr); // [ 1, 2, 3, 4, 5, ] [ 1, 2, 3 ]
console.log([...arr, ...arr1, 5]); // [ 1, 2, 3, 4, 5 ] （对象也能够如许拼接，但反复的会掩盖，相称与 Object.assign）

of 和 from

• of()类似于new Array()，但后者假如传入一个参数，则是设置数组长度。
• from() 把伪数组转换为真数组，类似于[].slice.call()（或许写成Array.prototype.slice.call()）
• 伪数组有DOM集、arguments、{0: ‘zero’, 1: ‘one’, length: 2}

Array.of(1,2,3,4); // [ 1, 2, 3, 4 ]
Array.from({0: 'zero', 1: 'one', length: 2}); // [ 'zero', 'one' ]

推断数组的要领有

• xx instanceof Array
• Array.isArray()
• Object.prototype.toString.call() === ‘[object Array]’

这里补充一点推断范例的技能：

• typeof操作符能够推断出number、boolean、string、function和undefined，而不能推断处详细的Object范例。

  • 推断Array要运用Array.isArray(arr)；
  • 推断null请运用myVar === null；
  • 推断某个全局变量是不是存在用typeof window.myVar === ‘undefined’；
  • 函数内部推断某个变量是不是存在用typeof myVar === ‘undefined’
• 没必要把恣意范例转换为boolean再推断，由于能够直接写if (myVar) {…}，假如须要转换能够用 !!myVar
• 不要运用new Number()、new Boolean()、new String() 建立包装对象；
• 用parseInt()或parseFloat()来转换恣意范例为Number；用String()来转换恣意范例为String，或许直接挪用某个对象的toString()要领；

indexOf 和 includes

• indexOf() 返回索引，不存在就返回 -1。inclues()返回布尔值。
• NaN 不能经由过程indexOf()推断，它是经由过程“===”比较的。

arr = [1, '2', null, NaN];
arr.indexOf(NaN); // -1
arr.includes(NaN); // true

filter、find 和 findIndex

• filter() 返回数组。find() 返回值，不存在就返回 undefined。 findIndex() 返回第一个匹配到的索引，不存在就返回 -1。

// let arr = [1, '2', null, NaN];
// arr.filter(item => typeof item === 'number'); // [1, NaN]
// arr.find(item => typeof item === 'number'); // 1
// arr.findIndex(item => typeof item === 'number'); // 0

some 和 every

• 返回布尔值
• some()用于检测数组中的元素是不是有满足指定前提的；every()用于检测数组中所有元素是不是都相符指定前提。
• 不对空数组举行检测，不转变原数组

let arr = [Array(), [], {}, null]
let res1 = arr.some((item, index, arr) => {
    return Object.prototype.toString.call(item) === '[object Array]'
})
let res2 = arr.every((item, index, arr) => {
    return Object.prototype.toString.call(item) === '[object Array]'
})
console.log(res1,res2); // true false

map 和 forEach

• map() 对数组中的每一个元素举行处置惩罚，获得新的数组，不转变原数组
• forEach() 相称于 for 轮回，返回 undefined，不转变原数组

let res = [0,1,2,3,4].map((item, idx)=> item * idx); // [ 0, 1, 4, 9, 16 ]

reduce

• reduce((accumulator, currentValue, currentIndex, array)=>{}, initValue)
• 第一个参数是迭代器函数，函数的作用是对数组中从左到右的每一个元素举行处置惩罚。第二个可选参数是累加器的初始值。没偶然，累加器第一次的值为currentValue。
• accumulator 累加器，即函数上一次挪用的返回值。第一次的时刻为 initialValue || arr[0]
• currentValue 数组中函数正在处置惩罚的的值，第一次的时刻是 initialValue || arr[1]
• currentIndex 数组中函数正在处置惩罚的的索引
• array 函数挪用的数组

console.log(
    [1,2,3].reduce((a,b,c,d)=>{
        console.log(a,b,c,d);
        return a+b; // 下一次的a
    }, 4)
); // 10
/* 
    4 1 0 [ 1, 2, 3 ]
    5 2 1 [ 1, 2, 3 ]
    7 3 2 [ 1, 2, 3 ] 
*/

固然累乘或许做其他营业也是能够的。