SOURCE

// let a =  [1,2,3,4].reduce((acc,cur)=>{
//     console.log(acc)
//     console.log(cur)
//     return acc + cur

// },10)
// console.log(a)

//map 方法接收一个回调函数，函数内接收三个参数，当前项、索引、原数组，返回一个新的数组，并且数组长度不变
let testArr = [1,2,3,4]
// Array.prototype.reduceMap = function(callback){
//     return this.reduce((acc,cur,index,array) =>{
//         const item = callback(cur,index,array)
//         acc.push(item)
//         return acc
//     },[])
// }
// let b = testArr.reduceMap((item,index)=>{
//     return item + index
// })
// console.log(b)
/*
在 Array 的原型链上添加 reduceMap 方法，接收一个回调函数 callback 作为参数（就是 map 传入的回调函数），内部通过 this 拿到当前需要操作的数组，
这里 reduce 方法的第二个参数初始值很关键，需要设置成一个 [] ，
这样便于后面把操作完的单项塞入 acc 。
我们需要给 callback 方法传入三个值，当前项、索引、原数组，
也就是原生 map 回调函数能拿到的值。
返回 item 塞进 acc，并且返回 acc ，
作为下一个循环的 acc（贪吃蛇原理）。最终 this.reduce 返回了新的数组，并且长度不变
*/


//forEach 接收一个回调函数作为参数，函数内接收四个参数当前项、索引、原函数、当执行回调函数 callback 时，用作 this 的值，并且不返回值。
// Array.prototype.reduceForEach = function(callback){
//     this.reduce((acc,cur,index,array)=>{
//         callback(cur,index,array)
//     },[])
// }
// testArr.reduceForEach((item,index,array)=>{
//     console.log(item,index)
// })


Array.prototype.reduceFilter = function (callback) {
   return this.reduce((acc, cur, index, array) => {
    if (callback(cur, index, array)) {
      acc.push(cur)
    }
    return acc
  }, [])
}
let c = testArr.reduceFilter(item => item % 2 == 0) // 过滤出偶数项。
// [2, 4]
console.log(c)

const testObj = [{a:1} , {a:2},{a:3},{a:4}]
Array.prototype.redecuFind = function(callback){
    return this.reduce((acc,cur,index,array)=>{
        if(callback(cur,index,array)){
            if(acc instanceof Array && acc.length ==0){
                acc = cur
            }
        }
        if((index == array.length-1) && acc instanceof Array && acc.length==0){
            acc = undefined
        }
        return acc
    },[])
}
console.log(testObj.redecuFind(item => item.a%2 ==0))

//将二维数组变成一维数组
const testArr1 = [[1,2],[3,4],[5,6,7]]
let A = testArr1.reduce((acc,cur)=>{
    return acc.concat(cur)
},[])
console.log(A)
// 计算数组中元素出现的个数
const testArr2 = [1,3,4,1,3,2,9,8,5,3,2,0,12,10]
let B = testArr2.reduce((acc,cur)=>{
    if(!(cur in acc)){
        acc[cur] = 1
    }else{
        acc[cur]+=1
    }
    return acc

},{})
console.log(B)
//按属性给数组分类
const bills = [
  { type: 'shop', momey: 223 },
  { type: 'study', momey: 341 },
  { type: 'shop', momey: 821 },
  { type: 'transfer', momey: 821 },
  { type: 'study', momey: 821 }
];
let C = bills.reduce((acc, cur) => {
  // 如果不存在这个键，则设置它赋值 [] 空数组
  if (!acc[cur.type]) {
    acc[cur.type] = [];
  }
  acc[cur.type].push(cur)
  return acc
}, {})
console.log(C)
//数组去重
const testArr4 = [1,2,2,3,4,4,5,5,5,6,7]
testArr4.reduce((acc, cur) => {
  if (!(acc.includes(cur))) {
    acc.push(cur)
  }
  return acc
}, [])
// [1, 2, 3, 4, 5, 6, 7]
//求最大值或者最小值
const testArr5 = [
  { age: 20 },
  { age: 21 },
  { age: 22 }
]
testArr5.reduce((acc, cur) => {
  if (!acc) {
    acc = cur
    return acc
  }
  if (acc.age < cur.age) {
    acc = cur
    return acc
  }
  return acc
}, 0)
// {age: 22}