javascript对对象的reduce()

2020/10/19 12:01 · javascript ·  · 0评论

有一个很好的Array方法reduce()可以从Array中获取一个值。例:

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

但是,对象似乎没有reduce()实现任何方法。

在这种情况下,您真正​​想要的是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

一个办法是到reducekeys()

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

如果要将结果作为对象({ value: ... }),则每次都必须初始化并返回该对象:

Object.keys(o).reduce(function (previous, key) {
    previous.value += o[key].value;
    return previous;
}, { value: 0 });

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;
}, 0);

首先,您不太了解reduce的先前值是什么。

在伪代码中,您拥有return previous.value + current.value,因此该previous值将是下次调用时的数字,而不是对象。

其次,reduce是一个Array方法,而不是Object的方法,并且在迭代对象的属性时不能依赖顺序(请参阅:https//developer.mozilla.org/zh-CN/docs/ JavaScript / Reference / Statements / for ... in,这也适用于Object.keys);所以我不确定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中带有胖箭头函数语法的PS(在Firefox Nightly中已经存在),您可以缩小一点:

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

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

扩展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; '.

n'Joy,伙计们!;-)

您可以使用生成器表达式(多年来在所有浏览器中以及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

您也可以将其添加到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);
    }
}

由于尚未真正确认答案,因此Underscore的解决方案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)

试试这个。它将对其他变量中的数字进行排序。

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)
本文地址:http://javascript.askforanswer.com/javascriptduiduixiangdereduce.html
文章标签: ,   ,   ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!