es6 reduce 函数的使用 (reduce真香)

        var arr = [3, 9, 4, 3, 6, 0, 9];
        // 原理: 利用reduce特性 prev初始值设置0 并把函数的返回值再次带入函数中
        var sum = arr.reduce(function (prev, cur) { // prev 初始为0 以后则为函数返回的值
            return prev + cur; // 数组各项之间的和
        }, 0);
        // 原理 利用reduce特性 进行三木运算最终返回最大的值
        var max = arr.reduce(function (prev, cur) {
            // return Math.max(prev, cur); // 数组里面的最大值
            return prev > cur ? prev : cur // 三元表达式写法
        });
        let max = arr[0]; // 进行三木运算最终返回最大的值
        for (let i = 0; i < arr.length - 1; i++) {
            max = max < arr[i + 1] ? arr[i + 1] : max
        }
        // 数组 去重
        // 原理: 利用 indexof()判断是否有值 再利用 && 运算遇到false就返回原理 防止再次添加 最终返回处理后的值
        var newArr = arr.reduce(function (prev, cur) {
            prev.indexOf(cur) === -1 && prev.push(cur); // 数组去重 indexof没有找到就返回-1 && 遇到false返回如果没有遇到则返回最后一个表达式
            return prev;
            /** 基本原理
             * 1. 初始化一个空数组
             * 2. 找不到就添加,找到就不添加
             */
        }, []);
        // 数组 对象 去重 
        // 原理: 创建第三个对象变量 有就直接返回 没有 就添加进一个新的数组里面
        // 数组对象去重本质 利用一个新创建的对象去和 原数组对象进行匹配 有的则忽略没有则添加进数组里面
        let person = [{
                id: 0,
                name: "小明"
            },
            {
                id: 1,
                name: "小张"
            },
            {
                id: 2,
                name: "小李"
            },
            {
                id: 3,
                name: "小孙"
            },
            {
                id: 1,
                name: "小周"
            },
            {
                id: 2,
                name: "小陈"
            },
        ];

        let obj123 = {}; // 创建一个对象用来判断有没有

        person = person.reduce((cur, next) => {
            obj123[next.id] ? "" : obj123[next.id] = true && cur.push(next); // 存在设置为空直接返回
            return cur; //                                                          如果不存在就设置为true 放行 执行后面的添加函数
        }, []) //设置cur默认类型为数组，并且初始值为空的数组
        // console.log(person);
        // 打印老大 , 老二和老三
        // 原理: if判断进行 每一次的返回处理 用到了 reduce 的第三个第四个参数
        const objArr = [{
            name: '老大'
        }, {
            name: '老二'
        }, {
            name: '老三'
        }];
        const res = objArr.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;
            }
        }, '');
        // console.log(res);
        let y =objArr.reduce((a,b,index,arr)=>{ // 这里主要用到reuce的index 和 arr 三四两个参数 
            if (index=== 0) {
                return b.name
            }
            if (index === (arr.length-1)) {
                return a + ' ' + b.name
            }
            if (index == 1) {
                return a + ' , ' + b.name
            }
        })
        // 求字符串中字母出现的次数
        // 原理: 先把字符串转为数组 再利用对象 给对象属性值设置一个数字 依次累加
        const str = 'sfhjasfjgfasjuwqrqadqeiqsajsdaiwqdaklldflas-cmxzmnha';
        let foo = str.split('').reduce((accumulator, cur) => { // 先把字符串转为数组 利用split函数
            accumulator[cur] ? accumulator[cur]++ : accumulator[cur] = 1; // accumulator[cur]等价于 accumulator.cur accumulator.cur = 1
            return accumulator; // 先用一个空对象进行处理 把每一个设置为数字 1 // 第二次遍历的时候 让数字累加 就可以判断 字符串哪个数字最多
        }, {}); 
        // console.log(foo);
        // 数组内部值得平方 对数组每一个元素进行设置
        // 原理: 空数组依次添加 处理后的元素值
        var arr1 = [2, 3, 4, 5, 6]; // 每个值的平方
        var newarr = arr1.reduce((accumulator, cur) => {
            accumulator.push(cur * cur);
            return accumulator; // 必须要单独返回 要不然报他不是一个函数
        }, []);
        // console.log(arr1);
        // 数组转为对象 
        // 原理: 设置一个空对象 对空对象进行往里面 添加属性 ( 这个属性最好设置为对应的数字 )  并且赋值
        var streams = [{
            name: '技术',
            id: 1
        }, {
            name: '设计',
            id: 2
        }];
        var obj = streams.reduce((accumulator, cur) => {
            accumulator[cur.id] = cur; // 等价于 accumulator.1 = { name:' 技术', id: 1}
            return accumulator;
        }, {});
        // console.log(obj[1]);
        // 扁平化处理  
        // 原理: 新建一个空数组 依次与后面数组合并
        var arr = [
            [1, 2, 8],
            [3, 4, 9],
            [5, 6, 10]
        ];
        var dd = arr.reduce((x, y) => {
            return x.concat(y)
        }, []);
        // console.log(dd);
        /* 高级用法
         *  多维的叠加执行操作
         */
        var result = [{
                subject: 'math',
                score: 88
            },
            {
                subject: 'chinese',
                score: 95
            },
            {
                subject: 'english',
                score: 80
            }
        ];
        var dis = {
            math: 0.5,
            chinese: 0.3,
            english: 0.2
        };
        var res3 = result.reduce((accumulator, cur) => {
            dis[cur.subject] * cur.score + accumulator
        }, 0);
        // console.log(res3);

**

• 把数组分割

**

		function c(array) {
			let index = 0;
			let n = [];
			while (index < array.length) {
				n.push(array.slice(index, index += 3));
			}
			return n;
		}
		var Array = [1, 2, 3, 4, 5, 6, 7];;
		var u = c(Array);
		console.log(u);

		var Array = [1, 2, 3, 4, 5, 6, 7];
		var a = []
		Array.reduce((n) => {
			if (n < Array.length) {
				a.push(Array.slice(n, n + 3))
				return n + 3
			}
		}, 0)
		console.log(a);