var total = 0;$.each(arr,function() {total += this;});

var arr = [1, 2, 3, 4];var total = 0;for (var i in arr) {total += arr[i];}

为什么不减少呢？它通常有点违反直觉，但使用它来查找总和非常简单：

var a = [1,2,3];var sum = a.reduce(function(a, b) { return a + b; }, 0);

一个标准的JavaScript解决方案：

var addition = [];addition.push(2);addition.push(3);
var total = 0;for (var i = 0; i < addition.length; i++){total += addition[i];}alert(total);          // Just to output an example/* console.log(total); // Just to output an example with Firebug */

这对我有效（结果应该是5）。我希望这种解决方案没有隐藏的缺点。

使用map：

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

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

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 (varindex = 0,              // The iteratorlength = array.length,  // Cache the array lengthsum = 0;                // The total amountindex < length;         // The "for"-loop conditionsum += array[index++]   // Add number on each iteration);return sum;}

这正是reduce的工作。

如果您使用的是ECMAScript 2015（又名ECMAScript 6）：

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

对于较旧的JS：

const sum = [1, 2, 3].reduce(add, 0); // with initial value to avoid when the array is empty
function add(accumulator, a) {return accumulator + a;}
console.log(sum); // 6

这不是很漂亮吗？：）

一小段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)

arr.reduce(function (a, b) {return a + b;});

参考：Array.prototype.reduce（）

有人在寻找像我这样的功能性单线吗？

假设：

const arr = [1, 2, 3, 4];

这是现代JS的oneliner：

sum = arr.reduce((a, b) => a + b, 0);

（如果您碰巧必须支持没有箭头函数的旧IE：）

sum = arr.reduce(function (a, b) {return a + b;}, 0);

请注意，是此处的初始值，因此如果需要，您可以将其用作偏移量。还要注意，需要此初始值，否则使用空数组调用函数会出错。

这里有很酷的技巧，我有很多安全的传统答案，没有缓存数组的长度。

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 10console.log( arraySum( my_array ) );

如果不缓存数组的长度，JS编译器需要在循环的每次迭代中遍历数组以计算长度，在大多数情况下这是不必要的开销。V8和许多现代浏览器为我们优化了这一点，所以它不那么令人担忧，但是有一些较旧的设备可以从这种简单的缓存中受益。

如果长度可能会发生变化，缓存可能会导致一些意想不到的副作用，如果你不知道为什么要缓存长度，但是对于一个可重用的函数来说，它的唯一目的是获取一个数组并将值添加在一起，这是一个很好的选择。

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

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

您也可以使用Reduce。

[1,2,3,4,5,6].reduceRight(function(a,b){return a+b;})

结果输出为21。

参考：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight

如果您碰巧使用Lodash，您可以使用和函数

array = [1, 2, 3, 4];sum = _.sum(array); // sum == 10

我是JavaScript和一般编码的初学者，但我发现一个简单易行的方法来求和数组中的数字是这样的：

    var myNumbers = [1,2,3,4,5]var total = 0;for(var i = 0; i < myNumbers.length; i++){total += myNumbers[i];}

基本上，我想贡献这个，因为我没有看到很多不使用内置函数的解决方案，而且这种方法很容易编写和理解。

var totally = eval(arr.join('+'))

这样你就可以把各种奇异的东西放在数组中。

var arr = ['(1/3)','Date.now()','foo','bar()',1,2,3,4]

我只是半开玩笑。

有趣的方法：

eval([1,2,3].join("+"))

这些都是非常好的答案，但以防万一，如果数字是按顺序排列的，就像问题（1,2,3,4）一样，你可以通过应用公式轻松地做到这一点（n*（n+1））/2其中n是最后一个数

Object.defineProperty(Object.prototype, 'sum', {enumerable:false,value:function() {var t=0;for(var i in this)if (!isNaN(this[i]))t+=this[i];return t;}});
[20,25,27.1].sum()                 // 72.1[10,"forty-two",23].sum()          // 33[Math.PI,0,-1,1].sum()             // 3.141592653589793[Math.PI,Math.E,-1000000000].sum() // -999999994.1401255
o = {a:1,b:31,c:"roffelz",someOtherProperty:21.52}console.log(o.sum());              // 53.519999999999996

推荐（减少默认值）

Array.prototype.reduce可用于遍历数组，将当前元素值添加到前一个元素值的总和。

console.log([1, 2, 3, 4].reduce((a, b) => a + b, 0))console.log([].reduce((a, b) => a + b, 0))

不带默认值

出现TypeError错误

console.log([].reduce((a, b) => a + b))

在ES6的箭头功能之前

console.log([1,2,3].reduce(function(acc, val) { return acc + val; }, 0))
console.log([].reduce(function(acc, val) { return acc + val; }, 0))

非数字输入

如果非数字是可能的输入，您可能想要处理它？

console.log(["hi", 1, 2, "frog"].reduce((a, b) => a + b))
let numOr0 = n => isNaN(n) ? 0 : n
console.log(["hi", 1, 2, "frog"].reduce((a, b) =>numOr0(a) + numOr0(b)))

不推荐的危险评价使用

我们可以使用val来执行JavaScript代码的字符串表示。使用Array.prototype.join函数将数组转换为字符串，我们将[1,2,3]更改为“1+2+3”，其计算结果为6。

console.log(eval([1,2,3].join('+')))
//This way is dangerous if the array is built// from user input as it may be exploited eg:
eval([1,"2;alert('Malicious code!')"].join('+'))

当然，显示警报并不是可能发生的最糟糕的事情。我包含这个的唯一原因是作为奥通德问题的答案，因为我认为它没有得到澄清。

使用递归

var sum = (arr) => arr.length === 1 ? arr[0] : arr.shift() + sum(arr);sum([1,2,3,4]) // 10

使用reduce

let arr = [1, 2, 3, 4];
let sum = arr.reduce((v, i) => (v + i));
console.log(sum);

试试这个…

function arrSum(arr){total = 0;arr.forEach(function(key){total = total + key;});return total;}

这样容易多了

function sumArray(arr) {var total = 0;arr.forEach(function(element){total += element;})return total;}
var sum = sumArray([1,2,3,4])
console.log(sum)

Vanilla JavaScript就是你所需要的：

> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; a.forEach(function(e){sum += e}); sum10> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; a.forEach(e => sum += e); sum10> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; for(e in a) sum += e; sum"00123foobar"> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; for(e of a) sum += e; sum10

有些人建议在Array.prototype中添加.sum()方法。这通常被认为是不好的做法，所以我不建议你这样做。

如果你仍然坚持这样做，那么这是一种简洁的写作方式：

Array.prototype.sum = function() {return [].reduce.call(this, (a,i) => a+i, 0);}

然后：[1,2].sum(); // 3

请注意，添加到原型中的函数混合使用ES5和ES6函数以及箭头语法。声明function是为了允许该方法从您正在操作的Array中获取this上下文。我在reduce调用中使用=>是为了简洁。

对于非常大的数字，循环或减少可能是过程密集型的。

sum = (n * (n+1))/2;

从mathCentral。

不需要initial value！因为如果没有传递initial value，则不会在列表的第一个元素上调用callback function，而是将第一个元素作为initial value传递。非常cOOl特性：）

[1, 2, 3, 4].reduce((a, x) => a + x) // 10[1, 2, 3, 4].reduce((a, x) => a * x) // 24[1, 2, 3, 4].reduce((a, x) => Math.max(a, x)) // 4[1, 2, 3, 4].reduce((a, x) => Math.min(a, x)) // 1

好的，假设你有下面这个数组：

const arr = [1, 2, 3, 4];

让我们开始研究许多不同的方式，因为我在这里找不到任何全面的答案：

1）使用内置的Reduce（）

function total(arr) {if(!Array.isArray(arr)) return;return arr.reduce((a, v)=>a + v);}

2）使用for循环

function total(arr) {if(!Array.isArray(arr)) return;let totalNumber = 0;for (let i=0,l=arr.length; i<l; i++) {totalNumber+=arr[i];}return totalNumber;}

（3）循环

function total(arr) {if(!Array.isArray(arr)) return;let totalNumber = 0, i=-1;while (++i < arr.length) {totalNumber+=arr[i];}return totalNumber;}

4）使用数组foreach

function total(arr) {if(!Array.isArray(arr)) return;let sum=0;arr.forEach(each => {sum+=each;});return sum;};

并这样称呼它：

total(arr); //return 10

不建议将这样的原型用于Array…

这是一个使用栈算法的优雅的单行解决方案，尽管人们可能需要一些时间来理解这个实现的美妙之处。

const getSum = arr => (arr.length === 1) ? arr[0] : arr.pop() + getSum(arr);
getSum([1, 2, 3, 4, 5]) //15

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

这个代码段的美妙之处在于该函数包含arr[0]检查以防止无限循环。一旦它到达最后一项，它将返回整个总和。

这个函数可以总结所有的数字-

 function array(arr){var sum = 0;for (var i = 0; i< arr.length; i++){sum += arr[i];}console.log(sum);}array([5, 1, 3, 3])

我看到所有的答案都是“减少”解决方案

var array = [1,2,3,4]var total = 0for (var i = 0; i < array.length; i++) {total += array[i]}console.log(total)

带ES6休息参数

let array = [1, 2, 3, 4]
function sum(...numbers) {let total = 0;for (const number of numbers) {total += number;}return total;}
console.log(sum(...array));

只需使用此功能：

function sum(pArray){pArray = pArray.reduce(function (a, b) {return a + b;}, 0);
return pArray;}

function sum(pArray){pArray = pArray.reduce(function (a, b) {return a + b;}, 0);
return pArray;}
var arr = [1, 4, 5];
console.log(sum(arr));

您可以将duce（）方法与lambda表达式结合使用：

[1, 2, 3, 4].reduce((accumulator, currentValue) => accumulator + currentValue);

    <!DOCTYPE html><html><body>
<p>Click the button to join two arrays.</p><button onclick="myFunction()">Try it</button><p id="demo"></p><script>var hege = [1, 2,4,6,7,8,8];var stale = [1, 2,4,5];function myFunction() {console.log((hege.length > stale.length))var children  = (hege.length > stale.length)? abc1() :abc2();       document.getElementById("demo").innerHTML = children;}function abc1(){console.log(hege,"Abc1")var abcd=hege.map(function (num, idx) {console.log(hege.length , idx)return stale.length>idx?num + stale[idx]:num;})return abcd;}
function abc2(){
console.log(hege,"Abc2",stale)var abcd=stale.map(function (num, idx) {console.log(hege.length , idx)return hege.length>idx?num + hege[idx]:num;})return abcd;}</script>
</body></html>

一个“重复”问题询问如何对二维数组执行此操作，因此这是回答该问题的简单改编。（差异仅为六个字符[2], 0，它在每个子数组中找到第三项并传递初始值零）：

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

一个简单的方法示例：

function add(array){var arraylength = array.length;var sum = 0;for(var timesToMultiply = 0; timesToMultiply<arraylength; timesToMultiply++){sum += array[timesToMultiply];}
return sum;}
console.log(add([1, 2, 3, 4]));

使用for循环：

const array = [1, 2, 3, 4];let result = 0;
for (let i = 0; i < array.length - 1; i++) {result += array[i];}
console.log(result); // Should give 10

或者forEach循环：

const array = [1, 2, 3, 4];let result = 0;
array.forEach(number => {result += number;})
console.log(result); // Should give 10

为了简单起见，使用reduce：

const array = [10, 20, 30, 40];const add = (a, b) => a + bconst result = array.reduce(add);
console.log(result); // Should give 100

精度

排序数组和起始和形成最小数字（片段显示与非排序的区别）

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

arr=[.6,9,.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);
// we use .sort((a,b)=>a-b) instead .sort() because// that second one treat elements like strings (so in wrong way)// e.g [1,10,9,20,93].sort() -->  [1, 10, 20, 9, 93]

对于多维数字数组，请使用arr.flat(Infinity)

arr= [ [ [1,2,3,4],[1,2,3,4],[1,2,3,4] ],[ [1,2,3,4],[1,2,3,4],[1,2,3,4] ] ];      
sum = arr.flat(Infinity).reduce((a,c)=> a+c,0);
console.log(sum);  // 60

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

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

这里，["1"，"2"，"3"，"4"]是字符串数组，函数Number()将字符串转换为数字。

考虑到你有阵列

const arr = [1, 2, 3, 4];

对我来说，最直观的方法是使用for-in

let sum = 0;for(var value in arr) {sum += arr[value];}
console.log('Array:', arr);console.log('Sum:', sum);

但是，您也可以使用箭头函数和Reduce函数

const sum = arr.reduce(function (a, b) {return a + b;}, 0);
console.log('Array:', arr);console.log('Sum:', sum);

他们都会输出

Array: [ 1, 2, 3, 4]Sum: 10

你可以试试这个：

var arr = [100,114,250,1200];var total = 0;for(var i in arr){total += parseInt(arr[i]);}
console.log(total);

输出将是：1664

或者如果value是Float，那么试试这个：

var arr = [100.00,114.50,250.75,1200.00];var total = 0;for(var i in arr){total += parseFloat(arr[i]);}    
console.log(total.toFixed(2));

输出将是：1665.25

此外，对于简单的array，求和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);

ES6 for… of

let total = 0;
for (let value of [1, 2, 3, 4]) {total += value;}

我知道这是一篇旧文章，但我只是想分享我解决这个问题的方法。

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

非常简单

第1步我们应该有一个数组，如下所示：

const arrayNumber = [500,152,154,1555,12445];

步骤2（如果您可以忽略此步骤）步骤是确保表中的所有值都是该值的数字

let newArray = [];for (let i = 0; i < arrayNumber.length; i++) {newArray.push(parseInt(arrayNumber[i], 10));}

步骤3

const sumInArray = dataData.reduce( (a, b) => a + b);

最后

console.log(sumInArray);

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

了解底层流程的最简单答案：

let array = [10, 20, 30, 40, 50]let total = 0
for(let i in array){total += array[i]}
console.log(total)

&如果您已经熟悉底层流程，那么内置方法可以节省您的时间：

let array = [10, 20, 30, 40, 50]let total = array.reduce((x, y) => x + y)console.log(total)

使用Reduce（）

[1, 2, 3, 4].reduce((a, b) => a + b, 0); // 10

对于每个（）

let sum = 0;[1, 2, 3, 4].forEach(n => sum += n);sum; // 10

带参数

function arrSum(arr) {sum = 0;arr.forEach(n => sum += n);return sum;}
arrSum([1, 2, 3, 4]) // 10

是否有理由不首先过滤数组以删除非数字？看起来很简单：

[1, 2, 3, null, 'a'].filter((x) => !isNaN(x)).reduce((a, b) => a + b)

有人还可以使用map()函数对数组值进行求和。

function sumOfArrVal(arr){let sum=0;arr.map(val=>sum+=val)return sum}
let result=sumOfArrVal([1,2,3,4])console.log(result)

getTotal = (arr) => {let total = 0for (let i = 0; i < arr.length; i++) {total += arr[i];}return total}
getTotal([1, 2, 3, 4]) // 10getTotal([1, 2, 3, 4, 5]) // 15

没有人提到函数式编程，但在这种情况下使用Ramda是一种非常干净的方法：

//Assuming you use nodejs, but can also be used in browserconst R = require('ramda');
let nums = [2, 4, 6, 8, 10];console.log(R.sum(nums));

您可以尝试以下代码：

[1, 2, 3, 4].reduce((pre,curr)=>pre+curr,0)

事实是，有一个古老而有趣的经典解决方案（除了新手'foreach'和'duce'）：经典的对于。

y = 0;for (x of [1, 2, 3, 4]) y+=x;

我看到这是一个古老的问题，但几乎没有任何答案真正使用jQuery，特别是按照提问者的要求使用$.each。有一种方法可以做到这一点，但是许多人建议的本机方法（即使用Array.reduce()）要好得多，也更容易。

这是jQuery的方式，如果你绝对必须使用它：

  var arr = [1,2,3,4];var sum = 0;  
$.each( arr, (i, v) => sum += v);
alert(sum); // This will be 10

太长别读

如果您关心性能，请定义一个使用for-loop的函数。

function sum(arr) {var res = 0;for (var x of arr) {res += x;}return res;}

基准

我使用#0（打字稿版本）对一系列实现进行了基准测试：

const arr = Array.from({ length: 100 }, () => Math.random());const reducer = function (p: number, a: number) {return p + a;};const recursion = function (arr: number[], i: number) {if(i > 0) return arr[i] + recursion(arr, i - 1)else return 0};const recursion2 = function (arr: number[], i: number, len: number) {if(i < len) return arr[i] +  recursion2(arr, i + 1, len)else return 0};const recursion3 = function (arr: number[], i: number) {if(i < arr.length) return arr[i] + recursion3(arr, i + 1)else return 0};new Benchmark.Suite().add("jquery", () => {let res = 0;$.each(arr, (_, x) => (res += x));}).add("lodash", ()=>_.sum(arr)).add("forEach", () => {let res = 0;arr.forEach((x) => (res += x));}).add("reduce", () => arr.reduce((p, a) => p + a, 0)).add("predefined reduce", () => arr.reduce(reducer, 0)).add("eval", () => eval(arr.join("+"))).add("recursion", () => recursion(arr, arr.length - 1)).add("recursion2", () => recursion2(arr, 0, arr.length)).add("recursion3", () => recursion3(arr, 0)).add("naive", () => (arr[0]+arr[1]+arr[2]+arr[3]+arr[4]+arr[5]+arr[6]+arr[7]+arr[8]+arr[9]+arr[10]+arr[11]+arr[12]+arr[13]+arr[14]+arr[15]+arr[16]+arr[17]+arr[18]+arr[19]+arr[20]+arr[21]+arr[22]+arr[23]+arr[24]+arr[25]+arr[26]+arr[27]+arr[28]+arr[29]+arr[30]+arr[31]+arr[32]+arr[33]+arr[34]+arr[35]+arr[36]+arr[37]+arr[38]+arr[39]+arr[40]+arr[41]+arr[42]+arr[43]+arr[44]+arr[45]+arr[46]+arr[47]+arr[48]+arr[49]+arr[50]+arr[51]+arr[52]+arr[53]+arr[54]+arr[55]+arr[56]+arr[57]+arr[58]+arr[59]+arr[60]+arr[61]+arr[62]+arr[63]+arr[64]+arr[65]+arr[66]+arr[67]+arr[68]+arr[69]+arr[70]+arr[71]+arr[72]+arr[73]+arr[74]+arr[75]+arr[76]+arr[77]+arr[78]+arr[79]+arr[80]+arr[81]+arr[82]+arr[83]+arr[84]+arr[85]+arr[86]+arr[87]+arr[88]+arr[89]+arr[90]+arr[91]+arr[92]+arr[93]+arr[94]+arr[95]+arr[96]+arr[97]+arr[98]+arr[99])).add("loop with iterator", () => {let res = 0;for (const x of arr) res += x;}).add("traditional for loop", () => {let res = 0;// cache the length in case the browser can't do it automaticallyconst len = arr.length;for (let i = 0; i < len; i++) res += arr[i];}).add("while loop", () => {let res = 0;let i = arr.length;while (i--) res += arr[i];}).add("loop in a function ", () => sum(arr)).on("cycle", (event) => console.log(String(event.target))).run();

在chrome 104中，基于for-loop的实现是最快的：

jquery               x  1,832,472 ops/sec ±1.35% (61 runs sampled)lodash               x  2,079,009 ops/sec ±1.11% (68 runs sampled)forEach              x  4,887,484 ops/sec ±2.35% (67 runs sampled)reduce               x 21,762,391 ops/sec ±0.46% (69 runs sampled)predefined reduce    x  2,026,411 ops/sec ±0.50% (68 runs sampled)eval                 x     33,381 ops/sec ±2.54% (66 runs sampled)recursion            x  2,252,353 ops/sec ±2.13% (62 runs sampled)recursion2           x  2,301,516 ops/sec ±1.15% (65 runs sampled)recursion3           x  2,395,563 ops/sec ±1.65% (66 runs sampled)naive                x 31,244,240 ops/sec ±0.76% (66 runs sampled)loop with iterator   x 29,554,762 ops/sec ±1.07% (66 runs sampled)traditional for loop x 30,052,685 ops/sec ±0.67% (66 runs sampled)while loop           x 18,624,045 ops/sec ±0.17% (69 runs sampled)loop in a function   x 29,437,954 ops/sec ±0.54% (66 runs sampled)

Firefox 104显示了类似的行为：

jquery               x  1,461,578 ops/sec ±1.58% (64 runs sampled)lodash               x  4,931,619 ops/sec ±0.80% (66 runs sampled)forEach              x  5,594,013 ops/sec ±0.51% (68 runs sampled)reduce               x  3,731,232 ops/sec ±0.53% (66 runs sampled)predefined reduce    x  2,633,652 ops/sec ±0.54% (66 runs sampled)eval                 x    105,003 ops/sec ±0.88% (66 runs sampled)recursion            x  1,194,551 ops/sec ±0.24% (67 runs sampled)recursion2           x  1,186,138 ops/sec ±0.20% (68 runs sampled)recursion3           x  1,191,921 ops/sec ±0.24% (68 runs sampled)naive                x 21,610,416 ops/sec ±0.66% (66 runs sampled)loop with iterator   x 15,311,298 ops/sec ±0.43% (67 runs sampled)traditional for loop x 15,406,772 ops/sec ±0.59% (67 runs sampled)while loop           x 11,513,234 ops/sec ±0.60% (67 runs sampled)loop in a function   x 15,417,944 ops/sec ±0.32% (68 runs sampled)

讨论

定义匿名函数的实现通常较慢，因为创建匿名函数会带来很大的开销。当使用大数组运行基准测试时，例如，长度为1000而不是100，reduce和for基于循环的实现之间的差异在chrome中变得微不足道。

Chrome的V8引擎知道如何在reduce中内联简单的匿名函数，因为reduce测试用例比predefined reduce测试用例快得多。Firefox似乎尝试了类似的方法，但这样做的效率较低。在js中，非内联函数调用非常慢，因为调用堆栈的效率低于编译软件中的调用堆栈。

与reduce类似，基于forEach和jquery的实现使用匿名函数并且相对较慢。lodash有一个专门的sum实现，但它（从v4.0.0开始）作为sumBy的特例实现，效率相对较低。

eval是迄今为止最慢的测试用例。这是有道理的，因为使用连接构建字符串可能会导致多次动态分配（很慢）。接下来，必须调用解析器，只有这样才能最终执行代码。

我包含了一些递归实现，因为互联网上的一些人声称js中的递归比循环更快。我无法复制他们的例子——使用benchmark.js，递归非常慢，当使用console.time和循环时，两个函数花费的时间相同。在计算和时，正如预期的那样，递归比循环慢得多，可能是由于大量使用js调用堆栈。

简单的实现是手动添加数组的所有100个元素。虽然很不方便，但这是最快的实现。但是，幸运的是，for-loops非常接近。在循环周围添加单个函数调用不会损害性能。因此，你可以随意从上面使用实用函数。

我无法解释为什么while循环比for循环慢。反向迭代数组似乎不是问题所在。

我认为这是找到数字和数组的简单方法

function sumArray(arr){
let total = 0;
for(i = 0; i<arr.length ; i++){
total += arr[i];}return total;}
console.log(sumArray([1,2,3,4,]));

您可以使用for of循环获取总和，如下所示：

let arr = [1, 2, 3, 4];let total = 0;for (let i of arr) {total += i;}console.log(total)