如何找到數字數組的總和

Question

給定一個數組[1, 2, 3, 4] ，我如何找到它的元素之和？ （在這種情況下，總和為10 。）

我認為$.each可能會有用，但我不確定如何實現它。

Answer 1

這正是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

那不是很漂亮嗎？ :-)

Answer 2

推薦（使用默認值減少）

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

不推薦的危險評估使用

我們可以使用eval來執行 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('+'))

當然，顯示警報並不是可能發生的最糟糕的事情。 我包含此內容的唯一原因是作為 Ortund 問題的答案，因為我認為它沒有得到澄清。

Answer 3

為什么不減？ 這通常有點反直覺，但使用它來求和非常簡單：

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

Answer 4

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

Answer 5

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

Answer 6

任何人都在尋找像我這樣的功能性oneliner？

假設：

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

請注意，此處0是初始值，因此您可以根據需要將其用作偏移量。 還要注意這個初始值是需要的，否則用空數組調用函數會出錯。

Answer 7

如果你碰巧使用 Lodash，你可以使用sum函數

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

Answer 8

這可以通過遍歷所有項目，並在每次迭代中將它們添加到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 (
    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;
}

Answer 9

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

參考： Array.prototype.reduce()

Answer 10

// Given array 'arr'
var i = arr.length;
var sum = 0;
while (--i) sum += arr[i];

這將平均需要 1.57 毫秒/運行（在 100 個隨機正態數的數組上運行超過 1000 次），而使用上述eval()方法為 3.604 毫秒/運行，使用標准 for(i,length eval()運行需要 2.151 毫秒/運行,++) 循環。

方法說明：此測試在 Google Apps Script 服務器上運行，因此它們的 javascript 引擎與 Chrome 幾乎相同。

編輯：-- --i而不是i--每次運行節省 0.12 毫秒（i-- 為 1.7）

編輯：神聖的咒罵，別介意整篇文章。 使用上面提到的reduce()方法，它只有1ms/run。

Answer 11

好的，假設您在下面有這個數組：

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）使用while循環

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

Answer 12

您也可以使用 reduceRight。

[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

Answer 13

有趣的方法：

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

Answer 14

一個標准的 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）。 我希望這種解決方案沒有隱藏的缺點。

Answer 15

我是 JavaScript 和一般編碼的初學者，但我發現對數組中的數字求和的簡單方法如下：

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

基本上，我想貢獻這個是因為我沒有看到很多不使用內置函數的解決方案，而且這種方法易於編寫和理解。

Answer 16

您可以嘗試以下代碼：

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

Answer 17

使用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 + b
const result = array.reduce(add);

console.log(result); // Should give 100

Answer 18

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

這樣你就可以把各種奇特的東西放在數組中。

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

我只是半開玩笑。

Answer 19

一些人建議在Array.prototype中添加一個.sum()方法。 這通常被認為是不好的做法，所以我不建議你這樣做。

如果您仍然堅持這樣做，那么這是一種簡潔的寫法：

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

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

請注意，添加到原型中的函數混合使用了 ES5 和 ES6 函數和箭頭語法。 聲明該function以允許該方法從您正在操作的Array中獲取this上下文。 為了簡潔起見，我在reduce調用中使用了=> 。

Answer 20

ES6 for..of

let total = 0;

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

Answer 21

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

Answer 22

使用reduce

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

Answer 23

無需initial value ！ 因為如果沒有傳遞initial value ，則不會對列表的第一個元素調用callback function ，而是將第一個元素作為initial value傳遞。 非常 c OO l 功能:)

[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

Answer 24

這是一個使用堆棧算法的優雅的單線解決方案，盡管可能需要一些時間來理解這個實現的美妙之處。

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

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

基本上，該函數接受一個數組並檢查該數組是否恰好包含一項。 如果為 false，則將最后一項從堆棧中彈出並返回更新后的數組。

這個片段的美妙之處在於該函數包括arr[0]檢查以防止無限循環。 一旦到達最后一項，它就會返回整個總和。

Answer 25

准確性

對數組進行排序並從最小數字開始求和（片段顯示與非排序的差異）

[...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)=>ab).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)=>ab) instead .sort() because // that second one treat elements like strings (so in wrong way) // eg [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

Answer 26

這些確實是很好的答案，但是以防萬一數字按問題（1,2,3,4）中的順序排列，您可以通過應用公式 (n*(n+1))/2 輕松做到這一點，其中n 是最后一個數字

Answer 27

您可以將 reduce() 方法與 lambda 表達式結合使用：

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

Answer 28

使用減少（）

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

使用 forEach()

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

Answer 29

我看到所有答案都是“減少”解決方案

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

Answer 30

很簡單

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

Answer 31

了解底層過程的最簡單答案：

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)

Answer 32

這里很酷的技巧，我有很多安全的傳統答案沒有緩存數組的長度。

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

這可能是一種過時的心態，一直困擾着我，但我不認為在這種情況下使用它有什么缺點。

Answer 33

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

Answer 34

這更容易

function sumArray(arr) {
    var total = 0;
    arr.forEach(function(element){
        total += element;
    })
    return total;
}

var sum = sumArray([1,2,3,4])

console.log(sum)

Answer 35

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

Answer 36

一個簡單的方法示例：

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

Answer 37

當數組由字符串組成時，必須更改代碼。 如果數組是來自數據庫請求的結果，則可能是這種情況。 此代碼有效：

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

這里，["1", "2", "3", "4"] 是字符串數組，函數Number()將字符串轉換為數字。

Answer 38

是否有理由不首先過濾數組以刪除非數字？ 看起來很簡單：

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

Answer 39

getTotal = (arr) => {
    let total = 0
    for (let i = 0; i < arr.length; i++) {
        total += arr[i];
    }
    return total
}

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

Answer 40

您可以使用 for of 循環獲取總和，如下所示：

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

Answer 41

嘗試這個...

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

Answer 42

Vanilla JavaScript 就是你所需要的：

> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; a.forEach(function(e){sum += e}); sum
10
> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; a.forEach(e => sum += e); sum
10
> 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; sum
10

Answer 43

這個函數可以總結所有的數字——

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

Answer 44

考慮到你有數組

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

Answer 45

我認為這是找到數字總和數組的簡單方法

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

Answer 46

只需使用此功能：

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

Answer 47

一個“重復”問題詢問如何對二維數組執行此操作，因此這是回答該問題的簡單改編。 （區別僅在於六個字符[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

Answer 48

你可以試試這個：

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

console.log(total);

輸出將是：1664

或者如果 value 是 Fl​​oat，那么試試這個：

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

Answer 49

我知道這是一個舊帖子。 但我只是想分享我解決這個問題的方法。

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

Answer 50

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

Answer 51

事實是有一個古老而有趣的經典解決方案（除了新手'foreach'和'reduce'）：經典for of 。

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

Answer 52

TL;博士

如果您關心性能，請定義一個使用for循環的 function。

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

基准

我使用benchmark.js （打字稿版本）對一系列實現進行了基准測試：

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 automatically
        const 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循環的實現是最快的：

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)

討論

定義匿名 function 的實現通常較慢，因為創建匿名 function 的開銷很大。 當使用大型數組運行基准測試時，例如長度為 1000 而不是 100， reduce和基於for循環的實現之間的差異在 chrome 中變得微不足道。

Chrome 的 V8 引擎知道如何在reduce中內聯簡單的匿名函數，因為reduce測試用例比predefined reduce測試用例快得多。 Firefox 似乎嘗試了類似的方法，但這樣做效率較低。 非內聯 function 調用在 js 中非常慢，因為調用堆棧的效率低於編譯軟件中的調用堆棧。

與reduce類似，基於forEach和jquery的實現使用匿名函數並且相對較慢。 lodash有一個專門的sum實現，但它（從 v4.0.0 開始）被實現為sumBy的一個特例，效率相對較低。

eval是迄今為止最慢的測試用例。 這是有道理的，因為使用連接構造字符串可能會導致幾個動態分配（速度很慢）。 接下來，必須調用解析器，然后才能最終執行代碼。

我已經包含了一些遞歸實現，因為互聯網上的一些人聲稱遞歸比 js 中的循環更快。 我無法重現他們的示例-使用benchmark.js ，遞歸非常慢，並且當使用帶有循環的console.time時，兩個函數都需要相同的時間。 在計算總和時，正如預期的那樣，遞歸比循環慢得多，這可能是由於 js 調用堆棧的大量使用。

天真的實現將手動添加數組的所有 100 個元素。 雖然很不方便，但這是最快的實現。 但是，幸運的是， for循環非常接近。 在循環周圍添加單個 function 調用不會損害性能。 因此，您可以從上面隨意使用實用程序 function。

我無法解釋為什么while循環比for循環慢。 反向迭代數組似乎不是這里的問題。

Answer 53

有人也可以使用map()函數對數組值求和。

function sumOfArrVal(arr){
    let sum=0;
    arr.map(val=>sum+=val)
    return sum
}

let result=sumOfArrVal([1,2,3,4])
console.log(result)

Answer 54

沒有人提到函數式編程，但在這種情況下使用 Ramda 將是一種非常干凈的方法：

//Assuming you use nodejs, but can also be used in browser
const R = require('ramda');

let nums = [2, 4, 6, 8, 10];
console.log(R.sum(nums));

Answer 55

我看到這是一個老問題，但實際上幾乎沒有任何答案使用 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

Answer 56

使用遞歸

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

Answer 57

此外，使用es6求和以獲得簡單array 。

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

Answer 58

對於非常大的數字，循環或減少可能是過程密集型的。 用高斯怎么樣？

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

來自數學中心。

Answer 59

    <!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>

Answer 60

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