数组常用方法

forEach()
map() —— 更新数组
filter()、includes()、find()、findIndex() —— 筛选（删除）数组
some()、every() —— 判断数组
reduce() —— 叠加数组

一、forEach() 遍历

遍历数组全部元素，利用回调函数对数组进行操作，自动遍历数组.length次，会修改原来的数组，不会返回执行结果，无法break中途跳出循环，不可控 （ for循环可以跳出循环）

不支持return操作输出，return只用于控制循环是否跳出当前循环

语法：Array.forEach((item,index,arr)=>{}); item当前元素、index当前索引、arr原数组

let arr = [1,6,9,10,100,25];
const r=arr.forEach((item,index)=>arr[index]=item*2);
console.log(r);// undefined
console.log(arr);// [2, 12, 18, 20, 200, 50]

二、map()

把一个数组映射成一个新数组，可以逐个改变数组，创建并返回一个新数组（不改变原数组）。

map() 方法按照原始数组元素顺序依次处理元素。

注意： map() 不会对空数组进行检测。

注意： map() 不会改变原始数组。

语法：let newArray = oldArray.map((item, index, arr) => {}) item当前元素、index当前索引、arr原数组

let arr = [1,6,9,10,100,25];
const newArr=arr.map(item=>{if(item %2===0) item=item*10 ;return item });// 偶数*10
console.log(newArr);// [1, 60, 9, 100, 1000, 25]  返回的是每一项运算后的结果的数组
console.log(arr);// [1,6,9,10,100,25]
// 注意
const newArr2=arr.map(item=>item%2===0)  // 返回的是布尔值组成的数组
console.log(newArr2);// [false, true, false, true, true, false]

let arr = [1,2,3].map(function(item){
	return `<li>${item}</li>`      //['<li>1</li>','<li>2</li>','<li>3</li>']
})
arr.join('')                       //<li>1</li><li>2</li><li>3</li>

三、filter()

1.创建新数组
2.不改变原数组
3.输出的是 判断为true的数组元素 组成的新数组
4.使用return操作输出，会循环数组每一项，并在回调函数中操作

语法：array.filter((item,index,arr),=>thisValue) item当前元素、index当前索引、arr原数组

var arr = [1,2,3,4,5] ;
var newArr = arr.filter((item,index)=>{
		return item>2&&item<5 ;         //根据判断为true来遍历循环添加进新数组
})
console.log(newArr);                            //打印新数组
console.log(arr);                               //打印原数组，map()没有改变原数组

四、includes() 

只是判断数组是否含有某值，不用return，不用回调函数，输出一个true或false

语法：array.includes(item)  item 数值

var arr = [1,2,3,4,5] ;
var new1 = arr.includes(5);    //不用回调函数，且是完全匹配才行如原数组是55则flase（实用性不如正则）
console.log(new1);
console.log(arr);

五、 find()

1.不创建新数组

2.不改变原数组

3.find() 方法为数组中的每个元素都调用一次函数执行：

4.输出的是一旦 判断为true 则跳出循环输出符合条件的数组元素

5.使用return操作输出，会循环数组每一项，并在回调函数中操作

如果没有符合条件的元素返回 undefined

注意: find() 对于空数组，函数是不会执行的。

语法：array.find((item, index, arr)=>thisValue) item(数组元素)、index(序列)、arr(数组本身)

var arr = ['Apple', 'pear', 'orange'];
console.log(arr.find((s) =>{
    return s.toLowerCase() === s;
})); // 'pear', 因为pear全部是小写
 
console.log(arr.find((s) => {
    return s.toUpperCase() === s;
})); // undefined, 因为没有全部是大写的元素

六、 findIndex()

返回第一个符合条件的索引,参数为回调函数

1.不创建新的数据；

2.原数组保持不变；

3.当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数，如果没有符合条件的元素返回 -1；

4.使用return操作输出，会循环数组每一项，并在回调函数中操作

注意: findIndex() 对于空数组，函数是不会执行的。

语法：Array.findIndex((value,index,arr) => thisValue) ；value当前值，index当前索引，arr原数组

let arr = [1,6,9,10,100,25];
const r= arr.findIndex((value,index,arr) => { return value > 2}) // 2
console.log(r);//1

let arr2 = [{name:'语文',score:120},{name:'数学',score:130},{name:'英语',score:113}];
let index = arr2.findIndex(item => item.name === "数学");
console.log(index);// 返回第一个符合条件的索引值1   找不到返回-1

七、 some()

用于检测数组中的元素是否满足指定条件（函数提供),判断数组所有元素是否有符合条件的 返回 Boolean 布尔值：true/false。

只要有一项符合条件就为true

1.不创建新数组

2.不改变原数组

3.如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。如果没有满足条件的元素，则返回false。

4.使用return操作输出，会循环数组每一项，并在回调函数中操作。

注意： some() 不会对空数组进行检测。

注意： some() 不会改变原始数组。

语法 ：array.some((item,index,arr)=>thisValue)item当前值，index当前索引，arr原数组

let arr = [1,6,9,10,100,25];
const s = arr.some(item => item > 2);// 判断是否有大于2的
console.log(s);// true 

 八、every()

用于检测数组所有元素是否都符合指定条件（通过函数提供），判断数组所有元素是否全部符合条件 返回 Boolean 布尔值：true/false，全部符合才为true。

every() 方法使用指定函数检测数组中的所有元素：

1、不创建新数组；

2、原数组保持不变；

3、如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测，如果所有元素都满足条件，则返回 true；

4、使用return操作输出，会循环数组每一项，并在回调函数中操作。

注意： every() 不会对空数组进行检测。

语法：array.every((item,index,arr)=>thisValue) item当前值，index当前索引，arr原数组

let arr = [1,6,9,10,100,25];
const e = arr.every(item => item > 2);// 判断是否都大于2
console.log(e);// false

 九、reduce()

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。

不一定在数学意义上的叠加计算，这里叠加指的是：可以利用前遍历操作的结果到下一次遍历使用，重复叠加使用下去。

1、创建一个新数组；

2、原数组保持不变；

3、输出的是 return 叠加什么就输出什么 新数组；

4、回调函数后的改变第一项参数。（不影响原数组）

5、使用return操作输出，会循环数组每一项，并在回调函数中操作

reduce() 可以作为一个高阶函数，用于函数的 compose。

注意: reduce() 对于空数组是不会执行回调函数的。

语法：array.reduce((prev，cur，index，arr)=> initialValue) 

prev(第一次为数组第一项，之后为上一操作的结果)

cur(当前元素)

index(当前元素的索引)

arr(当前元素所属的数组对象)

 例子一：没有初始值

let arr = [1, 2, 3, 4];
let sum = arr.reduce(function(prev, cur, index, arr) {
    console.log(prev, cur, index);
    return prev + cur;
})
console.log(arr, sum);
// 输出结果
// 1 2 1
// 3 3 2
// 6 4 3
// [1,2,3,4] 10

由此可见，如果没有给初始值，arr的第一个值会被作为初始值，因此arr长度是4，而reduce只能循环3次。

例子二：有初始值：

let  arr = [1, 2, 3, 4];
let sum = arr.reduce(function(prev, cur, index, arr) {
    console.log(prev, cur, index);
    return prev + cur;
},0) //这里设置初始值为0
console.log(arr, sum);
// 输出结果
// 0 1 0
// 1 2 1
// 3 3 2
// 6 4 3
// [1,2,3,4] 10

有初始值时，arr长度是4，reduce循环4次。

注意: reduce() 对于空数组是不会执行回调函数的。 当不给初始值且arr为空数组是会报错，所以通常建议设置初始值。

reduce()的简单用法：

1.用reduce求和、求积

let  arr = [1, 2, 3, 4];
let sum = arr.reduce((prev,cur) => prev + cur)
let mul = arr.reduce((prev,cur) => prev * cur)
console.log( sum ); //求和，10
console.log( mul ); //求积，24

2.对象中的属性求和

var result = [
    {
        food: '薯片',
        calories: 1000
    },
    {
        food: '薯条',
        calories: 800
    },
    {
        food: '薯粉',
        calories: 200
    }
];
let sumCalories = arr.reduce((prev,cur)=>{
  return prev + cur.calories
},0)
console.log( sumCalories ); // 2000

reduce()的进阶用法：

1.计算数组中每个元素出现的次数

let animal = ['dog', 'cat', 'mouse', 'fish', 'cat'];
let animalNum = animal.reduce((prev, cur) => {
    if (prev[cur]) {
      prev[cur]++
    } else {
      prev[cur] = 1
    }
    return prev
    }, {})
console.log(animalNum);//{dog: 1, cat: 2, mouse: 1, fish: 1}

2.数组去重

    let arr = [1, 3, 4, 4, 2, 1, 1, 8]
    let newArr = arr.reduce((prev, cur) => {
      if (!prev.includes(cur)) {
        return prev.concat(cur)
      } else {
        return prev
      }
    }, [])
    console.log(newArr);//[1, 3, 4, 2, 8]

3.将二维数组转为一维数组

    let arr = [[0, 1], [2, 3], [4, 5]]
    let newArr = arr.reduce((prev, cur) => {
      return prev.concat(cur)
    }, [])
    console.log(newArr);//[0, 1, 2, 3, 4, 5]

4.将多维数组转为一维数组

    let arr = [[0, 1], [2, 3], [4, [5, 6, 7]]]
    const newArr = function (arr) {
      return arr.reduce((prev, cur) => {
        return prev.concat(Array.isArray(cur) ? newArr(cur) : cur)
      }, [])
    }
    console.log(newArr(arr));//[0, 1, 2, 3, 4, 5, 6, 7]