Arrayform的方法(部分 , 详情请参考MDN)

1. concat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

for example :

let arr1 = [1, 2, 3 ]

let arr2 = [4, 5, 6 ]

let arr3 = arr1.concat(arr2)

console.log(arr3)  //输出结果是 [1, 2, 3, 4, 5, 6]

2. every() 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。

for example

[1,2,3,4,5,6].every(x => x>=10 )

    //false 

[30,40,20,25,35].every(x => x>=15)

    //true

3. filter() 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

for example :

[30,40,20,25,35].filter(x => x > 25 )


//return   [30, 40, 35]

4. find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。

let arr = [
    {name : 'apples' , quantity : 2},
    {name : 'bananas' , quantity : 7},
    {name : 'cherries' , quantity : 5},
]

console.log(arr.find(x => x.name))
// { name: 'apples', quantity: 2 }

5. findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1

let arr = [10, 11, 3, 4, 6, 7]

console.log(arr.findIndex(x => x > 11))

// -1

6. flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。

let arr = [10, 11, 3,[ [ [2 , 4] ] ] , 4, 6, 7]

console.log(arr.flat(3))  //数字代表嵌套数组的结构深度,默认值是1

// [ 10, 11, 3, 2, 4,  4, 6, 7 ]

7. Array.from() 方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。

console.log(Array.from('peach'))


// [ 'p', 'e', 'a', 'c', 'h' ]

8. indexOf()方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

语法    arr.indexOf(searchElement[, fromIndex])

searchElement

要查找的元素

fromIndex 可选

开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找 ，以此类推。 注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0.

返回值

首个被找到的元素在数组中的索引位置; 若没有找到则返回 -1

let arr = [1, 3, 4, 5, 3, 5, 6, 7, 4, 2, 1, 3, 5, 6]

let arr1 = []

arr.forEach((item) => {

    if (arr1.indexOf(item) === -1) {

        arr1.push(item)

    }

})

console.log(arr1)

9. join() 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。

 let  a = ['Wind', 'Rain', 'Fire'];

let myVar1 = a.join();      // myVar1的值变为"Wind,Rain,Fire"

let myVar2 = a.join(', ');  // myVar2的值变为"Wind, Rain, Fire"

let myVar3 = a.join(' + '); // myVar3的值变为"Wind + Rain + Fire"

let myVar4 = a.join('');    // myVar4的值变为"WindRainFire"

10. map() 方法创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值

语法  :  

var new_array = arr.map(function callback(currentValue[, index[, array]]) {
 // Return element for new_array 
}[, thisArg])

参数

callback

生成新数组元素的函数，使用三个参数：

currentValue

callback 数组中正在处理的当前元素。

index可选

callback 数组中正在处理的当前元素的索引。

array可选

map 方法调用的数组。

thisArg可选

执行 callback 函数时值被用作this。

返回值  

一个由原数组每个元素执行回调函数的结果组成的新数组。

let arr = [
    {key : 1 ,value : 10},
    {key : 2 ,value : 20},
    {key : 3 ,value : 30}
]

let reformattedArray = arr.map(function (obj) {
    let robj = {}
    robj[obj.key] = obj.value
    return robj
})

console.log(reformattedArray)

// [ { '1': 10 }, { '2': 20 }, { '3': 30 } ]

11. slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。

其中语法  arr.slice([begin[, end]])

参数  :  

begin 可选

提取起始处的索引（从 0 开始），从该索引开始提取原数组元素。

如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。

如果省略 begin，则 slice 从索引 0 开始。

如果 begin 超出原数组的索引范围，则会返回空数组。

end 可选

提取终止处的索引（从 0 开始），在该索引处结束提取原数组元素。slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end）。

slice(1,4) 会提取原数组中从第二个元素开始一直到第四个元素的所有元素 （索引为 1, 2, 3的元素）。

如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。

如果 end 被省略，则 slice 会一直提取到原数组末尾。

如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。

返回值是一个含有被提取元素的新数组。

let myHonda = {color : 'red' , wheels : 4 , engine : {cylinders : 4 , size :2.2}}

let myCar = [myHonda ,2 ,'cherry condition', 'purchased 1997']

let newCar = myCar.slice(0,2)

//输出结果 myCar =  [{"color":"red","wheels":4,"engine":{"cylinders":4,"size":2.2}},2,"cherry 
condition","purchased 1997"]

 newCar =  [{"color":"red","wheels":4,"engine":{"cylinders":4,"size":2.2}},2]

 myCar[0].color = "red"

 newCar[0].color = "red"

12. reduce() 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

语法 : arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

let arr = [1, 3, 4, 5, 6, 7, 8]

let re = arr.reduce((x, y) => x + y)

console.log(re) 

// 34