Javascript Array.prototype.reduce的实际用途是什么？

据我所知，这是一个广泛适用的常用函数。问题是

它具有求和值的效果。当然，这不是一个很好的例子，因为他们不能只完成

[0,1,2,3,4].sum（）。

那么，作为一名web开发人员，在现实生活中，我会遇到一个问题，然后想，“啊，这是

reduce

”或者是一个非常模糊的情况，或者是一个常见的情况，我可以使用

reduce

作为一种聪明的解决方法

当然，这不是一个很好的例子，因为他们不能只做

[0,1,2,3,4].sum（）

JavaScript中没有标准的

Array#sum

。这就是它的用途：实现它：

Object.defineProperty(Array.prototype, "sum", {
    value: function() {
        return this.reduce(function(sum, item) { return sum + item; }, 0);
    }
});

（在这个特定的示例中，实际上可以关闭

，0

部分；如果调用

reduce

时没有种子值，则它对回调的第一次调用使用第一个条目作为第一个参数，第二个条目作为secodn。）

或任何其他类型的累积操作，例如产品，可能使用对象属性：

var foos = [
    {foo: 1},
    {foo: 2},
    {foo: 3}
];
var product = foos.reduce(function(p, obj) {
    return p * obj.foo;
}, 0);

var list = [
    {id: 1, name: "John"},
    {id: 2, name: "Carla"},
    {id: 3, name: "Mohammed"}
];
var index = list.reduce(function(o, item) {
    o[item.id] = item;
    return o;
}, {});

或者可能是追加操作：

var list = [
    {name: "John"},
    {name: "Carla"},
    {name: "Mohammed"}
];
var names = list.reduce(function(acc, obj, index) {
    if (index === list.length - 1) {
        return acc + ", and " + obj.name;
    }
    return acc + ", " + obj.name;
});

几乎任何涉及累积值的操作都是我倾向于使用

reduce

的操作

我经常看到的另一个用法（有些人会说是abusage）是，当您想对数组中的每个项执行一些操作时，需要将其添加到新数组或对象中，例如通过对象属性创建数组的交叉索引：

var foos = [
    {foo: 1},
    {foo: 2},
    {foo: 3}
];
var product = foos.reduce(function(p, obj) {
    return p * obj.foo;
}, 0);

var list = [
    {id: 1, name: "John"},
    {id: 2, name: "Carla"},
    {id: 3, name: "Mohammed"}
];
var index = list.reduce(function(o, item) {
    o[item.id] = item;
    return o;
}, {});

我在上面说“有些人会说abusage”的原因是上面的累加器（

o

）实际上没有改变；它的状态会发生变化（我们向它添加属性），但它的值不会发生变化，因此从这个意义上讲，

reduce

并没有用于它的预期目的：构建一个发生变化的值。但我也经常看到这种用法，可能是因为它允许我们在一个表达式中而不是在两个表达式中创建

索引

当然，这不是一个很好的例子，因为他们不能只做
[0,1,2,3,4].sum（）

JavaScript中没有标准的
Array#sum
。这就是它的用途：实现它：

Object.defineProperty(Array.prototype, "sum", {
    value: function() {
        return this.reduce(function(sum, item) { return sum + item; }, 0);
    }
});

（在这个特定的示例中，实际上可以关闭
，0
部分；如果调用
reduce
时没有种子值，则它对回调的第一次调用使用第一个条目作为第一个参数，第二个条目作为secodn。）

或任何其他类型的累积操作，例如产品，可能使用对象属性：

var foos = [
    {foo: 1},
    {foo: 2},
    {foo: 3}
];
var product = foos.reduce(function(p, obj) {
    return p * obj.foo;
}, 0);

var list = [
    {id: 1, name: "John"},
    {id: 2, name: "Carla"},
    {id: 3, name: "Mohammed"}
];
var index = list.reduce(function(o, item) {
    o[item.id] = item;
    return o;
}, {});

或者可能是追加操作：

var list = [
    {name: "John"},
    {name: "Carla"},
    {name: "Mohammed"}
];
var names = list.reduce(function(acc, obj, index) {
    if (index === list.length - 1) {
        return acc + ", and " + obj.name;
    }
    return acc + ", " + obj.name;
});

几乎任何涉及累积值的操作都是我倾向于使用
reduce
的操作

我经常看到的另一个用法（有些人会说是abusage）是，当您想对数组中的每个项执行一些操作时，需要将其添加到新数组或对象中，例如通过对象属性创建数组的交叉索引：

var foos = [
    {foo: 1},
    {foo: 2},
    {foo: 3}
];
var product = foos.reduce(function(p, obj) {
    return p * obj.foo;
}, 0);

var list = [
    {id: 1, name: "John"},
    {id: 2, name: "Carla"},
    {id: 3, name: "Mohammed"}
];
var index = list.reduce(function(o, item) {
    o[item.id] = item;
    return o;
}, {});

我在上面说“有些人会说abusage”的原因是上面的累加器（
o
）实际上没有改变；它的状态会发生变化（我们向它添加属性），但它的值不会发生变化，因此从这个意义上讲，
reduce
并没有用于它的预期目的：构建一个发生变化的值。但是我也经常看到这种用法，可能是因为它允许我们在一个表达式中而不是在两个表达式中创建
索引。
我刚刚在codewars.com上使用了.reduce（）方法进行算法挑战。以下是挑战：

皮特喜欢烤一些蛋糕。他有一些食谱和配料。
不幸的是，他数学不好。你能帮他找到答案吗，
考虑到他的食谱，他能烤多少蛋糕

编写一个函数cakes（），它接受配方（对象）和
可用成分（也是一个对象）并返回最大数量
皮特能烤的蛋糕数（整数）。为了简单起见，没有单元
对于数量（例如，1磅面粉或200克糖）而言，仅为1或
200). 对象中不存在的成分可以
被认为是0

示例：

// must return 2
cakes({flour: 500, sugar: 200, eggs: 1}, {flour: 1200, sugar: 1200, eggs: 5, milk: 200}); 
// must return 0
cakes({apples: 3, flour: 300, sugar: 150, milk: 100, oil: 100}, {sugar: 500, flour: 2000, milk: 2000});

以下是解决方案：

function cakes(recipe, available) {
  return Object.keys(recipe).reduce(function(val, ingredient) {
    return Math.min(Math.floor(available[ingredient] / recipe[ingredient] || 0), val)
  }, Infinity)  
}

我刚刚在codewars.com上使用了.reduce（）方法进行算法挑战。以下是挑战：

皮特喜欢烤一些蛋糕。他有一些食谱和配料。
不幸的是，他数学不好。你能帮他找到答案吗，
考虑到他的食谱，他能烤多少蛋糕

编写一个函数cakes（），它接受配方（对象）和
可用成分（也是一个对象）并返回最大数量
皮特能烤的蛋糕数（整数）。为了简单起见，没有单元
对于数量（例如，1磅面粉或200克糖）而言，仅为1或
200). 对象中不存在的成分可以
被认为是0

示例：

// must return 2
cakes({flour: 500, sugar: 200, eggs: 1}, {flour: 1200, sugar: 1200, eggs: 5, milk: 200}); 
// must return 0
cakes({apples: 3, flour: 300, sugar: 150, milk: 100, oil: 100}, {sugar: 500, flour: 2000, milk: 2000});

以下是解决方案：

function cakes(recipe, available) {
  return Object.keys(recipe).reduce(function(val, ingredient) {
    return Math.min(Math.floor(available[ingredient] / recipe[ingredient] || 0), val)
  }, Infinity)  
}

事实上，我看到了另一个例子；[
他们使用了这种解决方案

 function largestOfFour(arr) {
     return arr.map(function(group){
return group.reduce(function(prev, current) {
  return (current > prev) ? current : prev;
});
    });
}

对于这个问题，返回一个数组，该数组由每个提供的子数组中的最大数组成。为简单起见，提供的数组将正好包含4个子数组。
实际上，我在中看到了另一个示例[
他们使用了这种解决方案

 function largestOfFour(arr) {
     return arr.map(function(group){
return group.reduce(function(prev, current) {
  return (current > prev) ? current : prev;
});
    });
}

对于此问题；返回一个由每个提供的子数组中的最大数组成的数组。为简单起见，提供的数组将正好包含4个子数组。
这与许多其他高阶构造相同。‘aha’时刻只有在使用后才会出现。有时这会导致“太聪明”，但钟摆通常会自行修复。这与许多其他高阶结构相同。‘aha’时刻只有在使用后才会出现。有时这可能会导致“太聪明”，但钟摆通常会自行修复。最佳答案！第一个例子是一个很好的例子，说明可以忽略初始值。-）此外，还原正确的“abusage”（至少我）经常使用