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

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

//Try this way

const arr = [10,10,20,60]; 
const sumOfArr = (a) =>{
    let sum=0;
    for(let i in a) { 
        sum += a[i];
    }
    return sum;
}
console.log(sumOfArr(arr))

精确

对数组进行排序并以最小的数字开始求和（代码段显示了与非排序的区别）

[...arr].sort((a,b)=>a-b).reduce((a,c)=>a+c,0)

arr=[,6,9,1,1,1,1，.1，.1]sum=arr.reduce（（a，c）=>a+c，0）sortSum=[…arr].sort（（a，b）=>a-b）.reduce（（a、c）=>a+c，0）console.log（'sum:'，sum）；console.log（'sortSum:'，sortSum）；console.log（'sum==sortSum:'，sum==sortSum）；//我们使用.sort（（a，b）=>a-b）代替.sort（），因为//第二个将元素视为字符串（因此方式错误）//例如[1,10,9,20,93].sort（）-->[1，10，20，9，93]

对于多维数字数组，使用arr.flat（无限）

arr=[[[1，2，3，4]，[1,2,3,4]，[1,2,4]，[ [1,2,3,4],[1,2,3,4],[1,2,3,4] ] ];sum=arr.flat（无限）.reduce（（a，c）=>a+c，0）；console.log（总和）；//60

一小段JavaScript代码就能完成这项工作：

var numbers = [1,2,3,4];
var totalAmount = 0;

for (var x = 0; x < numbers.length; x++) {

    totalAmount += numbers[x];
}

console.log(totalAmount); //10 (1+2+3+4)

使用贴图：

var sum = 0;
arr.map(function(item){
    sum += item;
});

// sum now contains the total.

您可以将该方法添加到Array原型中。

Array.prototype.sum = function(){
    var sum = 0;
    this.map(function(item){
        sum += item;
    });
    return sum;
}

然后您可以在任何阵列上使用它，如下所示：

arr.sum();

这里很酷的技巧，我对很多安全的传统答案进行了吹毛求疵，没有缓存数组的长度。

function arraySum(array){
  var total = 0,
      len = array.length;

  for (var i = 0; i < len; i++){
    total += array[i];
  }

  return total;
};

var my_array = [1,2,3,4];

// Returns 10
console.log( arraySum( my_array ) );

在不缓存数组长度的情况下，JS编译器需要在循环的每次迭代中遍历数组来计算长度，这在大多数情况下是不必要的开销。V8和许多现代浏览器都为我们优化了这一点，因此它不再那么受关注，但也有一些较旧的设备受益于这种简单的缓存。

如果长度可能会发生变化，如果您不知道为什么要缓存长度，缓存可能会导致一些意想不到的副作用，但对于唯一目的是获取数组并将值相加的可重用函数来说，这非常适合。

这里是这个arraySum函数的CodePen链接。http://codepen.io/brandonbrule/pen/ZGEJyV

这可能是一种过时的心态，一直困扰着我，但我不认为在这种情况下使用它有什么缺点。