Javascript对象上的reduce()
Javascript reduce() on Object
有一个很好的数组方法reduce()
从数组中获得一个值。例子:
[0,1,2,3,4].reduce(function(previousValue, currentValue, index, array){
return previousValue + currentValue;
});
用对象实现相同的最好方法是什么?我想这样做:
{
a: {value:1},
b: {value:2},
c: {value:3}
}.reduce(function(previous, current, index, array){
return previous.value + current.value;
});
然而,Object似乎没有实现任何reduce()
方法。
一种选择是reduce
为keys()
:
var o = {
a: {value:1},
b: {value:2},
c: {value:3}
};
Object.keys(o).reduce(function (previous, key) {
return previous + o[key].value;
}, 0);
有了这个,你将需要指定一个初始值,否则第一轮将是'a' + 2
。
如果您希望结果为Object ({ value: ... }
),则必须每次初始化并返回对象:
Object.keys(o).reduce(function (previous, key) {
previous.value += o[key].value;
return previous;
}, { value: 0 });
在这种情况下,您实际需要的是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
ES6实现: Object.entries()
const o = {
a: {value: 1},
b: {value: 2},
c: {value: 3}
};
const total = Object.entries(o).reduce(function (total, pair) {
const [key, value] = pair;
return total + value.value;
}, 0);
首先,你不知道reduce之前的值是多少
在您的伪代码中,您有return previous.value + current.value
,因此previous
的值将是下一次调用时的一个数字,而不是一个对象。
第二,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中使用fat箭头函数的语法(已经在Firefox Nightly中),您可以缩小一点:
Object.keys(obj).map(key => obj[key].value).reduce((previous, current) => previous + current);
让我总结一下可能性。其目的总是从对象中生成一个数组。为此有各种Javascript对象函数。对于每个单独的函数,都有不同的解释方法。因此,它总是取决于我们的对象是什么样子的,以及我们想要做什么。
在上面的例子中,它是一个有三个对象的对象。
const obj = {
a: {value: 1},
b: {value: 2},
c: {value:3}
};
与种对象。Keys只提供对象的键。
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(),这取决于你和你想做什么。
1:
[{value:5}, {value:10}].reduce((previousValue, currentValue) => { return {value: previousValue.value + currentValue.value}})
>> Object {value: 15}
2:
[{value:5}, {value:10}].map(item => item.value).reduce((previousValue, currentValue) => {return previousValue + currentValue })
>> 15
3: [{value:5}, {value:10}].reduce(function (previousValue, currentValue) {
return {value: previousValue.value + currentValue.value};
})
>> Object {value: 15}
对象可以通过object .entries()、object .keys()、object .values()转换为数组,然后再缩减为数组。但是您也可以在不创建中间数组的情况下减少对象。
我已经创建了一个小的辅助库odict来处理对象。
npm install --save odict
它有reduce
函数,工作方式非常像Array.prototype.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
);
Extend Object.prototype.
Object.prototype.reduce = function( reduceCallback, initialValue ) {
var obj = this, keys = Object.keys( obj );
return keys.reduce( function( prevVal, item, idx, arr ) {
return reduceCallback( prevVal, item, obj[item], obj );
}, initialValue );
};
使用示例。
var dataset = {
key1 : 'value1',
key2 : 'value2',
key3 : 'value3'
};
function reduceFn( prevVal, key, val, obj ) {
return prevVal + key + ' : ' + val + '; ';
}
console.log( dataset.reduce( reduceFn, 'initialValue' ) );
'Output' == 'initialValue; key1 : value1; key2 : value2; key3 : value3; '.
享受吧,伙计们!!: -) 您可以使用生成器表达式(在所有浏览器中支持多年,在Node中支持)来获得列表中的键值对,您可以减少:
>>> a = {"b": 3}
Object { b=3}
>>> [[i, a[i]] for (i in a) if (a.hasOwnProperty(i))]
[["b", 3]]
如果你可以使用数组,一定要使用数组,数组的长度和顺序是其价值的一半。
function reducer(obj, fun, temp){
if(typeof fun=== 'function'){
if(temp== undefined) temp= '';
for(var p in obj){
if(obj.hasOwnProperty(p)){
temp= fun(obj[p], temp, p, obj);
}
}
}
return temp;
}
var O={a:{value:1},b:{value:2},c:{value:3}}
reducer(O, function(a, b){return a.value+b;},0);
/*返回值:(Number)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
你也可以把它添加到对象原型中:
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);
}
}
试试这个。它将从其他变量中排序数字。
const obj = {
a: 1,
b: 2,
c: 3
};
const result = Object.keys(obj)
.reduce((acc, rec) => typeof obj[rec] === "number" ? acc.concat([obj[rec]]) : acc, [])
.reduce((acc, rec) => acc + rec)
如果作为数组处理就容易多了
返回水果总数:
let fruits = [{ name: 'banana', id: 0, quantity: 9 }, { name: 'strawberry', id: 1, quantity: 1 }, { name: 'kiwi', id: 2, quantity: 2 }, { name: 'apple', id: 3, quantity: 4 }]
let total = fruits.reduce((sum, f) => sum + f.quantity, 0);
由于尚未在答案中得到确认,因此下划线的reduce
也适用于此。
_.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
试试这个一行箭头函数
Object.values(o).map(a => a.value, o).reduce((ac, key, index, arr) => ac+=key)
- 对一个对象使用reduce可以返回一个没有't在数组中包含目标字母
- 我们可以用参数对象集合而不是原始数据来调用JavaScript collection.reduce()方法吗
- 为什么 Array.prototype.reduce() 不接受 Map 对象作为初始值
- 如果数组中只有一个对象,则Lodash返回错误的reduce结果
- 使用JavaScript's Reduce从对象数组创建数组
- 如何在 CouchDB 中将对象属性从 reduce 合并到重新归约函数
- 如果对象使用 reduce、forEach 或筛选器共享属性值,则合并 JSON 数组中的对象
- reduce为面向对象的javascript
- 如何在对象内部执行递归reduce函数
- 试图理解reduce使用对象作为previousValue
- Javascript函数计算对象属性的嵌套数组,可能使用reduce/map
- Javascript reduce函数在这个对象上不起作用
- 使用reduce将Javascript对象转换为查询字符串
- MongoDB map reduce使用嵌套对象
- 数组的第一个对象没有被传递给reduce()的initialValue参数
- 匹配' reduce/scan '的累加器函数中可观察对象的类型
- 调用reduce to sum对象数组返回NaN
- Javascript对象上的reduce()
- 使用Reduce将数组转换为对象
- MongoDB对对象字段进行Map Reduce