记录 reduce 用法

/**
   *
   * reduce(callback, initVal) 第一个参数是回调函数。第二个参数是初始值，如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。
   * callback接收四个参数：
   *   1、accumulate：累计器。截止当前元素，之前所有的元数组元素被回调函数处理累计的结果。
   *   2、current：当前被执行的数组元素。
   *   3、currentIndex：当前被执行的数组元素索引。
   *   4、sourceArray：原数组，也就是调用reduce方法的数组
  */

/**
   * 累加
  */
  let addition = (arr) => arr.reduce((t, v) => t + v)
  let addition1 = (arr) => arr.reduce((t, v) => t + v, 5)
  let addition2 = (arr) => arr.reduce((t, v) => t + v.age, 0)
  console.log(addition([1, 2, 3, 4])); // 10
  console.log(addition1([1, 2, 3, 4, 5])); // 20
  console.log(addition2([{age: 10}, {age: 20}])); // 30

/**
   * 累乘
  */
  let multip = (arr) => arr.reduce((t, v) => t * v)
  let multip1 = (arr) => arr.reduce((t, v) => t * v, 2)
  console.log(multip([1, 2, 3, 4])); // 24
  console.log(multip1([1, 2, 3, 4])); // 48

/**
   * 求和
  */
  let list = [
    {name: 'aa', id: 5, age: 11},
    {name: 'bb', id: 6, age: 12},
    {name: 'cc', id: 7, age: 13}
  ]
  let total = (arr) => arr.reduce((t, v) => t + v.id * v.age, 0)
  console.log(total(list)); // 218

/**
   * 数组、字符串 倒叙
  */
  let reverseArr = (arr) => arr.reduceRight((t, v) => (t.push(v), t), [])
  let reverseStr = (val) => [].reduceRight.call(val, (t, v) => t + v, '')
  let reverseStr1 = (val) => val.split('').reduceRight((t, v) => t + v)
  console.log(reverseArr([1, 2, 3, 4])); // [4, 3, 2, 1]
  console.log(reverseStr('reduce')); // ecuder
  console.log(reverseStr1('reduce')); // ecuder

/**
   * reduce 实现 map 和 filter
  */
  let list_1 = [1, 2, 3, 4]

  let m = list_1.map(item => item * 2)
  let m1 = list_1.reduce((t, v) => [...t, v * 2], [])
  console.log(m, m1); // [2, 4, 6, 8] [2, 4, 6, 8]

  let f = list_1.filter(item => item > 2)
  let f1 = list_1.reduce((t, v) => v > 2 ? [...t, v] : t, [])
  console.log(f, f1); // [3, 4] [3, 4]

  let mf = list_1.map(item => item * 2).filter(item => item > 2)
  let mf1 = list_1.reduce((t, v) => v * 2 > 2 ? [...t, v * 2] : t, [])
  console.log(mf, mf1); // [4, 6, 8] [4, 6, 8]

/**
   * reduce 实现 some 和 every
  */
  let s = list.some(item => item.age > 12)
  let s1 = list.reduce((t, v) => t || v.age > 12, false)
  console.log(s, s1); // true true

  let e = list.every(item => item.age > 12)
  let e1 = list.reduce((t, v) => t && v.age > 12, true)
  console.log(e, e1); // false false

/**
   * 数组分割
  */
  let seg = (arr, len = 1) => {
    return arr.length
      ? arr.reduce((t, v) => (t[t.length - 1].length === len ? t.push([v]) : t[t.length - 1].push(v), t), [[]])
      : []
  }
  console.log(seg([1, 2, 3, 4, 5], 3)); // [[1, 2, 3], [4, 5]]

/**
   * 求数组并集、交集
  */
  let union = (arr1 = [], arr2 = []) => arr1.reduce((t, v) => (!arr2.includes(v) && t.push(v), t), [])
  console.log(union([1, 2, 3, 4], [1, 4])); // [2, 3]

  let inter = (arr1 = [], arr2 = []) => arr1.reduce((t, v) => (arr2.includes(v) && t.push(v), t), [])
  console.log(inter([1, 2, 3, 4], [1, 4])); // [1, 4]

/**
   * 替换数组元素
  */
  let rep = (arr = [], val = '', start = 0, end = arr.length) => {
    if (start < 0 || start >= end || end > arr.length) {
      return arr
    }

    return [
      ...arr.slice(0, start),
      ...arr.slice(start, end).reduce((t, v) => (t.push(val || v), t), []),
      ...arr.slice(end, arr.length)
    ]
  }
  console.log(rep([1, 2, 3, 4, 5], 'q', 1, 3)); // [1, "q", "q", 4, 5]

/**
   * 扁平化数组
  */
  let flat = (arr) => arr.reduce((t, v) => t.concat(Array.isArray(v) ? flat(v) : v), [])
  console.log(flat([1, [2, [3, 'a']], [2, [5, [6, ['c', 'd']]]]])); // [1, 2, 3, "a", 2, 5, 6, "c", "d"]

/**
   * 数组去重
  */
  let arr3 = (arr) => arr.reduce((t, v) => t.includes(v) ? t : [...t, v], [])
  console.log(arr3([1, 'a', 'a', 2, 2])); // [1, "a", 2]

  let list_2 = [
    {name: 'aa', width: 20},
    {name: 'bb', width: 80},
    {name: 'cc', width: 10},
    {name: 'aa', width: 30},
    {name: 'bb', width: 50},
    {name: 'cc', width: 70},
    {name: 'aa', width: 60},
  ]
  let obj = {}

  let arr4 = (arr) => arr.reduce((t, v) => {
    if (obj[v.name]) {
      obj[v.name]++
      return t
    }
    obj[v.name] = true
    return [...t, v]
  }, [])
  console.log(arr4(list_2)); // [{name: 'aa', width: 20}, {name: 'bb', width: 80}, {name: 'cc', width: 10}]

  let arr5 = (arr) => arr.reduce((t, v) => {
    if (!obj[v.name]) {
      t.push(v)
      obj[v.name] = true
    }
    return t
  }, [])
  console.log(arr5(list_2)); // [{name: 'aa', width: 20}, {name: 'bb', width: 80}, {name: 'cc', width: 10}]

/**
   * 最大、最小值
  */
  let max = (arr) => arr.reduce((t, v) => t > v ? t : v)
  let min = (arr) => arr.reduce((t, v) => t < v ? t : v)
  console.log(max([1, 22, 33, 44])); // 44
  console.log(min([1, 22, 33, 44])); // 1

  let max1 = (arr) => arr.reduce((t, v) => t.age > v.age ? t : v, [])
  let min1 =(arr) => arr.reduce((t, v) => t.age < v.age ? t : v, [])
  console.log(max1([{age: 10}, {age: 20}, {age: 30}])); // {age: 30}
  console.log(min1([{age: 10}, {age: 20}, {age: 30}])); // {age: 10}

/**
   * 数组成员拆解
  */
  let zip = (arr) => arr.reduce(
    (t, v) => (v.forEach((item, i) => t[i].push(item)), t),
    Array.from({length: Math.max(...arr.map(m => m.length))}).map(v => [])
  )
  console.log(zip([['a', 1], ['b', 2]])); // [['a', 'b'], [1, 2]]

/**
   * 统计个数
  */
  let count = (arr) => arr.reduce((t, v) => (t[v] = (t[v] || 0) + 1, t), {})
  console.log(count(['a', 'a', 'b', 'c', 'c'])); // {a: 2, b: 1, c: 2}

/**
   * 查找数组成员位置
  */
  let local = (arr, val) => arr.reduce((t, v, i) => (v === val && t.push(i), t), [])
  console.log(local([1, 2, 3, 3, 2, 1], 1)); // [0, 5]

/**
   * 相同属性分组
  */
  let list_3 = [
    { name: 'a', age: 10 },
    { name: 'b', age: 14 },
    { name: 'c', age: 17 },
    { name: 'a', age: 12 },
    { name: 'c', age: 19 }
  ]
  let attr = (arr, key) => {
    return key
      ? arr.reduce((t, v) => (!t[v[key]] && (t[v[key]] = []), t[v[key]].push(v), t), {})
      : {}
  }
  console.log(attr(list_3, 'name'));
  // {
  //   a: [{ name: 'a', age: 10 }, { name: 'a', age: 12 }],
  //   b: [{ name: 'b', age: 14 }],
  //   c: [{ name: 'c', age: 17 }, { name: 'c', age: 19 }]
  // }

/**
   * 异步累计
  */
  async function asyncTotal(arr = []) {
    return arr.reduce(async (t, v) => {
      let total = await t
      let item = await Todo(v)
      total[v] = item
      return total
    }, Promise.resolve({}))
  }
  // let res = await asyncTotal([1,2,3,4,5]) // 需要在 async 下使用

/**
   * 斐波那契数列
  */
  let fiboSeq = (length = 5) => {
    let arr = [...new Array(length).keys()]
    return arr.reduce((t, v, i) => (i > 1 && t.push(t[i - 1] + t[i - 2]), t), [0, 1])
  }
  console.log(fiboSeq(10)); // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

/**
   * URL参数反序列化
  */
  let paramsURL = () => {
    return location.search.replace(/(^\?)|(&$)/g, '').split('&').reduce((t, v) => {
      let [key, val] = v.split('=')
      t[key] = decodeURIComponent(val)
      return t
    }, {})
  }
  // location: www.baidu.com?a=11&b=22
  console.log(paramsURL()); // {a: '11', b: '22'}

/**
   * URl参数序列化
  */
  let stringifyURL = (value) => {
    return Object.entries(value)
      .reduce((t, v) => `${t}${v[0]}=${encodeURIComponent(v[1])}&`, Object.keys(value).length ? '?' : '')
      .replace(/&$/, '')
  }
  console.log(stringifyURL({a: '11', b: '22'})); // '?a=11&b=22'

/**
   * 返回对象指定键
  */
  let keys = (obj, arr) => {
    return Object.keys(obj)
      .reduce((t, v) => (arr.includes(v) && (t[v] = obj[v]), t), {})
  }
  console.log(keys({a: 1, b: 2, c: 3, d: 4}, ['a', 'c'])); // {a: 1, c: 3}

/**
   * 数组转对象
  */
  let obj5 = (arr) => arr.reduce((t, v) => {
    let {name, ...rest} = v
    t[name] = rest
    return t
  }, {})
  console.log(obj5(list_3));
  // {
  //   a: {age: 12},
  //   b: {age: 14},
  //   c: {age: 19}
  // }

// 数组子集求和
  let arr = [1, 2, 3]
  let total2 = arr.reduce((t, v) => t.concat(t.map(m => m.concat(v))), [[]])
  console.log(total2); // [[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]

/**
   * 九九乘法表
  */
  let arr99 = [...new Array(9).keys()]
    .reduce((t, v, i) => t + [...new Array(i + 1).keys()]
    .reduce((x, y, z) => `${x}${i + 1} * ${z + 1} = ${(i + 1) * (z + 1)}  `, '')
    .trim() + '\n', '\n')

  console.log(arr99);

  // 1 * 1 = 1
  // 2 * 1 = 2  2 * 2 = 4
  // 3 * 1 = 3  3 * 2 = 6  3 * 3 = 9
  // 4 * 1 = 4  4 * 2 = 8  4 * 3 = 12  4 * 4 = 16
  // 5 * 1 = 5  5 * 2 = 10  5 * 3 = 15  5 * 4 = 20  5 * 5 = 25
  // 6 * 1 = 6  6 * 2 = 12  6 * 3 = 18  6 * 4 = 24  6 * 5 = 30  6 * 6 = 36
  // 7 * 1 = 7  7 * 2 = 14  7 * 3 = 21  7 * 4 = 28  7 * 5 = 35  7 * 6 = 42  7 * 7 = 49
  // 8 * 1 = 8  8 * 2 = 16  8 * 3 = 24  8 * 4 = 32  8 * 5 = 40  8 * 6 = 48  8 * 7 = 56  8 * 8 = 64
  // 9 * 1 = 9  9 * 2 = 18  9 * 3 = 27  9 * 4 = 36  9 * 5 = 45  9 * 6 = 54  9 * 7 = 63  9 * 8 = 72  9 * 9 = 81