JavaScript实现reduce（）⽅法函数
更新：增加递归实现的⽅法
更新：重构⾮递归实现的⽅法
思路
与之前两篇⽂章( ， ）中的迭代⽅法不⼀样，reduce() 是归并⽅法。
reduce 接收两个参数：
第⼀个参数是在每⼀项上调⽤的函数
该函数接收 4 个参数：
前⼀个值 prev
当前值 cur
项的索引 index
数组对象 array
第⼆个可选参数是作为归并基础的初始值
reduce ⽅法返回⼀个最终的值。
代码表⽰：
归并
与之前的迭代不同，归并不是对每⼀项都执⾏⽬标函数，⽽是可以概括为如下两步：不断地对数组的前两项“取出”，对其执⾏⽬标函数，计算得到的返回值
把上述返回值“填回”数组⾸部，作为新的 array[0]
持续循环执⾏这个过程，直到数组中每⼀项都访问了⼀次
返回最终结果
举例说明
对数组 [1，2，3] 归并执⾏ (prev, cur) => prev + cur，流程如图：
[1, 2, 3] // 取出 1 + 2 ，填回 3
[3, 3] // 取出 3 + 3 ，填回 6
[6] // 最终结果为 6
所以得到 6 。
实现
第⼀版
根据这个思路，得到第⼀版代码如下
// let arr = base ? this.unshift(base) : this;// ⾸进，返回新数组的长度，影响原数组故不能这么写  let initialArr = this;
let arr = at(); //得到副本
if (base) arr.unshift(base); // 当存在归并基础值的参数时，将其从数组⾸部推⼊
let index;
while (arr.length > 2) {
index = initialArr.length - arr.length + 1;
let newValue = fn.call(null, arr[0], arr[1], index, initialArr);
arr.splice(0, 2); // 删除前两项，影响原数组
arr.unshift(newValue);// 把 fn(arr[0],arr[1]) 的结果从数组⾸部推⼊
}
index += 1;
let result = fn.call(null, arr[0], arr[1], index, initialArr);
return result;
};
注意点：
队列⽅法 unshift()
可以从数组⾸部加⼊任意个项，
返回值是新数组的长度
影响原数组
splice() ⽅法，⾼程三将其誉为最强⼤的数组⽅法
删除任意数量的项
指定 2 个参数： （删除起始位置， 删除项个数）
插⼊任意数量的项
指定 3 个参数： （起始位置，0，要插⼊的项）
第⼆个参数 0 即为要删除的个数
替换，即删除任意数量的项的同时，插⼊任意数量的项
指定 3 个参数：（起始位置，要删除的个数， 要插⼊的任意数量的项）返回值
始终是⼀个数组，包含从原始数组中删除的项。
若未删除任何项，返回空数组
影响原数组
改进版
从上⾯的总结可以看出，splice() ⽅法完全可以取代 unshift() ⽅法。
⽽且，第⼀版中存在⼀些重复代码，也可以改进。
由此得到第⼆版代码
let initialArr = this;
let arr = at();
if (base) arr.unshift(base);
let index, newValue;
while (arr.length > 1) {
index = initialArr.length - arr.length + 1;
newValue = fn.call(null, arr[0], arr[1], index, initialArr);
arr.splice(0, 2, newValue); // 直接⽤ splice 实现替换
}
return newValue;
};
检测：
let arr = [1, 2, 3, 4, 5];
let sum = arr.fakeReduce((prev, cur, index, arr) => {
console.log(prev, cur, index, arr);
return prev * cur;
}, 100);
console.log(sum);
输出：
100 1 0 [ 1, 2, 3, 4, 5 ]
100 2 1 [ 1, 2, 3, 4, 5 ]
200 3 2 [ 1, 2, 3, 4, 5 ]
600 4 3 [ 1, 2, 3, 4, 5 ]
2400 5 4 [ 1, 2, 3, 4, 5 ]
12000
最后加上类型检测等
// 第三版
Array.prototype.fakeReduce = function fakeReduce(fn, base) {  if (typeof fn !== "function") {
throw new TypeError("arguments[0] is not a function");
}
let initialArr = this;
typeof arraylet arr = at();
if (base) arr.unshift(base);
let index, newValue;
while (arr.length > 1) {
index = initialArr.length - arr.length + 1;
newValue = fn.call(null, arr[0], arr[1], index, initialArr);
arr.splice(0, 2, newValue); // 直接⽤ splice 实现替换
}
return newValue;
};
递归实现
简易版
const reduceHelper = (f, acc, arr) => {
if (arr.length === 0) return acc
const [head, ...tail] = arr
return reduceHelper(f, f(acc, head), tail)
}
Array.prototype.fakeReduce = function (fn, initialValue) {
const array = this
return reduceHelper(fn, initialValue, array)
}
注：acc 即 accumulator, 累计回调的返回值。它是上⼀次调⽤回调时返回的累积值或 initialValue。升级版
⽀持 cb 函数的全部参数
const reduceHelper = (fn, acc, idx, array) => {
if (array.length === 0) return acc
const [head, ...tail] = array
idx++
return reduceHelper(fn, fn(acc, head, idx, array), idx, tail)
}
Reduce = function (cb, initialValue) {
const array = this
const [head, ...tail] = array
const startIndex = initialValue ? -1 : 0
return initialValue ? reduceHelper(cb, initialValue, startIndex, array) : reduceHelper(cb, head, startIndex, tail)
}
重构⾮递归
Reduce = function (cb, initialValue) {
const array = this
let acc = initialValue || array[0]
const startIndex = initialValue ? 0 : 1
for (let i = startIndex; i < array.length; i++) {
const cur = array[i]
acc = cb(acc, cur, i, array)
}
return acc
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。