Even though there is already an accepted answer for this question, I wanted to provide a different approach using array.reduce. Typically, reducing an array by summing its values is a common example for using reduce:

$scope.calculateTotal = function(list, property){
    return list.reduce( function(previousValue, currentValue){
        return previousValue + currentValue[property];
    }, 0);
};

$scope.totalAmount = $scope.calculateTotal($scope.items, 'Value');

Fiddle

Implement a solution using the reduce method along with destructuring to calculate the total sum of Amount:

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

console.log(traveler.reduce((accum, {Amount}) => accum + Amount, 0));

Here's a different perspective - the native JavaScript functions Map and Reduce are incredibly powerful tools (used in various languages).

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

Note: breaking down tasks into smaller functions allows for reusability.

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

// Also, adhere to camelCase convention when coding in Javascript.
// If deviating from standards,
// maintain consistency throughout, like...

// { 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 }];

// Just before Travelers array, changed "Amount" to "amount" for consistency.

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}];
//     Excludes "Infant" as 0 is falsey.

When it comes to modifying prototype methods and incorporating external libraries, I tend to steer clear. Instead, my go-to solution involves utilizing the reduce Array prototype method.

// Using the + operator to cast to Number
items.reduce((accumulator, currentValue) => +accumulator + +currentValue.price, 0);

Here is a more legible alternative using the Map and Reduce methods:

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

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

Function for calculating sum of specified field in an object:

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

This code snippet is functioning perfectly for me in both TypeScript and JavaScript:

let items = [
     { name:'Shirt', price: 25},
     { name:'Pants', price: 50},
     { name:'Shoes', price: 80}
];
let totalCost = items.map(obj => obj.price).reduce((accumulator, currentValue) => { return accumulator + currentValue });
console.log(totalCost);

I trust that you may find this information helpful.

Here are the steps you can take:

$scope.traveler.map(obj=>obj.Amount).reduce((acc,current)=>acc+current);

Sharing my thoughts on this topic: it's crucial for this process to remain completely functional, without depending on any outside variables. Many have already provided excellent solutions, and using the reduce method is definitely the most effective approach.

Given that most of us now have access to ES2015 syntax, here's a suggestion I'd like to offer:

const calculateSum = (object) => Object.keys(object).reduce((accumulator, currentValue) => accumulator + object[currentValue], 0);

This function maintains immutability. Essentially, what the reduce function accomplishes here is quite simple: It initializes the accumulator with a value of 0, then adds each item's value during each iteration.

Functional programming paired with ES2015 features – a winning combination! :)

It appears that nobody has mentioned this yet, but there exists a handy lodash function specifically designed for this task. See the snippet below where 'value' represents the attribute you wish to sum:

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

Both of these methods will achieve the desired result.

A different approach is to utilize Array.prototype.forEach()

let totalCost = 0;
$scope.traveler.forEach( item => totalCost = totalCost + item.Cost);
return totalCost;

Calculating sum from array of objects

function calculateTotal(array, target)
  let values = array.map((object) => parseInt(object[target]) || 0)
  return values.reduce((prev, curr) => prev + curr)
}

exampleArray = [
  { value1: 1, value2: "" },
  { value1: null, value2: 2 },
  { value1: 1, value2: 2 },
  { value1: 1, value2: 2 },
]

calculateTotal(exampleArray, value1) == 3
calculateTotal(exampleArray, value2) == 6

If you want to calculate the sum of an array, you can utilize Array.prototype.reduce:

const total = items.reduce((accumulator , value)=>{
   return accumulator + value.price;
} ,0);

Check out this ES6 arrow function one-liner.

const getPropertyValueSum = (items, key) => items.reduce((acc, curr) => acc + curr[key], 0);

// example:
const product_prices = [ {price: 10}, {price: 15}, {price: 20} ];
const total_cost = getPropertyValueSum(product_prices, 'price');

Upon reviewing these responses, it appears that utilizing a for loop (or forEach or for of with await) may actually be more readable than using reduce or even a combination of map and reduce. Consider:

1. Returning to this code after 6 months or having someone else maintain it. Using a loop seems like a better approach.
2. Expanding this function in the future, for instance if you need to incorporate currency conversion. Trying to do this in a single line may not be ideal.

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

var sumFromArray = (propertyName, array) => {
  let sum = 0;
  array.forEach(item => {
    sum += item[propertyName] ?? 0;
  });
  return sum;
};

var sumOfTraveler = sumFromArray('Amount', traveler);
console.log(sumOfTraveler);

With types, your function definition could look like:

const sumFromArray = (propertyName: string, array: Array<{[propertyName: string]: number}>) => { ... };

For more information, refer to: TypeScript A computed property name in a type literal must directly refer to a built-in symbol

I don't have anything against map, reduce, or one-liners - just something to consider.

Method for combining an array of objects in Javascript

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

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

Check out this alternative solution for a more versatile approach:

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

To find the sum, simply call the function with the array and key as parameters:

let totalSum = calculateSumOfArrayWithKey(sampleArray, 'sampleKey');

As a newcomer trying to enhance a basic app for practice, I found myself feeling overwhelmed by the code snippets offered as solutions. Breaking it down into a simple solution looks like this:

let numbers = [3, 9, 2, 6];

function(){
total = 0;
for(let index = 0; index < numbers.length; index++){
    total += numbers[index];
}

// This will calculate the sum of the provided array

Before, I had been utilizing jquery for my project. However, I came to realize that it is just as effective to simplify the code to:

let totalCost = 0; 
$.each(passenger, (index, value) => { totalCost += value.cost ; });

This method essentially serves as a condensed adaptation of @akhouri's solution.

If you're looking for a simple way to perform database-like queries in JavaScript, consider using the jscollection library. With just one line of code, you can easily manipulate your data. Check out the jscollection library here

var totalAmount = List.extend(traveler).select('Amount').sum();