这里有一个优雅的单线解决方案，它使用堆栈算法，尽管人们可能需要一些时间来理解这个实现的美。

const getSum = arr => (arr.length === 1) ? arr[0] : arr.pop() + getSum(arr);

getSum([1, 2, 3, 4, 5]) //15

基本上，该函数接受一个数组，并检查该数组是否正好包含一个项。如果为false，则从堆栈中弹出最后一项并返回更新的数组。

这段代码的妙处在于，该函数包括arr[0]检查，以防止无限循环。一旦到达最后一项，它将返回全部金额。

这可以通过循环所有项，并在每次迭代中将它们添加到一个和变量中来实现。

var array = [1, 2, 3];

for (var i = 0, sum = 0; i < array.length; sum += array[i++]);

JavaScript不知道块的作用域，所以可以访问sum：

console.log(sum); // => 6

同上，但注释和准备为简单函数：

function sumArray(array) {
  for (
    var
      index = 0,              // The iterator
      length = array.length,  // Cache the array length
      sum = 0;                // The total amount
      index < length;         // The "for"-loop condition
      sum += array[index++]   // Add number on each iteration
  );
  return sum;
}

带ES6休息参数

让数组=[1，2，3，4]函数和（…数字）{设总数=0；for（常量数）{总数+=数量；}回报总额；}console.log（sum（…array））；

当数组由字符串组成时，必须更改代码。如果数组是数据库请求的结果，则可能是这种情况。此代码有效：

alert(
["1", "2", "3", "4"].reduce((a, b) => Number(a) + Number(b), 0)
);

这里，[“1”，“2”，“3”，“4”]是字符串数组，函数Number（）将字符串转换为数字。

此外，对于简单数组，使用es6求和。

const sum = [1, 2, 3].reduce((partial_sum, a) => partial_sum + a,0);
 
console.log(sum); 

对于具有默认初始化值的对象数组

const totalAmount = obj => 
    Object.values(obj).reduce((acc, { order_qty, mrp_price }) => 
    acc + order_qty * mrp_price, 0);
    
    console.log(totalAmount); 

我知道这是一个老帖子。但我只是想分享我对这个问题的看法。

let myArr = [1, 3, 4, 5, 6, 7, 8];
let counter = 0;
for(let i = 0; i < myArr.length; i++){
  counter = counter + myArr[i];
    console.log(counter);}