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);