给定数组[1, 2, 3, 4]，我如何找到其元素的总和？ （在这种情况下，总和将是10。）
我认为$.each可能有用，但我不确定如何实现它。
答案 0 :(得分：1151)
在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
答案 1 :(得分：197)
为什么不减少？它通常有点反直觉，但使用它来查找总和非常简单：
var a = [1,2,3];
var sum = a.reduce(function(a, b) { return a + b; }, 0);
答案 2 :(得分：169)
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)
)
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]更改为＆＃34; 1 + 2 + 3＆＃34;，其值为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的一个问题的答案，因为我认为它没有被澄清。
答案 3 :(得分：85)
var arr = [1,2,3,4];
var total=0;
for(var i in arr) { total += arr[i]; }
答案 4 :(得分：60)
var total = 0;
$.each(arr,function() {
total += this;
});
答案 5 :(得分：27)
这可以通过循环所有项目，并在每次迭代时将它们添加到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 :(得分：25)
如果您正好使用Lodash，可以使用sum功能
array = [1, 2, 3, 4];
sum = _.sum(array); // sum == 10
答案 7 :(得分：23)
arr.reduce(function (a, b) {
return a + b;
});
答案 8 :(得分：13)
// Given array 'arr'
var i = arr.length;
var sum = 0;
while (--i) sum += arr[i];
这将平均需要1.57毫秒/运行（在100个随机正常数字的阵列上测量超过1000次），相比之下，使用上述eval()方法运行3.604 ms /运行，使用标准运行2.151 ms /运行for（i，length，++）loop。
方法说明：此测试是在Google Apps脚本服务器上运行的，因此他们的javascript引擎与Chrome几乎相同。
编辑：--i代替i--每次运行节省0.12毫秒（i--为1.7）
答案 9 :(得分：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
答案 10 :(得分：11)
有趣的方法：
{{1}}
答案 11 :(得分：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 ...
答案 12 :(得分：11)
任何人都在寻找像我一样的功能性oneliner？拿这个：
sum= arr.reduce(function (a, b) {return a + b;}, 0);
答案 13 :(得分：9)
标准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）。我希望这种解决方案没有隐藏的劣势。
答案 14 :(得分：5)
我是JavaScript和编码的初学者，但我发现在数组中对数字求和的简单方法就像这样：
var myNumbers = [1,2,3,4,5]
var total = 0;
for(i=0; i<myArray.length; i++){
total += myArray[i];
}
基本上，我想做出贡献，因为我没有看到很多不使用内置函数的解决方案，而且这种方法易于编写和理解。
答案 15 :(得分：5)
var arr = ['(1/3)','Date.now()','foo','bar()',1,2,3,4]
这样你就可以将各种异国情调的东西放在阵列中。
<input>我只是半开玩笑。
答案 16 :(得分：4)
这是一个优雅的单行解决方案，使用stack algorithm，但可能需要一些时间才能理解这种实现的美妙。
const getSum = arr => (arr.length === 1) ? arr[0] : arr.pop() + getSum(arr);
getSum([1, 2, 3, 4, 5]) //15
基本上，该函数接受一个数组并检查该数组是否只包含一个项目。如果为false，则将最后一项弹出堆栈并返回更新的数组。
此片段的优点在于该函数包含arr[0]检查以防止无限循环。一旦到达最后一个项目，它将返回整个总和。
答案 17 :(得分：4)
一小段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)
答案 18 :(得分：4)
使用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
答案 19 :(得分：4)
有些人建议在.sum()中添加Array.prototype方法。这通常被认为是不好的做法，所以我不建议你这样做。
如果你仍然坚持这样做，那么这是一种简洁的写作方式：
Array.prototype.sum = function() {return [].reduce.call(this, (a,i) => a+i, 0);}
然后：[1,2].sum(); // 3
请注意，添加到原型中的函数使用ES5和ES6函数以及箭头语法的混合。声明function允许该方法从您正在操作的this获取Array上下文。我在=>调用中使用了reduce来简化。
答案 20 :(得分：3)
您可以将reduce（）方法与lambda表达式结合使用：
[1, 2, 3, 4].reduce((accumulator, currentValue) => accumulator + currentValue);
答案 21 :(得分：3)
使用pic = facebook.get('/me/picture?redirect=false').data
print 'picture:', pic['data']["url"]
reduce
答案 22 :(得分：3)
无需initial value！因为如果没有传递initial value，则不会在列表的第一个元素上调用callback function，而是将第一个元素作为initial value传递。非常 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
答案 23 :(得分：2)
我看到所有答案都是为了减少＆＃39;解决方案
var array = [1,2,3,4]
var total = 0
for (var i = 0; i < array.length; i++) {
total += array[i]
}
console.log(total)
答案 24 :(得分：2)
酷炫的技巧，我已经得到了很多安全的传统答案，并没有缓解阵列的长度。
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
可能这是一种过时的心态，但我并不认为在这种情况下使用它会有不利之处。
答案 25 :(得分：2)
这更容易
function sumArray(arr) {
var total = 0;
arr.forEach(function(element){
total += element;
})
return total;
}
var sum = sumArray([1,2,3,4])
console.log(sum)
答案 26 :(得分：2)
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
答案 27 :(得分：2)
这些都是非常好的答案，但是如果数字是顺序的，如问题（1,2,3,4），您可以通过应用公式轻松地做到这一点 （n *（n + 1））/ 2其中n是最后一个数字
答案 28 :(得分：1)
考虑到您拥有数组
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
答案 29 :(得分：1)
提高准确性：对数组进行排序并从最小的数字开始求和
[...arr].sort().reduce((a,c)=>a+c,0)
arr=[.6,9,.1,.1,.1,.1]
sum = arr.reduce((a,c)=>a+c,0)
sortSum = [...arr].sort().reduce((a,c)=>a+c,0)
console.log('sum: ',sum);
console.log('sortSum:',sortSum);
console.log('sum==sortSum :', sum==sortSum);
对于数字的多维数组，请使用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
答案 30 :(得分：1)
当数组由字符串组成时，必须更改代码。如果数组是数据库请求的结果，则可能是这种情况。这段代码有效：
alert(
["1", "2", "3", "4"].reduce((a, b) => Number(a) + Number(b), 0)
);
在此处，[“ 1”，“ 2”，“ 3”，“ 4”]组成字符串数组，并且函数Number()将字符串转换为数字。
答案 31 :(得分：1)
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
答案 32 :(得分：1)
此功能可以汇总所有数字 -
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])
答案 33 :(得分：1)
试试这个......
function arrSum(arr){
total = 0;
arr.forEach(function(key){
total = total + key;
});
return total;
}
答案 34 :(得分：0)
只需使用此功能：
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));
答案 35 :(得分：0)
了解底层流程的最简单答案：
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)
答案 36 :(得分：0)
//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))
答案 37 :(得分：0)
非常简单
第 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));
}
第三步
const sumInArray = dataData.reduce( (a, b) => a + b);
终于
console.log(sumInArray);
答案 38 :(得分：0)
我知道这是一个旧帖子。但我只是想分享我解决这个问题的方法。
let myArr = [1, 3, 4, 5, 6, 7, 8];
let counter = 0;
for(i=0; i < myArr.length; i++){
counter = counter + myArr[i];
console.log(counter);}
答案 39 :(得分：0)
let total = 0;
for (let value of [1,2,3,4]) {
total += value;
}
答案 40 :(得分：0)
此外，将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);
答案 41 :(得分：0)
您可以尝试以下方法：
var arr = [100,114,250,1200];
var total = 0;
for(var i in arr){
total += parseInt(arr[i]);
}
console.log(total);
输出将是：1664
或者，如果值是Float，请尝试以下操作：
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
答案 42 :(得分：0)
一个简单的方法示例：
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]));
答案 43 :(得分：0)
一个“重复”问题询问如何对二维数组执行此操作，因此这是回答该问题的简单方法。 （区别只是六个字符[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
答案 44 :(得分：0)
使用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));
答案 45 :(得分：-2)
使用递归
var sum = (arr) => arr.length === 1 ? arr[0] : arr.shift() + sum(arr);
sum([1,2,3,4]) // 10
答案 46 :(得分：-2)
对于非常大的数字循环或减少可能是过程密集型。那么使用高斯呢？
#include <iostream>
using namespace std;
int main() {
cout << "Fixed delay with circular buffer" << endl;
int dtime = 5;
int buffersize = 10;
auto *in = new int[buffersize];
auto *del = new int[dtime];
auto *out = new int[buffersize];
int *p = del;
// zero-initialise the delay line
for (int i = 0; i < dtime; i++) {
del[i] = 0;
}
// fill the in buffer
for (int i = 0; i < buffersize; i++) {
in[i] = i;
}
// apply delay
for (int i = 0; i < buffersize; i++) {
cout << *p << ' ';
// read
out[i] = del[*p];
// write
del[*p] = in[i];
// update pointer
*p = (*p != dtime-1? *p+1 : 0);
}
for (int i = 0; i < buffersize; i++) {
cout << endl << out[i] << ' ';
}
delete[] in;
delete[] out;
delete[] del;
return 0;
}
来自mathcentral。
答案 47 :(得分：-3)
click "confirm merge"
答案 48 :(得分：-9)
使用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();