web-dev-qa-db-ja.com

オブジェクトのJavascript reduce（）

配列から1つの値を取得するためのNice Arrayメソッド 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()メソッドが実装されていないようです。

javascriptarraysobjectreduce
133
Pavel S.

1つの選択肢は、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);

これで、あなたは初期値を指定したいと思うでしょう、あるいは第1ラウンドは'a' + 2になるでしょう。

結果をObject（{ value: ... }）にしたい場合は、毎回オブジェクトを初期化して返す必要があります。

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

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

まず第一に、あなたは reduce の前の値がであるものを完全には得ません。

あなたの疑似コードではreturn previous.value + current.valueを持っているので、previousの値はオブジェクトではなく次回の呼び出し時に数になります。

2つ目は、reduceはObjectのメソッドではなくArrayメソッドであり、オブジェクトのプロパティを反復するときにその順序に頼ることはできません（ https://developer.mozilla.org/ja）を参照）。 -US/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;
});

P.S太い矢印関数の構文を使ったES6（すでにFirefox Nightlyにある）では、少し縮めることができます。

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

この場合に実際に欲しいのは Object.values です。これを念頭に置いて、簡潔なES6の実装を次に示します。

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

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

console.log(total) // 6

または単に：

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

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

console.log(total) // 6
13
Daniel Bayley

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それ、みんな！ ;-)

3
user1247458

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}
2
Alair Tavares Jr

生成式を使用することで（今までのすべてのブラウザとNodeでサポートされています）、リスト内のキーと値のペアを簡単に絞り込むことができます。

>>> a = {"b": 3}
Object { b=3}

>>> [[i, a[i]] for (i in a) if (a.hasOwnProperty(i))]
[["b", 3]]
2
Janus Troelsen

あなたが配列を使うことができるならば、配列を使ってください、配列の長さと順序はその価値の半分です。

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

/ *戻り値：（数値）6 * /

1
kennebec

まだ答えが確認されていないので、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
})

リストオブジェクトに項目が1つしかない場合、_.reduceは唯一の値（オブジェクトまたはその他）を返します。反復関数は呼び出されません。

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

//returns {value: 1} instead of 1
1
Chris Dolphin

オブジェクトは、そのメソッドを使ってその配列表現に変えることができますが、 Object.entries（） 、 Object.keys（） 、 Object.values（） 、それから通常の配列のように縮小されます。メモリとサイクルを節約するために、オブジェクトを反復処理するためだけに中間配列を作成しない方がいいでしょう。

そのため、 Array.prototype.reduce（） を真似たヘルパー関数を作成しました。

const {hasOwnProperty} = Object.prototype;
const reduce = (object, reducer, accumulator) => {
  for (const key in object)
    if (hasOwnProperty.call(object, key))
      accumulator = reducer(accumulator, object[key], key, object);
  return accumulator;
};

あなたもそれを割り当てることができます

Object.reduce = reduce;

この方法はとても便利です。

だからあなたの質問に対する答えはこうなるでしょう：

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
);
1
Igor Sukharev

これを自分で実装するのはそれほど難しくありません。

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);
    }
}
1
Francis Avila

このワンライナー矢印機能を試してみてください

Object.values(o).map(a => a.value, o).reduce((ac, key, index, arr) => ac+=key)
0
M Thomas