Modo migliore per sommare un valore di proprietà in un array

Ho qualcosa del genere:

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

Ora per avere una quantità totale di questo array sto facendo qualcosa del genere:

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

È facile quando è solo un array, ma ho altri array con un nome di proprietà diverso che vorrei sommare.

Sarei più felice se potessi fare qualcosa del genere:

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

Ma non so come affrontarlo in modo da poterlo riutilizzare in futuro in questo modo:

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

Risposta

Ho deciso di utilizzare il suggerimento @ gruff-bunny, quindi evito di prototipare l'oggetto nativo (array)

Ho appena apportato una piccola modifica alla sua risposta convalidando l'array e il valore da sommare non è nullo, questa è la mia implementazione finale:

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

Risposta aggiornata

A causa di tutti gli svantaggi dell'aggiunta di una funzione al prototipo dell'array, sto aggiornando questa risposta per fornire un'alternativa che mantenga la sintassi simile alla sintassi originariamente richiesta nella domanda.

class TravellerCollection extends Array {
    sum(key) {
        return this.reduce((a, b) => a + (b[key] || 0), 0);
    }
}
const traveler = new TravellerCollection(...[
    {  description: 'Senior', Amount: 50},
    {  description: 'Senior', Amount: 50},
    {  description: 'Adult', Amount: 75},
    {  description: 'Child', Amount: 35},
    {  description: 'Infant', Amount: 25 },
]);

console.log(traveler.sum('Amount')); //~> 235

Risposta originale

Poiché si tratta di un array, è possibile aggiungere una funzione al prototipo di array.

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

The Fiddle: http://jsfiddle.net/9BAmj/

So che questa domanda ha una risposta accettata ma ho pensato di aggiungere una alternativa che utilizza array.reduce , visto che sommare un array è l'esempio canonico per ridurre:

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

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

Fiddle

Solo un altro esempio, questo è ciò per cui nativeJavaScript è stato creato Mape per cui Reducesono state create (Map e Reduce sono potenti in molte lingue).

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

Nota : creando funzioni più piccole separate abbiamo la possibilità di riutilizzarle.

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

Evito sempre di cambiare il metodo prototipo e di aggiungere una libreria, quindi questa è la mia soluzione:

L'uso del metodo prototipo di array ridotto è sufficiente

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

Ho pensato di perdere i miei due centesimi su questo: questa è una di quelle operazioni che dovrebbero sempre essere puramente funzionali, non basarsi su variabili esterne. Alcuni hanno già dato una buona risposta, usandoreduce è il modo di andare qui.

Poiché la maggior parte di noi può già permettersi di utilizzare la sintassi ES2015, ecco la mia proposta:

const sumValues = (obj) => Object.keys(obj).reduce((acc, value) => acc + obj[value], 0);

La stiamo rendendo una funzione immutabile mentre ci siamo. Che cosareduce sta facendo qui è semplicemente questo: Inizia con un valore di 0per l'accumulatore e aggiungi ad esso il valore dell'elemento loop corrente.

Sì per la programmazione funzionale e ES2015! :)

Alternativa per una migliore leggibilità e utilizzo Mape 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);

Funzione riutilizzabile:

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

Puoi fare quanto segue:

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

Funziona per me in TypeScripte JavaScript:

let lst = [
     { description:'Senior', price: 10},
     { description:'Adult', price: 20},
     { description:'Child', price: 30}
];
let sum = lst.map(o => o.price).reduce((a, c) => { return a + c });
console.log(sum);

Spero sia utile

Non sono sicuro che questo sia già stato menzionato. Ma esiste una funzione lodash per questo. Lo snippet di seguito in cui valore è l'attributo da sommare è "valore".

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

Entrambi funzioneranno.

può anche usare Array.prototype.forEach ()

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

Ecco una riga che usa le funzioni freccia 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');

Come sommare la matrice di oggetti usando 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))

Dall'array di oggetti

function getSum(array, column)
  let values = array.map((item) => parseInt(item[column]) || 0)
  return values.reduce((a, b) => a + b)
}

foo = [
  { a: 1, b: "" },
  { a: null, b: 2 },
  { a: 1, b: 2 },
  { a: 1, b: 2 },
]

getSum(foo, a) == 3
getSum(foo, b) == 6

Stavo già usando jquery. Ma penso che sia abbastanza intuitivo da avere solo:

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

Questa è fondamentalmente solo una versione abbreviata della risposta di @ akhouri.

Ecco una soluzione che trovo più flessibile:

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

Per ottenere la somma, basta usarla così:

let sum = sumOfArrayWithParameter(someArray, 'someProperty');