一个对象可以通过以下方法转换为数组:object .entries()， object .keys()， object .values()，然后被还原为数组。但是，您也可以在不创建中间数组的情况下缩减对象。

我创建了一个小的帮助库odict用于处理对象。

npm install --save odict

它有一个类似于Array.prototype.reduce()的reduce函数:

export const reduce = (dict, reducer, accumulator) => {
  for (const key in dict)
    accumulator = reducer(accumulator, dict[key], key, dict);
  return accumulator;
};

你也可以把它分配给:

Object.reduce = reduce;

因为这个方法非常有用!

所以你问题的答案是:

const result = Object.reduce(
  {
    a: {value:1},
    b: {value:2},
    c: {value:3},
  },
  (accumulator, current) => (accumulator.value += current.value, accumulator), // reducer function must return accumulator
  {value: 0} // initial accumulator value
);

首先，你不太清楚reduce之前的值是什么。

在你的伪代码中，你已经返回先前的。值+电流。值，因此前一个值在下一次调用时将是一个数字，而不是一个对象。

其次，reduce是一个Array方法，而不是Object的方法，当你迭代一个对象的属性时，你不能依赖顺序(参见:https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements/for...in，这应用于Object。键);所以我不确定在对象上应用reduce是否有意义。

然而，如果顺序不重要，你可以有:

Object.keys(obj).reduce(function(sum, key) {
    return sum + obj[key].value;
}, 0);

或者你可以映射对象的值:

Object.keys(obj).map(function(key) { return this[key].value }, obj).reduce(function (previous, current) {
    return previous + current;
});

附注:在ES6中使用胖箭头函数的语法(已经在Firefox Nightly中)，你可以缩小一点:

Object.keys(obj).map(key => obj[key].value).reduce((previous, current) => previous + current);

在这种情况下，你真正想要的是Object.values。下面是一个简明的ES6实现:

const add = {
  a: {value:1},
  b: {value:2},
  c: {value:3}
}

const total = Object.values(add).reduce((t, {value}) => t + value, 0)

console.log(total) // 6

或者仅仅是:

const add = {
  a: 1,
  b: 2,
  c: 3
}

const total = Object.values(add).reduce((t, n) => t + n)

console.log(total) // 6

这并不难自己实现:

function reduceObj(obj, callback, initial) {
    "use strict";
    var key, lastvalue, firstIteration = true;
    if (typeof callback !== 'function') {
        throw new TypeError(callback + 'is not a function');
    }   
    if (arguments.length > 2) {
        // initial value set
        firstIteration = false;
        lastvalue = initial;
    }
    for (key in obj) {
        if (!obj.hasOwnProperty(key)) continue;
        if (firstIteration)
            firstIteration = false;
            lastvalue = obj[key];
            continue;
        }
        lastvalue = callback(lastvalue, obj[key], key, obj);
    }
    if (firstIteration) {
        throw new TypeError('Reduce of empty object with no initial value');
    }
    return lastvalue;
}

在行动:

var o = {a: {value:1}, b: {value:2}, c: {value:3}};
reduceObj(o, function(prev, curr) { prev.value += cur.value; return prev;}, {value:0});
reduceObj(o, function(prev, curr) { return {value: prev.value + curr.value};});
// both == { value: 6 };

reduceObj(o, function(prev, curr) { return prev + curr.value; }, 0);
// == 6

你也可以把它添加到Object原型中:

if (typeof Object.prototype.reduce !== 'function') {
    Object.prototype.reduce = function(callback, initial) {
        "use strict";
        var args = Array.prototype.slice(arguments);
        args.unshift(this);
        return reduceObj.apply(null, args);
    }
}

由于它还没有在答案中得到证实，因此下划线的减少也适用于此。

_.reduce({ 
    a: {value:1}, 
    b: {value:2}, 
    c: {value:3} 
}, function(prev, current){
    //prev is either first object or total value
    var total = prev.value || prev

    return total + current.value
})

注意,_。如果列表对象只有一项，Reduce将返回唯一的值(对象或其他)，而不调用迭代器函数。

_.reduce({ 
    a: {value:1} 
}, function(prev, current){
    //not called
})

//returns {value: 1} instead of 1

让我总结一下可能性。目标始终是用对象创建一个数组。这里有各种Javascript对象函数。对于每个单独的函数，都有不同的解释方法。它总是取决于我们的对象是什么样子的以及我们想要做什么。

在上面的例子中，它是一个有三个对象的对象。

const obj = { 
    a: {value: 1}, 
    b: {value: 2}, 
    c: {value:3} 
};

与种

对象。键只给我们对象的键。

const arr = Object.keys(obj);
// output arr: 
[a, b, c]

const result = arr.reduce((total, key) => {
    return sum + obj[key].value;
}, 0);
// output result
// 6

与Object.value

Object.value()返回数组中的每一个值。

const arr = Object.value(obj);
// output arr
[
   {value: 1},
   {value: 2},
   {value: 3},
]

const result = arr.reduce((total, singleValue) => {
   return total + singleValue.value;
}, 0);

// output result
// 6

// Or the short variant
const resultShort = Object.values(obj).reduce((t, n) => t + n.value, 0)

// output resultShort
// 6

与Object.entries

对象。Entries将每个单独的对象值分割为一个数组。

const arr = Object.entries(obj)
// output arr
[
  ["a", {visitors: 1}],
  ["b", {visitors: 2}],
  ["c", {visitors: 4}]
]

const result = arr.reduce((total, singleArr) => {
  return total + singleArr[1].value;
}, 0);

// output result
// 6

使用reduce还是使用数组函数map()取决于你自己和你想做什么。