第1类:索引方法indexOf()和lastIndexOf()

这两个方法是判断数组里是否有这个元素(全等比较),有的话返回数组里的下标,没有的话返回-1,它们唯一区别是一个是从前往后找,另一个是从后往前找.

var arr = [1, 7, 5, 7, 1, 3];

console.log(arr.indexOf(7));//1,从前往后找,返回下标
console.log(arr.indexOf('7'));//-1,它会执行全等的方式进行比较.

console.log(arr.lastIndexof(7));//3,返回下标
console.log(arr.indexOf('7'));//-1,它会执行全等的方式进行比较.
第2类:迭代方法forEach(),filter(),map(),some(),every(),reduce()

这五个方法都接收一个函数，函数里有三个参数，数组当前项的值、当前项在数组中的索引、数组对象本身。注意，这几种方法都不会改变原数组。

1.forEach()方法:

遍历数组,跟for …in 基本一样,这个方法写法比较方便,所以如果是遍历数组,推荐用这种方法.

var arr = [1, 7, 5, 7, 1, 3];

arr.forEach(function(v,index,arr){
    console.log(v);//得到每一项值   
})

forEach()方法规律:就是普通的遍历方法,写法比较简单.

2.filter()方法:过滤数组,里面有一个return 返回一个布尔值,返回一个满足布尔值的新数组.

遍历数组,里面判断数组元素是否满足某个条件,满足的话在函数里面返回出来,最终组成一个新数组.

var arr = [32, 33, 16, 18, 40]

var newArr=arr.filter(v=>{
    if(v>18){
        return true;
    }
})
console.log(newArr);//[32, 33, 40],返回满足条件的新数组.
var arr = [12, 66, 4, 88, 3, 7];
	let newArr=	arr.filter(v=>{
		return v>10;
	})
	console.log(newArr)//[12, 66, 88]
3.map()方法:有return,操作数组,返回经过处理后的新数组.

遍历数组,返回一个新数组,只不过它是返回数组处理后的新数组.

let arr = [{
      name: "佩奇",
      male: "不详",
      type: '对象'
    },
    {
      name: "路飞",
      male: "男",
      type: '对象'
    },
    {
      name: "娜美",
      male: "女",
      type: '对象'
    },
    {
      name: "乔巴",
      male: "男",
      type: '对象'
    },
  ]

  let newArr=arr.map(v=>{
     return v.name
  })

  console.log(newArr);// ["佩奇", "路飞", "娜美", "乔巴"]
let arr2=[1,2,3,4]
  let newArr2=arr2.map(v=>(//这里使用了es6里的()返回,所以可以不用return
     v*2
  ))
  console.log(newArr2)//[2,4,6,8]
4.some()方法:是否有满足,有字很重要,只要有一项满足就结束返回true,如果全部都不满足返回false,只返回一个布尔值.

判断数组中是否存在(只要一个满足即可)符合条件的元素,将结果返回,返回的不是数组,是布尔值.

let arr = [{
      name: "佩奇",
      male: "不详",
      type: '对象'
    },
    {
      name: "路飞",
      male: "不详",
      type: '对象'
    },
    {
      name: "娜美",
      male: "不详",
      type: '对象'
    },
    {
      name: "乔巴",
      male: "男",
      type: '对象'
    },
  ]

  let res = arr.some(v => {
    return v.male == '不详'//有,结果是true
  })
  console.log(res);//true
var arr = [12, 66, 4, 88, 3, 7];
let flag=arr.some(v=>{
	console.log(v)
	return v>80
})
console.log(flag)//true
5.every()方法:里面有return,判断每个是否都满足条件,找到不满足就结束返回false,如果全部满足才是true

判断数组中是否存在(要求数组中全部项都要满足)符合条件的元素,将结果返回,返回的不是数组,是布尔值.

// es5数组方法补充
  let arr = [{
      name: "佩奇",
      male: "不详",
      type: '对象'
    },
    {
      name: "路飞",
      male: "不详",
      type: '对象'
    },
    {
      name: "娜美",
      male: "不详",
      type: '对象'
    },
    {
      name: "乔巴",
      male: "男",
      type: '对象'
    },
  ]

  let res2 = arr.every(v => {
    
    return v.male == '不详'
  })
  console.log(res2);//false 有一个不满足,结果false
6.reduce()方法:参数1是函数,返回处理后的值

用来循环数组,并返回每个元素经过处理后的总结果.
比如:可用来计算数组的和

//reduce:可以拿来计算数组元素之和.
    /* 
    arr.reduce(function(prev, cur, index, arr){
      ...
    }, init)

    arr 表示将要处理的原数组；
    prev 表示上一次调用回调时的返回值，或者初始值 init;
    cur 表示当前正在处理的数组元素；
    index 表示当前正在处理的数组元素的索引，若提供 init 值，则索引为0，否则索引为1；
    init 表示初始值。
    */

    let arr = [1, 5, 6]
    let fn = (prev, cur) => {
        // console.log(prev);//10,11,16
        // console.log(cur);//1,5,6
        // var result=prev + cur
        // console.log(result);//11,16,22
        return prev + cur
    }
    let totle = arr.reduce(fn, 10)
    // console.log(arr);//[1, 5, 6]原数组不变
    console.log(totle);//22

更清晰的案例:

const array1 = [1, 2, 3, 4];
const reducer = (accumulator, currentValue) => accumulator + currentValue;

// 1 + 2 + 3 + 4
console.log(array1.reduce(reducer));//10
// expected output: 10

// 5 + 1 + 2 + 3 + 4
console.log(array1.reduce(reducer, 5));//15
// expected output: 15