如何找到一个数字数组的总和

这正是 reduce 的工作。

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

const sum = [1, 2, 3].reduce((partialSum, a) => partialSum + a, 0);控制台.log（总和）； // 6

对于较旧的 JS：

const sum = [1, 2, 3].reduce(add, 0); // 当数组为空时避免初始值 function add(accumulator, a) { return accumulator + a; } 控制台日志（总和）； // 6

那不是很漂亮吗？ :-)

---

推荐（使用默认值减少）

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 +值；}, 0))

非数字输入

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

console.log( ["hi", 1, 2, "frog"].reduce((a, b) => a + b) ) 让 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('+')) ) //如果数组是根据用户输入构建的，这种方式很危险 // 因为它可能被利用，例如：eval([1, "2;alert('恶意代码！')"].join('+'))

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

---

为什么不减？这通常有点反直觉，但使用它来求和非常简单：

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

---

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

---

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

---

任何人都在寻找像我这样的功能性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 是初始值，因此您可以根据需要将其用作偏移量。还要注意这个初始值是需要的，否则用空数组调用函数会出错。

---

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

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

---

这可以通过循环遍历所有项目，并在每次迭代中将它们添加到 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;
}

---

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

参考：Array.prototype.reduce()

---

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

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

---

您也可以使用 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

---

有趣的方法：

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

---

一个标准的 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）。我希望这种解决方案没有隐藏的缺点。

---

我是 JavaScript 和一般编码的初学者，但我发现对数组中的数字求和的简单方法如下：

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

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

---

您可以尝试以下代码：

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

---

使用 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

---

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

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

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

我只是半开玩笑。

---

一些人建议向 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 调用中使用了 =>。

---

ES6 for..of

let total = 0;

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

---

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

---

使用reduce

让 arr = [1, 2, 3, 4];让 sum = arr.reduce((v, i) => (v + i));控制台.log（总和）；

---

无需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

---

这是一个使用 stack algorithm 的优雅的单行解决方案，但可能需要一些时间才能了解此实现的美妙之处。

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

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

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

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

---

准确性

对数组进行排序并从最小数字开始求和（片段显示与非排序的差异）

[...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); // 我们使用 .sort((a,b)=>ab) 代替 .sort() 因为 // 第二个将元素视为字符串（因此方式错误） // 例如 [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);控制台.log（总和）； // 60

---

这些确实是很好的答案，但以防万一数字按问题（1,2,3,4）中的顺序排列，您可以通过应用公式 (n*(n+1))/2 轻松做到这一点，其中n 是最后一个数字

---

您可以将 reduce() 方法与 lambda 表达式结合使用：

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

---

使用减少（）

[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

---

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

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

---

很简单

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

---

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

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)

---