如何找到数字数组的总和

给定一个数组[1, 2, 3, 4] ，我如何找到它的元素之和？ （在这种情况下，总和为10 ）

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

---

#1楼

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

---

#2楼

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

---

#3楼

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

---

#4楼

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

平均运行时间为1.57毫秒（在100个随机正常数的数组上测量1000次运行），而上述eval()方法的运行时间为3.604毫秒，而标准的（i，length eval()运行时间为2.151毫秒，++）循环。

方法论说明：该测试在Google Apps脚本服务器上运行，因此其javascript引擎与Chrome几乎相同。

编辑：-- --i代替i--每次运行可节省0.12毫秒（i--为1.7）

编辑：神圣的咒骂，不要介意这整个职位。 使用上面提到的reduce（）方法，每次运行只有1毫秒。

---

#5楼

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

---

#6楼

在Lisp中 ，这正是reduce工作量的工作。 您会看到以下代码：

(reduce #'+ '(1 2 3)) ; 6

幸运的是，在JavaScript中，我们也有reduce ！ 不幸的是， +是运算符，而不是函数。 但是我们可以使其漂亮！ 在这里，看看：

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

那不是很漂亮吗？ :-)

更好！ 如果您使用的是ECMAScript 2015（又名ECMAScript 6 ），它可能会很漂亮：

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

---

#7楼

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

---

#8楼

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

参考： Array.prototype.reduce（）

---

#9楼

任何人都在寻找像我这样的功能强大的内衬吗？ 拿着它：

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

---

#10楼

这里的技巧很酷，我选择了很多安全的传统答案，而不用担心数组的长度。

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

这可能是我束手无策的一种过时的心态，但是我认为在这种情况下使用它并不不利。

---

#11楼

您也可以使用reduceRight。

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

结果输出为21。

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

---

#12楼

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

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

---

#13楼

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

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

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

---

#14楼

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

这样，您可以将各种奇特的东西放入数组中。

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

我只是在开玩笑。

---

#15楼

有趣的方法：

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

---

#16楼

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

---

#17楼

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

---

#18楼

推荐（减少默认值）

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问题的回答，因为我认为这没有得到澄清。

---

#19楼

使用reduce

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

---

#20楼

尝试这个...

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

---

#21楼

这容易得多

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

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

console.log(sum)

---

#22楼

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

---

#23楼

一些人建议向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呼叫。

---

#24楼

无需initial value ！ 因为如果没有传递initial value ，则不会在列表的第一个元素上调用callback function ，而是将第一个元素作为initial value传递。 非常有趣的功能:)

[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

---

#25楼

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

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

---

#26楼

这是一种使用堆栈算法的优雅的单线解决方案，尽管您可能需要一些时间来了解此实现的优点。

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

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

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

此代码段的优点在于该函数包括arr[0]检查以防止无限循环。 一旦到达最后一项，它将返回全部金额。

---

#27楼

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

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

---

#28楼

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

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

---

#29楼

一个简单的方法示例：

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

---

#30楼

使用for循环：

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

for (let i = 0; i < array.length - 1; i++) {
  result += array[i];
}

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

甚至是forEach循环：

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

---

#31楼

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

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