Reduce 的常用写法

一、计算数组的总和

const arr = [1, 2, 3, 4, 5];
const sum = arr.reduce(
  (previousValue, currentValue, currentIndex, array) =>
    previousValue + currentValue
);
console.log(sum); // 15

二、计算数组的平均数

const arr = [1, 2, 3, 4, 5];
const average = arr.reduce(
  (previousValue, currentValue, currentIndex, array) => {
    previousValue += currentValue;
    if (currentIndex === array.length - 1) {
      return previousValue / array.length;
    } else {
      return previousValue;
    }
  }
);
console.log(average); // 3

三、求数组的最大值

const arr = [1, 2, 3, 4, 5];
const max = arr.reduce((previousValue, currentValue, currentIndex, array) =>
  Math.max(previousValue, currentValue)
);
console.log(max); // 5

// 当然还有更好用的办法
console.log(Math.max(...arr)); // 5

四、求数组的最小值

const arr = [1, 2, 3, 4, 5];
const min = arr.reduce((previousValue, currentValue, currentIndex, array) =>
  Math.min(previousValue, currentValue)
);
console.log(min); // 1

// 老规矩
console.log(Math.min(...arr)); // 1

五、数组去重

const arr = [1, 2, 3, 3, 4, 4, 5];
const uniqueArr = arr.reduce(
  (previousValue, currentValue, currentIndex, array) => {
    if (!previousValue.includes(currentValue)) {
      previousValue.push(currentValue);
    }
    return previousValue;
  },
  []
);
console.log(uniqueArr); // [ 1, 2, 3, 4, 5 ]

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

const arr = [1, 2, 3, 3, 4, 4, 5];
const countMap = arr.reduce(
  (previousValue, currentValue, currentIndex, array) => {
    if (!previousValue[currentValue]) {
      previousValue[currentValue] = 1;
    } else {
      previousValue[currentValue]++;
    }
    return previousValue;
  },
  {}
);
console.log(countMap); // { '1': 1, '2': 1, '3': 2, '4': 2, '5': 1 }

七、实现数组分组

const arr = [1, 2, 3, 4, 5];
const result = arr.reduce(
  (previousValue, currentValue, currentIndex, array) => {
    if (currentValue % 2 === 0) {
      previousValue.even.push(currentValue);
    } else {
      previousValue.odd.push(currentValue);
    }
    return previousValue;
  },
  {
    even: [],
    odd: [],
  }
);
console.log(result); // { even: [ 2, 4 ], odd: [ 1, 3, 5 ] }

八、计算数组中连续递增数字的长度

const arr = [1, 2, 3, 5, 6, 7, 8, 9];
const result = arr.reduce(
  (previousValue, currentValue, currentIndex, array) => {
    if (currentIndex === 0 || currentValue !== array[currentIndex - 1] + 1) {
      previousValue.push([currentValue]);
    } else {
      previousValue[previousValue.length - 1].push(currentValue);
    }
    return previousValue;
  },
  []
);
const maxLength = result.reduce(
  (previousValue, currentValue, currentIndex, array) =>
    Math.max(previousValue, currentValue.length),
  0
);
console.log(maxLength); // 5

九、计算对象数组的属性总和

const arr = [
  {
    name: "Alice",
    age: 25,
  },
  {
    name: "Bob",
    age: 30,
  },
  {
    name: "Charlie",
    age: 35,
  },
];
const result = arr.reduce(
  (previousValue, currentValue, currentIndex, array) =>
    previousValue + currentValue.age,
  0
);
console.log(result); // 90

十、将对象数组转换为键值对对象

const arr = [
  {
    name: "Alice",
    age: 25,
  },
  {
    name: "Bob",
    age: 30,
  },
  {
    name: "Charlie",
    age: 35,
  },
];
const result = arr.reduce(
  (previousValue, currentValue, currentIndex, array) => {
    previousValue[currentValue.name] = currentValue.age;
    return previousValue;
  },
  {}
);
console.log(result); // { Alice: 25, Bob: 30, Charlie: 35 }

十一、计算数组中出现次数最多的元素

const arr = [1, 2, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6];
const result = arr.reduce(
  (previousValue, currentValue, currentIndex, array) => {
    previousValue[currentValue] = (previousValue[currentValue] || 0) + 1;
    return previousValue;
  },
  {}
);
const maxCount = Math.max(...Object.values(result));
const mostFrequent = Object.keys(result)
  .filter((key) => result[key] === maxCount)
  .map(Number);
console.log(mostFrequent); // [ 6 ]

十二、实现 Promise 串行执行

const promise1 = () => Promise.resolve("one");
const promise2 = (input) => Promise.resolve(input + " two");
const promise3 = (input) => Promise.resolve(input + " three");

const promises = [promise1, promise2, promise3];
const result = promises.reduce(
  (previousValue, currentValue, currentIndex, array) =>
    previousValue.then(currentValue),
  Promise.resolve("start")
);
result.then(console.log); // one two three

十三、对象属性值求和

const obj = {
  a: 1,
  b: 2,
  c: 3,
};
const result = Object.values(obj).reduce(
  (previousValue, currentValue, currentIndex, array) =>
    previousValue + currentValue
);
console.log(result); // 6

十四、按属性对数组分组

const arr = [
  {
    id: 1,
    name: "John",
  },
  {
    id: 2,
    name: "Mary",
  },
  {
    id: 3,
    name: "Bob",
  },
  {
    id: 4,
    name: "Mary",
  },
];
const result = arr.reduce(
  (previousValue, currentValue, currentIndex, array) => {
    const key = currentValue.name;
    if (!previousValue[key]) {
      previousValue[key] = [];
    }
    previousValue[key].push(currentValue);
    return previousValue;
  },
  {}
);
console.log(result);
/**
 * {
 *  John: [ { id: 1, name: 'John' } ],
 *  Mary: [ { id: 2, name: 'Mary' }, { id: 4, name: 'Mary' } ],
 *  Bob: [ { id: 3, name: 'Bob' } ]
 * }
 */

十五、扁平化数组

const nestedArray = [
  [1, 2],
  [3, 4],
  [5, 6],
];
const flattenedArray = nestedArray.reduce(
  (previousValue, currentValue, currentIndex, array) =>
    previousValue.concat(currentValue),
  []
);
console.log(flattenedArray); // [ 1, 2, 3, 4, 5, 6 ]

十六、合并对象

const obj1 = { a: 1, b: 2 };
const obj2 = { c: 3, d: 4 };
const obj3 = { e: 5, f: 6 };
const mergedObj = [obj1, obj2, obj3].reduce(
  (previousValue, currentValue, currentIndex, array) =>
    Object.assign(previousValue, currentValue),
  {}
);
console.log(mergedObj); // { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 }