如何找到数字数组的总和

给定一个数组[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 (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;
}

#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 emptyfunction 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.1401255o = {a:1,b:31,c:"roffelz",someOtherProperty:21.52}
console.log(o.sum());              // 53.519999999999996

#18楼

没有默认值

您收到一个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);