web-dev-qa-db-fra.com

Meilleure façon de sommer une valeur de propriété dans un tableau

J'ai quelque chose comme ça:

$scope.traveler = [
            {  description: 'Senior', Amount: 50},
            {  description: 'Senior', Amount: 50},
            {  description: 'Adult', Amount: 75},
            {  description: 'Child', Amount: 35},
            {  description: 'Infant', Amount: 25 },
];

Maintenant, pour avoir un montant total de ce tableau, je fais quelque chose comme ceci:

$scope.totalAmount = function(){
       var total = 0;
       for (var i = 0; i < $scope.traveler.length; i++) {
              total = total + $scope.traveler[i].Amount;
            }
       return total;
}

C'est facile quand il n'y a qu'un seul tableau, mais j'ai d'autres tableaux avec un nom de propriété différent que je voudrais résumer.

Je serais plus heureux si je pouvais faire quelque chose comme ça:

$scope.traveler.Sum({ Amount });

Mais je ne sais pas comment traverser cela de manière à pouvoir le réutiliser à l'avenir comme ceci:

$scope.someArray.Sum({ someProperty });

Réponse

J'ai décidé d'utiliser la suggestion @ gruff-bunny, alors je évite de prototyper l'objet natif } _ (Array)

Je viens de faire une petite modification à sa réponse en validant le tableau et la valeur à additionner n'est pas nulle, ceci est ma dernière implémentation:

$scope.sum = function (items, prop) {
    if (items == null) {
        return 0;
    }
    return items.reduce(function (a, b) {
        return b[prop] == null ? a : a + b[prop];
    }, 0);
};
javascriptarraysprototype-programming
87
nramirez

Puisqu'il s'agit d'un tableau, vous pouvez ajouter une fonction au prototype de tableau.

traveler = [
    {  description: 'Senior', Amount: 50},
    {  description: 'Senior', Amount: 50},
    {  description: 'Adult', Amount: 75},
    {  description: 'Child', Amount: 35},
    {  description: 'Infant', Amount: 25 },
];

Array.prototype.sum = function (prop) {
    var total = 0
    for ( var i = 0, _len = this.length; i < _len; i++ ) {
        total += this[i][prop]
    }
    return total
}

console.log(traveler.sum("Amount"))

Le violon: http://jsfiddle.net/9BAmj/

58
bottens

Je sais que cette question a une réponse acceptée, mais je pensais intégrer une alternative utilisant array.reduce , étant donné que la somme d'un tableau est l'exemple canonique de réduction:

$scope.sum = function(items, prop){
    return items.reduce( function(a, b){
        return a + b[prop];
    }, 0);
};

$scope.travelerTotal = $scope.sum($scope.traveler, 'Amount');

Fiddle

191
Gruff Bunny

Juste une autre prise, c’est pour cela que native fonctions JavaScriptMapetReduceont été conçues pour (Map et Réduire sont des moteurs dans de nombreuses langues).

var traveler = [{description: 'Senior', Amount: 50},
                {description: 'Senior', Amount: 50},
                {description: 'Adult', Amount: 75},
                {description: 'Child', Amount: 35},
                {description: 'Infant', Amount: 25}];

function amount(item){
  return item.Amount;
}

function sum(prev, next){
  return prev + next;
}

traveler.map(amount).reduce(sum);
// => 235;

// or use arrow functions
traveler.map(item => item.Amount).reduce((prev, next) => prev + next);

Remarque : en créant des fonctions séparées plus petites, nous obtenons la possibilité de les utiliser à nouveau.

// Example of reuse.
// Get only Amounts greater than 0;

// Also, while using Javascript, stick with camelCase.
// If you do decide to go against the standards, 
// then maintain your decision with all keys as in...

// { description: 'Senior', Amount: 50 }

// would be

// { Description: 'Senior', Amount: 50 };

var travelers = [{description: 'Senior', amount: 50},
                {description: 'Senior', amount: 50},
                {description: 'Adult', amount: 75},
                {description: 'Child', amount: 35},
                {description: 'Infant', amount: 0 }];

// Directly above Travelers array I changed "Amount" to "amount" to match standards.

function amount(item){
  return item.amount;
}

travelers.filter(amount);
// => [{description: 'Senior', amount: 50},
//     {description: 'Senior', amount: 50},
//     {description: 'Adult', amount: 75},
//     {description: 'Child', amount: 35}];
//     Does not include "Infant" as 0 is falsey.
73
SoEzPz

J'évite toujours de changer de méthode de prototype et d'ajouter une bibliothèque, voici donc ma solution:

Utiliser la méthode du prototype de matrice réduite est suffisant

// + operator for casting to Number
items.reduce((a, b) => +a + +b.price, 0);
43
Eric Marcelino

Vous pouvez faire ce qui suit:

$scope.traveler.map(o=>o.Amount).reduce((a,c)=>a+c);
9
greenif

Je ne suis pas sûr que cela ait déjà été mentionné. Mais il existe une fonction lodash pour cela. Extrait ci-dessous où valeur est votre attribut à additionner "valeur".

_.sumBy(objects, 'value');
_.sumBy(objects, function(o) { return o.value; });

Les deux vont marcher.

2
Liam Middleton

Voici un one-liner utilisant les fonctions de flèche ES6.

const sumPropertyValue = (items, prop) => items.reduce((a, b) => a + b[prop], 0);

// usage:
const cart_items = [ {quantity: 3}, {quantity: 4}, {quantity: 2} ];
const cart_total = sumPropertyValue(cart_items, 'quantity');
1
Steve Breese

peut également utiliser Array.prototype.forEach ()

let totalAmount = 0;
$scope.traveler.forEach( data => totalAmount = totalAmount + data.Amount);
return totalAmount;
1
akhouri

Comment résumer un tableau d'objet en utilisant Javascript

const traveler = [
  {  description: 'Senior', Amount: 50},
  {  description: 'Senior', Amount: 50},
  {  description: 'Adult', Amount: 75},
  {  description: 'Child', Amount: 35},
  {  description: 'Infant', Amount: 25 }
];

const traveler = [
    {  description: 'Senior', Amount: 50},
    {  description: 'Senior', Amount: 50},
    {  description: 'Adult', Amount: 75},
    {  description: 'Child', Amount: 35},
    {  description: 'Infant', Amount: 25 },
];
function sum(arrayData, key){
   return arrayData.reduce((a,b) => {
  return {Amount : a.Amount + b.Amount}
})
}
console.log(sum(traveler))
0
kvimalkr55

J'utilisais déjà jQuery. Mais je pense que c'est assez intuitif pour avoir juste:

var total_amount = 0; 
$.each(traveler, function( i, v ) { total_amount += v.Amount ; });

Ceci est fondamentalement juste une version abrégée de la réponse de @ akhouri. 

0
SpiRail

Voici une solution que je trouve plus flexible:

function sumOfArrayWithParameter (array, parameter) {
  let sum = null;
  if (array && array.length > 0 && typeof parameter === 'string') {
    sum = 0;
    for (let e of array) if (e && e.hasOwnProperty(parameter)) sum += e[parameter];
  }
  return sum;
}

Pour obtenir la somme, utilisez-la simplement comme ça:

let sum = sumOfArrayWithParameter(someArray, 'someProperty');
0
Philippe Genois

Alternative pour une meilleure lisibilité et utilisation de Map et Reduce:

const traveler = [
    {  description: 'Senior', amount: 50 },
    {  description: 'Senior', amount: 50 },
    {  description: 'Adult', amount: 75 },
    {  description: 'Child', amount: 35 },
    {  description: 'Infant', amount: 25 },
];

const sum = traveler
  .map(item => item.amount)
  .reduce((prev, curr) => prev + curr, 0);

Fonction réutilisable:

const calculateSum = (obj, field) => obj
  .map(items => items.attributes[field])
  .reduce((prev, curr) => prev + curr, 0);
0
codingbamby