Javascript 如何求一组数字的和

给定一个数组

[1,2,3,4]

，如何找到它的元素之和？（在这种情况下，总和为

10

）

---

我认为可能有用，但我不确定如何实现它。

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

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

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

var加法=[]；
加推（2）；
加推（3）；
var合计=0；
对于（变量i=0；i

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

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

这将平均需要1.57 ms/次运行（在100个随机正态数的阵列上测量1000次以上的运行），相比之下，使用上述

eval（）

方法需要3.604 ms/次运行，使用（i，长度，++）循环标准需要2.151 ms/次运行

方法说明：这个测试是在Google Apps脚本服务器上运行的，所以他们的javascript引擎与Chrome几乎相同

编辑：

--i

而不是

i--

每次运行可节省0.12毫秒（i--为1.7）

---

编辑：神圣的咒骂，别管这篇文章了使用上面提到的reduce（）方法，只需1 ms/次运行。

这可以通过循环所有项目，并在每次迭代中将它们添加到一个

sum

-变量来实现

var array = [1, 2, 3];

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

如上所述，但作为简单函数进行注释和准备：

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

函数数组（数组）{
为了(
变量
index=0，//迭代器
length=array.length，//缓存数组长度
sum=0；//总金额
索引<长度；//循环条件为
sum+=array[index++]//在每次迭代中添加数字
);
回报金额；
}
在中，这正是
reduce
的工作。您会看到这种代码：

（减少#'+'（1、2、3））；6.

幸运的是，在JavaScript中，我们也有！不幸的是，
+
是一个运算符，而不是一个函数。但我们可以让它变得漂亮！看这里：

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

这不是很漂亮吗？：-）

更好！如果您使用的是ECMAScript2015（aka），它可以是这样漂亮：

const sum = [1, 2, 3].reduce((partial_sum, a) => partial_sum + a,0); 
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)

var数=[1,2,3,4]；
var totalAmount=0；
对于（变量x=0；x

参考资料：
有人在寻找像我这样功能强大的oneliner吗？拿这个来说：

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

（如果您碰巧必须支持没有箭头功能的旧IE:）

这里有一些很酷的技巧，我对许多安全的传统答案有一些挑剔，这些答案不缓存数组的长度

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

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

函数数组sum（数组）{
var总计=0，
len=数组长度；
对于（变量i=0；i

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

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

这里有一个arraySum函数的代码笔链接。

这可能是一种过时的思维方式，一直困扰着我，但我不认为在这种情况下使用它有什么坏处。
您也可以使用reduceRight

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

结果输出为21

参考资料：
如果您碰巧正在使用Lodash，则可以使用该功能

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

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

var myNumbers=[1,2,3,4,5]
var合计=0；
对于（变量i=0；i

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

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

这样你就可以把各种各样的异国情调的东西放进阵列中

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

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是建议的最后一个数字
（使用默认值减少）
可用于遍历数组，将当前元素值添加到先前元素值之和


console.log(
[1,2,3,4]。减少（（a，b）=>a+b，0）
)
console.log(
[]减少（（a，b）=>a+b，0）
)
使用
减少


让arr=[1,2,3,4]；
让sum=arr.reduce（（v，i）=>（v+i））；
控制台日志（总和）这要容易得多

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

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

console.log(sum)

一些人建议在
数组.prototype
中添加
.sum（）
方法。这通常被认为是不好的做法，所以我不是建议你这么做

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

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

然后：
[1,2].sum（）；//3

请注意，添加到原型中的函数混合使用ES5和ES6函数以及箭头语法。声明
函数
以允许该方法从您正在操作的
数组
中获取
此
上下文。我在
reduce
调用中使用了
=>
以简化操作。
无需
初始值
！因为
eval([1,2,3].join("+"))

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

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

console.log(sum)

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

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

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

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

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

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

total(arr); //return 10

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

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

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

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

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

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

const array = [1, 2, 3, 4];
let result = 0;

array.forEach(number => {
  result += number;
})

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

const array = [10, 20, 30, 40];
const add = (a, b) => a + b
const result = array.reduce(add);

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

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

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