JavaScript уменьшить () на объекте

182

Есть хороший метод 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()реализован ни один метод.

Павел С.
источник
1
Вы используете Underscore.js?
Сетен
Нет. Подчеркивает ли сокращение для объектов?
Павел С.
Я не могу вспомнить Я знаю, что у него есть reduceметод. Я бы проверил там. Тем не менее, решение не кажется таким сложным.
Сетен
1
@Sethen Maleno, @Pavel: да _, есть сокращение для объектов. Не уверен, что он работает случайно или если поддержка объекта была преднамеренной, но вы действительно можете передать объект, как в примере этого вопроса, и он (концептуально) будет for..inвызывать вашу функцию итератора со значениями, найденными в каждом ключе.
Роатин Март

Ответы:

55

Что вы на самом деле хотите в этом случае, так это 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
Дэниэл Бэйли
источник
Это Array.prototype.values ​​(), с которым вы связались - отредактировано сейчас
Джонатан Вуд
281

Одним из вариантов было бы :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 });
Джонатан Лоновски
источник
15
Хороший ответ, но лучше использовать Object.values ​​вместо Object.keys, потому что нас интересуют значения здесь, а не ключи. Должно быть так: Object.values ​​(o) .reduce ((total, current) => total + current.value, 0);
Мина Люк
3
Object.values ​​имеет гораздо худшую поддержку браузера, чем Object.keys, но это не может быть проблемой, если вы используете polyfill или переносите с Babel
duhaime
точно, я использовал это в ключах, которые были получены из модели Монго, и я передал пустой объект в качестве начального значения в результате уменьшения количества ключей, и, поскольку я использовал @babel/plugin-proposal-object-rest-spreadплагин, я распределил значение аккумулятора в Возврат снижения и это работает как обаяние, но я был удивлен, если я делаю что-то не так, потому что я передавал объект первоначальному значению уменьшения, и ваш ответ доказал мне, что я поступил правильно!
a_m_dev
55

Реализация 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);
faboulaws
источник
3
Object.entries(o); // returns [['value',1],['value',2],['value',3]]
faboulaws
1
const [ключ, значение] = пара; Я никогда не видел этого!
Мартин Мизер
9
@ martin-meeser - это называется деструктуризацией. Мы даже можем опустить эту строку, изменив function (total, pair)наfunction (total, [key, value])
Jakub Zawiślak
Хотя entriesэто более чистый способ сделать это keys, он менее производительный. hackernoon.com/…
robdonn
@faboulaws Object.entries (o); // возвращает [["a", {value: 1}], ["b", {value: 2}], ["c", {value: 3}]]
Томас
19

Прежде всего, вы не совсем получить то , что уменьшить «s предыдущее значение.

В вашем псевдокоде, который у вас есть return previous.value + current.value, поэтому previousзначением будет следующий номер вызова, а не объект.

Во-вторых, reduceэто метод Array, а не метод Object, и вы не можете полагаться на порядок при выполнении итерации свойств объекта (см .: https://developer.mozilla.org/en-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;
});

PS в ES6 с синтаксисом функции жирной стрелки (уже в Firefox Nightly) вы можете немного уменьшить:

Object.keys(obj).map(key => obj[key].value).reduce((previous, current) => previous + current);
ZER0
источник
3

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}
Алер Таварес-младший
источник
3

Объект можно превратить в массив с помощью: 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
);
Игорь Сухарев
источник
2

Расширить 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; '.

нет, ребята !! ;-)

user1247458
источник
-1, теперь у вас есть новое перечисляемое свойство для всех будущих объектов: jsfiddle.net/ygonjooh
Johan
1
Пожалуйста, не изменяйте базовый прототип, как этот. Это может привести к большому количеству проблем для будущих разработчиков, работающих в одной и той же кодовой базе
adam.k
Да, это «исправление обезьян» Это решение было написано 6 лет назад и не слишком актуально сейчас, просто имейте в виду, и, например, его будет лучше использовать Object.entries()в 2021 году
user1247458
2

Вы можете использовать выражение генератора (поддерживается во всех браузерах уже несколько лет и в Node), чтобы получить пары ключ-значение в списке, в котором вы можете сократить:

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

>>> [[i, a[i]] for (i in a) if (a.hasOwnProperty(i))]
[["b", 3]]
Янус Троелсен
источник
1

Если вы можете использовать массив, используйте массив, длина и порядок массива вдвое меньше.

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 * /

Kennebec
источник
1

Это не очень сложно реализовать самостоятельно:

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);
    }
}
Фрэнсис Авила
источник
0

Поскольку это еще не подтверждено в ответе, 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
Крис Дельфин
источник
«Попробуйте другую библиотеку» не является полезным
Grunion Шафта
Не полезно для вас
Крис Дельфин
0

Попробуйте эту функцию стрелки один вкладыш

Object.values(o).map(a => a.value, o).reduce((ac, key, index, arr) => ac+=key)
М Томас
источник
0

Попробуй это. Он будет сортировать числа из других переменных.

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)
prgv
источник