array.reduce((prev, cur, index, arr)=>{

      },init)

       prev：表示上一次调用时的返回值；或者初始值init；

       cur：表示当前正在处理的数组元素

       index：表示正在处理的数组元素的索引，若提供init，则索引为0，否则索引为1

       arr： 表示将要操作的源数组

       init：表示初始值

       首先，要明确的是，prev表示的是上一次回调时的返回值，或者初始值init，
       在我们第一次调用的时候，
       
       案例1，没有设置init的值，在没有设置init值的情况下，index的索引值是从1开始（prev也可以认为是0），
       其实第一次的时候就隐式调用了prev + cur，你可以理解为是在背后做了pre：0 + cur：1，
       我们在控制台看到的就是整个计算过程，index是1 ~ 6。
       
       在第二个案例中，init设置的值是2，那么就代表prev的初始值是2，那么第一次的时候，index是从0开始的，
       第一次调用的返回结果就是`2 + arr[0]:1 = 3`，整个过程index是从0 ~ 6，共7次
       

	// 案例1
    const arr = [1, 2, 3, 4, 5, 6, 7]
    const sum = arr.reduce((prev, cur, index) => {
      console.log('prev - 上一次调用时的返回值=', prev)
      console.log('cur - 当前正在处理的数组元素=', cur)
      console.log('index - 当前正在处理的数组元素-索引=', index)
      console.log('========================================')
      return prev + cur
    })
    console.log('案例1的sum=', sum)



    // 案例2
    const arr1 = [1, 2, 3, 4, 5, 6, 7]
    const sum1 = arr1.reduce((pre, cur, index) => {
      console.log('案例2的cur=', cur)
      console.log('案例2的index=', index)
      return pre + cur`在这里插入代码片`
    }, 2)
    console.log('案例2的sum=', sum1)


	
	// 案例3
    let allList = [1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6, 7, 8]
    // acc：累加器（即当前的累积值），curr：当前正在处理的元素
    let myLlist = allList.reduce((acc, curr) => {
      const isDuplicate = acc.some(item => item === curr)

      if (!isDuplicate) {
        acc.push(curr)
      }

      return acc
    }, [])
    console.log('myList=', myLlist) // [1, 2, 3, 4, 5, 6, 7, 8]

---

数组扁平化

    let a = []
    let b = [4, 5, 6]
    console.log('a.concat(b)=', a.concat(b)) // [4, 5, 6]


    const arr2 = [1, [2, [3, [4, 5]]], 6]

    const newArr = (arr) => {
      return arr.reduce((pre, cur) => {
        return pre.concat(Array.isArray(cur) ? newArr(cur) : cur)
      }, [])
    }

    console.log(newArr(arr2)) // [1, 2, 3, 4, 5, 6]

---

数组去重

    // 数组去重
    const arr3 = [1, 2, 3, 4, 5, 3, 2, 1, 6, 4, 7, 8]

    // 方法1
    const resultArr = arr3.reduce((pre, cur) => {
      if (!pre.includes(cur)) {
        return pre.concat(cur)
      }
      else {
        return pre
      }
    }, [])
    console.log(resultArr) // [1, 2, 3, 4, 5, 6, 7, 8]

    // 方法2
    const resArr = arr3.reduce((prev, cur) => {
      if (prev.indexOf(cur) === -1) {
        prev.push(cur)
      }
      return prev
    }, [])
    console.log(resArr) // [1, 2, 3, 4, 5, 6, 7, 8]


    // 方法3
    let arr = [1, 2, 1, 2, 3, 5, 4, 5, 3, 4, 4, 4, 4]
    let result = arr.sort().reduce((init, current) => {
      if (init.length === 0 || init[init.length - 1] !== current) {
        init.push(current)
      }
      return init
    }, [])
    console.log(result) // [1,2,3,4,5]

---

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

    let person = ['李白', '雅典娜', '安琪拉', '李白', '诸葛亮', '安琪拉']
    let nameObj = person.reduce((pre, cur) => {
      if (cur in pre) { // 因为设置了初始值init，所有第一次的pre等于init的值，即：{}
        pre[cur]++
      }
      else {
        pre[cur] = 1
      }
      console.log('pre=', pre)
      return pre
    }, {})
    console.log(nameObj) // {李白: 2, 雅典娜: 1, 安琪拉: 2, 诸葛亮: 1}
    /*
      pre= {李白: 1}
      pre= {李白: 1, 雅典娜: 1}
      pre= {李白: 1, 雅典娜: 1, 安琪拉: 1}
      pre= {李白: 2, 雅典娜: 1, 安琪拉: 1}
      pre= {李白: 2, 雅典娜: 1, 安琪拉: 1, 诸葛亮: 1}
      pre= {李白: 2, 雅典娜: 1, 安琪拉: 2, 诸葛亮: 1}
    */