1、map（）
作用：对数组每一个元素进行映射处理，得到一个全新数组； 语法：回调函数 (元素,下标)=>{ return 新元素 }； 应用场景：映射数组； 特点：
- 函数返回值：新数组
- 回调是否需要return：一定要return（当前元素）
代码：
var arr = [1, 2, 3, 4, 5, 4, 2]
var newArr = arr.map((item, index) => {
return {
id: item,
index,
}
})
console.log(newArr)
//打印结果：
[
{ id: 1, index: 0 },
{ id: 2, index: 1 },
{ id: 3, index: 2 },
{ id: 4, index: 3 },
{ id: 5, index: 4 },
{ id: 4, index: 5 },
{ id: 2, index: 6 }
]
var arr2 = [
{ id: 1, name: '张三', age: 18 },
{ id: 2, name: '李四', age: 28 },
{ id: 3, name: '王五', age: 38 },
]
var newArr2 = arr2.map((item, index) => {
return {
...item,
gender: 1,
}
})
console.log(newArr2)
//打印结果：
[
{ id: 1, name: '张三', age: 18, gender: 1 },
{ id: 2, name: '李四', age: 28, gender: 1 },
{ id: 3, name: '王五', age: 38, gender: 1 }
]
2、filter（）
作用：用于筛选数组中满足条件的元素，返回筛选后的新数组； 应用场景：过滤数组 特点：
- 函数返回值：新数组
- 回调是否需要return：return true（元素添加到新数组）
代码：
var arr3 = [
{ id: 1, name: 'jack', age: 18 },
{ id: 2, name: 'rose', age: 28 },
{ id: 3, name: 'tom', age: 38 }
]
var newArr3 = arr3.filter((item) => {
if (item.id > 1) {
return item
}
})
console.log(newArr3)
//打印结果
[ { id: 2, name: 'rose', age: 28 }, { id: 3, name: 'tom', age: 38 } ]
3、forEach（）
作用：对数组进行遍历循环，对数组中的每一项运行给定的函数，这个方法没有返回值。 应用场景：求数组最大值/最小值； 特点：
- 函数返回值：无
- 回调是否需要return：无
代码：
var arr = [1, 2, 3, 4, 5, 4, 2]
arr.forEach((item) => {
console.log(arr, 99)
})
4、some（）
作用：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true。 注意: 空数组，则返回false 应用场景：找出符合条件的数 特点：
- 函数返回值：布尔类型
- 回调是否需要return：return true ：循环结束
代码：
var arr4 = [
{ id: 1, name: 'jack', age: 18 },
{ id: 2, name: 'rose', age: 28 },
{ id: 3, name: 'tom', age: 38 }
]
var newArr4 = arr4.some((item) => {
return item.id === 4
})
console.log(newArr4) //false
5、every（）
作用：判断数组中每一项都是否满足所给条件，当所有项都满足条件，才会返回true。 注意：空数组，则返回true 应用场景：判断所有元素是否符合条件 特点：
- 函数返回值：布尔类型
- 回调是否需要return：return true ：循环继续
代码：
var arr4 = [1, 2, 3, 4, 5];
var flag = arr4.every(function(value, index) {
return value % 2 === 0;
});
console.log(flag); // false
6、find（）
作用：用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。 语法：find方法的回调函数可以接受三个参数，依次为当前的值、当前的位置和原数组。 特点：
- 函数返回值：有，返回一个对象
- 回调是否需要return：有，只要有条件满足就会返回当前满足项
代码：
[1, 4, -5, 10].find((n) => n < 0)
// -5
[1, 5, 10, 15].find(function(value, index, arr) {
return value > 9;
}) // 10
7、findIndex（）
作用：findIndex方法的用法与find方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。 应用场景：获取符合条件的第一个元素位置（下标） 特点：
- 函数返回值：数字
- 回调是否需要return：return true ：循环结束
代码：
var arr7 = [
{ id: 1, name: '嘻嘻', price: 100, num: 1 },
{ id: 2, name: '哈哈', price: 200, num: 2 },
{ id: 3, name: '嘿嘿', price: 300, num: 3 },
]
var index = arr7.findIndex((item) => {
return item.id === 1
})
console.log(index) //0
8、includes（）
作用：用于判断数组/字符串中是否包含指定的值； 特点：
- 函数返回值：布尔类型
- 回调是否需要return：无回调
代码：
[1, 2, 3].includes(2) // true
9、slice （）
作用：从某个已有的数组返回选定的元素； 特点：截取数据，包头不包尾； 语法： 数组.slice（开始下标，结束下标）
- 1个参数：截取数组中的数据返回一个新的数组，不会影响原数组
- 2个参数：从参数1开始，到参数2的前一位结束 ，相当于[ )
ps: slice(1,3) 从索引1开始到索引2结束
代码：
var arr9 = ['a', 'b', 'c', 'd', 'e', 'f']
console.log(arr9.slice(2, 5), 77) //[ 'c', 'd', 'e' ]
10、splice（）
作用：删除指定位置元素; 语法：数组.splice(起始下标,删除数量) 特点：
- 1个参数：截取数组中的数据返回一个新的数组，会影响原数组 从当前参数的索引开始往后截取 打印原数组返回的是没有被截取的数组
- 2个参数：从参数1开始，到参数2的前一位结束 //[ )
- 3个参数：从参数1开始，删除 参数2 个 元素，增加参数3
代码：
var arr9 = ['a', 'b', 'c', 'd', 'e', 'f']
console.log(arr9.splice(0, 3)) // [ ) 返回要删除的数据abc
console.log(arr9) // 新数据def
console.log(arr9.splice(3)) // def
//参数三：
场景一：删除多少增加多少
console.log(arr9.splice(2, 1, 'r'), 33) // c
console.log(arr9)//['a', 'b', 'r', 'd', 'e', 'f']
场景一：插入，不删增加
console.log(arr9.splice(6, 0, 'hhhh'), 33)
console.log(arr9) //[ 'a', 'b', 'c', 'd', 'e', 'f', 'hhhh']
11、reduce（）
作用：循环遍历数组中的每个元素； 语法：reduce(回调函数，累加器初始值)； 应用：一般用于计算数组的累加和，数组去重 特点：
- 不设置初始值，第一个参数为数组中的第一项，循环次数少一次；
- reduce() 对于空数组是不会执行回调函数的。
- 返回值做下一次循环第一个参数的值，没有返回值默认为undefined；
- 遇到空数组时会报错；
代码：
//场景一：计算数组的累加和
var arr6 = [
{ id: 1, name: 'lining', price: 100, num: 1 },
{ id: 2, name: 'anta', price: 200, num: 2 },
{ id: 3, name: 'nike', price: 300, num: 3 },
{ id: 4, name: 'tebu', price: 400, num: 1 }
]
// var newArr6 = arr6.reduce((sum, item) => {
// return sum += item.price * item.num
// }, 0)
var newArr6 = arr6.reduce((sum, item) => sum + item.price * item.num, 1)
console.log(newArr6)//得到合计金额
/*
场景一：数组去重
arr2===得到处理之后的新数组 []是arr2的初始值
item===arr数组的每一项
*/
var arr = [1, 2, 3, 4, 5, 4, 2]
var newArr7 = arr.reduce((arr2, item) => {
if (!arr2.includes(item)) {
arr2.push(item)
}
return arr2
}, [])
console.log(newArr7)//[ 1, 2, 3, 4, 5 ]
set()方法去重数组
var arr = [1, 2, 3, 4, 5, 4, 2]
//Array.from伪数组转真数组
var newArr8 = Array.from(new Set(arr))
console.log(newArr8) ////[ 1, 2, 3, 4, 5 ]
