reduce用法

前言

关于reduce，参考了一些文章，结合自己实际运用整理出来，后续有用到的案例持续更新~

一、简介

描述：接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值

使用：array.reduce( function(total, currentValue, currentIndex, arr), initialValue)

• total：计算结束后的返回值（必需）

• currentValue： 当前元素（必需）

• currentIndex：当前元素的索引（可选）

• arr： 当前元素所属的数组对象（可选）

• initialValue: 传递给函数的初始值，相当于初始total（可选）

  tips：关于参数名称
   1.特定场景便于理解，可以取以下名称：
    (1)求和的前两个参数用：total、num
    (2)累加的第一个参数用：count		
   2.笔者常用：pre、cur、index、arr，初始值看情况给 ‘’ 或 [] 或 {}
    - previous：以前的
    - current：现在的
  

二、使用

1.求和

//1.数组求和
let arr = [10, 20, 30];
//(1)基础使用：两个必需参数
let sum1 = arr.reduce((total, num) => total + num);            //sum1: 60
//(2)基于1，加上初始值
let sum2 = arr.reduce((total, num) => total + num, 10);        //sum2: 70
//(3)基于2，变换下展示形式
function getSum(total, num) {
    return total + num;
}
let sum3 = arr.reduce(getSum, 10);                             //sum3: 70

//2.对象数组求和
let obj = [
  { subject: '1', score: 10 },
  { subject: '2', score: 20 },
  { subject: '3', score: 30 }
];
let sum4 = obj.reduce((total, cur) => total + cur.score, -10); //sum4: 50

2.选出数组最大值

let arr = [10, 20, 30];
let max1 = arr.reduce( (pre,cur) => pre>cur ? pre : cur);      //max1: 30
let max2 = arr.reduce( (pre,cur) => pre>cur ? pre : cur, 40);  //max2: 40

3.数组对象处理数据（index、arr）

let obj = [{name: '老大'}, {name: '老二'}, {name: '老三'}, {name: '老四'}];
let res = obj1.reduce((pre, cur, index, arr) => {
	if (index === 0) {
		return cur.name;
	} else if (index === (arr.length - 1)) {
    	return pre + '和' + cur.name;
	} else {
    	return pre + '、' + cur.name;
	}
}, '');                                       //res: "老大、老二、老三和老四"

4.统计字符串中字母出现的次数

let str = 'abcabcabcabc';
let res = str.split('').reduce((obj, cur) => {           //split切割转数组
	obj[cur] ? obj[cur]++ : obj[cur] = 1;
	return obj;
}, {});                                         //res: {a: 4, b: 4, c: 4}

5.数组转数组，数组转对象

//1.数组转数组：求平方
let arr = [10, 20, 30];
let newarr = arr.reduce((accumulator, cur) => {
	accumulator.push(cur * cur);
	return accumulator;
}, []);                                        //newarr: [100, 400, 900]
//2.数组转对象：[{},{}] --> {a:{}, b:{}}
let arr = [{num: '10', des: 'des1'}, {num: '20', des: 'des2'}];
var obj = arr .reduce((accumulator, cur) => {
	accumulator[cur.des] = cur;
	return accumulator;
}, {});                                      //obj：{des1: {}, des2: {}}

6.扁平一个二维数组

let arr = [[1, 2], [3, 4], [5, 6]];
let newarr = arr.reduce((x, y) => x.concat(y), []); 
                                                   //[1, 2, 3, 4, 5, 6]
                                                   

7.对象数组去重

//1.根据单条属性去重
let arr = [
	{id: 1, name: '张三'},
	{id: 2, name: '张三'},
	{id: 3, name: '李四'},
	{id: 4, name: '李四'},
]
let hash = {};
let newArr = arr.reduce((pre, cur) => {
	if (!hash[cur.name]) {
		hash[cur.name] = true;
		pre.push(cur);
	}
	return pre;
}, [])                                                //newArr: 剩1、3两条数据
//2.根据多条属性去重
let arr = [
	{id: 1, name: '张三'},
	{id: 1, name: '张三'},
	{id: 2, name: '李四'},
	{id: 2, name: '李四'},
]
let hash = {};
let newArr = arr.reduce((pre, cur) => {
	const hashId = `${cur.name}_${cur.id}`;
	if (!hash[hashId]) {
		hash[`${cur.name}_${cur.id}`] = true;
		pre.push(cur);
	}
	return pre;
}, [])                                               //newArr: 剩1、3两条数据