如何找到一组数字的总和

Question

给定一个数组[1, 2, 3, 4],我如何找到其元素的总和？(在这种情况下,总和将是10.)

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

Answer 1

在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

Answer 2

推荐(默认值减少)

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的问题的答案,因为我认为它没有得到澄清.

Answer 3

为什么不减少？它通常有点反直觉,但使用它来查找总和非常简单:

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

Answer 4

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

Answer 5

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

Answer 6

这可以通过循环遍历所有项目,并在每次迭代时将它们添加到sum-variable.

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

Answer 7

如果你碰巧使用Lodash,你可以使用sum函数

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

Answer 8

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

参考:Array.prototype.reduce()

Answer 9

您可以尝试以下代码：

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

Answer 10

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

这将平均花费1.57毫秒/运行(在100个随机正常数字的阵列上测量1000次运行),相比之下,使用上述eval()方法运行3.604毫秒/运行,运行标准为2.151毫秒/ (i,长度,++ )循环.

方法说明:此测试是在Google Apps脚本服务器上运行的,因此他们的javascript引擎与Chrome几乎完全相同.

编辑:--i代替i--节省0.12毫秒每次运行时(我-是1.7)

编辑:神圣的咒骂,不要介意这整篇文章.使用上面提到的reduce()方法,它只有1 ms/run.

Answer 11

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

Answer 12

有趣的方法:

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

Answer 13

好吧,想象一下下面有这个数组:

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)使用array forEach

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

并称之为:

total(arr); //return 10

不建议将这样的原型原型化为Array ...

Answer 14

长话短说

\n

如果您关心性能，请定义一个使用for循环的函数。

\n

function sum(arr) {\n    var res = 0;\n    for (var x of arr) {\n        res += x;\n    }\n    return res;\n}\n

\n

基准

\n

benchmark.js我使用（打字稿版本）对一系列实现进行了基准测试：

\n

const arr = Array.from({ length: 100 }, () => Math.random());\nconst reducer = function (p: number, a: number) {\n    return p + a;\n};\nconst recursion = function (arr: number[], i: number) {\n    if(i > 0) return arr[i] + recursion(arr, i - 1)\n    else return 0\n};\nconst recursion2 = function (arr: number[], i: number, len: number) {\n    if(i < len) return arr[i] +  recursion2(arr, i + 1, len)\n    else return 0\n};\nconst recursion3 = function (arr: number[], i: number) {\n    if(i < arr.length) return arr[i] + recursion3(arr, i + 1)\n    else return 0\n};\nnew Benchmark.Suite()\n    .add("jquery", () => {\n        let res = 0;\n        $.each(arr, (_, x) => (res += x));\n    })\n    .add("lodash", ()=>_.sum(arr))\n    .add("forEach", () => {\n        let res = 0;\n        arr.forEach((x) => (res += x));\n    })\n    .add("reduce", () => arr.reduce((p, a) => p + a, 0))\n    .add("predefined reduce", () => arr.reduce(reducer, 0))\n    .add("eval", () => eval(arr.join("+")))\n    .add("recursion", () => recursion(arr, arr.length - 1))\n    .add("recursion2", () => recursion2(arr, 0, arr.length))\n    .add("recursion3", () => recursion3(arr, 0))\n    .add("naive", () => (\n        arr[0]+arr[1]+arr[2]+arr[3]+arr[4]+arr[5]+arr[6]+arr[7]+arr[8]+arr[9]+\n        arr[10]+arr[11]+arr[12]+arr[13]+arr[14]+arr[15]+arr[16]+arr[17]+arr[18]+arr[19]+\n        arr[20]+arr[21]+arr[22]+arr[23]+arr[24]+arr[25]+arr[26]+arr[27]+arr[28]+arr[29]+\n        arr[30]+arr[31]+arr[32]+arr[33]+arr[34]+arr[35]+arr[36]+arr[37]+arr[38]+arr[39]+\n        arr[40]+arr[41]+arr[42]+arr[43]+arr[44]+arr[45]+arr[46]+arr[47]+arr[48]+arr[49]+\n        arr[50]+arr[51]+arr[52]+arr[53]+arr[54]+arr[55]+arr[56]+arr[57]+arr[58]+arr[59]+\n        arr[60]+arr[61]+arr[62]+arr[63]+arr[64]+arr[65]+arr[66]+arr[67]+arr[68]+arr[69]+\n        arr[70]+arr[71]+arr[72]+arr[73]+arr[74]+arr[75]+arr[76]+arr[77]+arr[78]+arr[79]+\n        arr[80]+arr[81]+arr[82]+arr[83]+arr[84]+arr[85]+arr[86]+arr[87]+arr[88]+arr[89]+\n        arr[90]+arr[91]+arr[92]+arr[93]+arr[94]+arr[95]+arr[96]+arr[97]+arr[98]+arr[99]))\n    .add("loop with iterator", () => {\n        let res = 0;\n        for (const x of arr) res += x;\n    })\n    .add("traditional for loop", () => {\n        let res = 0;\n        // cache the length in case the browser can\'t do it automatically\n        const len = arr.length;\n        for (let i = 0; i < len; i++) res += arr[i];\n    })\n    .add("while loop", () => {\n        let res = 0;\n        let i = arr.length;\n        while (i--) res += arr[i];\n    })\n    .add("loop in a function ", () => sum(arr))\n    .on("cycle", (event) => console.log(String(event.target)))\n    .run();\n

\n

在 chrome 104 中，for基于循环的实现是最快的：

\n

const arr = Array.from({ length: 100 }, () => Math.random());\nconst reducer = function (p: number, a: number) {\n    return p + a;\n};\nconst recursion = function (arr: number[], i: number) {\n    if(i > 0) return arr[i] + recursion(arr, i - 1)\n    else return 0\n};\nconst recursion2 = function (arr: number[], i: number, len: number) {\n    if(i < len) return arr[i] +  recursion2(arr, i + 1, len)\n    else return 0\n};\nconst recursion3 = function (arr: number[], i: number) {\n    if(i < arr.length) return arr[i] + recursion3(arr, i + 1)\n    else return 0\n};\nnew Benchmark.Suite()\n    .add("jquery", () => {\n        let res = 0;\n        $.each(arr, (_, x) => (res += x));\n    })\n    .add("lodash", ()=>_.sum(arr))\n    .add("forEach", () => {\n        let res = 0;\n        arr.forEach((x) => (res += x));\n    })\n    .add("reduce", () => arr.reduce((p, a) => p + a, 0))\n    .add("predefined reduce", () => arr.reduce(reducer, 0))\n    .add("eval", () => eval(arr.join("+")))\n    .add("recursion", () => recursion(arr, arr.length - 1))\n    .add("recursion2", () => recursion2(arr, 0, arr.length))\n    .add("recursion3", () => recursion3(arr, 0))\n    .add("naive", () => (\n        arr[0]+arr[1]+arr[2]+arr[3]+arr[4]+arr[5]+arr[6]+arr[7]+arr[8]+arr[9]+\n        arr[10]+arr[11]+arr[12]+arr[13]+arr[14]+arr[15]+arr[16]+arr[17]+arr[18]+arr[19]+\n        arr[20]+arr[21]+arr[22]+arr[23]+arr[24]+arr[25]+arr[26]+arr[27]+arr[28]+arr[29]+\n        arr[30]+arr[31]+arr[32]+arr[33]+arr[34]+arr[35]+arr[36]+arr[37]+arr[38]+arr[39]+\n        arr[40]+arr[41]+arr[42]+arr[43]+arr[44]+arr[45]+arr[46]+arr[47]+arr[48]+arr[49]+\n        arr[50]+arr[51]+arr[52]+arr[53]+arr[54]+arr[55]+arr[56]+arr[57]+arr[58]+arr[59]+\n        arr[60]+arr[61]+arr[62]+arr[63]+arr[64]+arr[65]+arr[66]+arr[67]+arr[68]+arr[69]+\n        arr[70]+arr[71]+arr[72]+arr[73]+arr[74]+arr[75]+arr[76]+arr[77]+arr[78]+arr[79]+\n        arr[80]+arr[81]+arr[82]+arr[83]+arr[84]+arr[85]+arr[86]+arr[87]+arr[88]+arr[89]+\n        arr[90]+arr[91]+arr[92]+arr[93]+arr[94]+arr[95]+arr[96]+arr[97]+arr[98]+arr[99]))\n    .add("loop with iterator", () => {\n        let res = 0;\n        for (const x of arr) res += x;\n    })\n    .add("traditional for loop", () => {\n        let res = 0;\n        // cache the length in case the browser can\'t do it automatically\n        const len = arr.length;\n        for (let i = 0; i < len; i++) res += arr[i];\n    })\n    .add("while loop", () => {\n        let res = 0;\n        let i = arr.length;\n        while (i--) res += arr[i];\n    })\n    .add("loop in a function ", () => sum(arr))\n    .on("cycle", (event) => console.log(String(event.target)))\n    .run();\n

\n

Firefox 104 显示了类似的行为：

\n

jquery               x  1,832,472 ops/sec \xc2\xb11.35% (61 runs sampled)\nlodash               x  2,079,009 ops/sec \xc2\xb11.11% (68 runs sampled)\nforEach              x  4,887,484 ops/sec \xc2\xb12.35% (67 runs sampled)\nreduce               x 21,762,391 ops/sec \xc2\xb10.46% (69 runs sampled)\npredefined reduce    x  2,026,411 ops/sec \xc2\xb10.50% (68 runs sampled)\neval                 x     33,381 ops/sec \xc2\xb12.54% (66 runs sampled)\nrecursion            x  2,252,353 ops/sec \xc2\xb12.13% (62 runs sampled)\nrecursion2           x  2,301,516 ops/sec \xc2\xb11.15% (65 runs sampled)\nrecursion3           x  2,395,563 ops/sec \xc2\xb11.65% (66 runs sampled)\nnaive                x 31,244,240 ops/sec \xc2\xb10.76% (66 runs sampled)\nloop with iterator   x 29,554,762 ops/sec \xc2\xb11.07% (66 runs sampled)\ntraditional for loop x 30,052,685 ops/sec \xc2\xb10.67% (66 runs sampled)\nwhile loop           x 18,624,045 ops/sec \xc2\xb10.17% (69 runs sampled)\nloop in a function   x 29,437,954 ops/sec \xc2\xb10.54% (66 runs sampled)\n

\n

讨论

\n

定义匿名函数的实现通常较慢，因为创建匿名函数是一个很大的开销。reduce当使用大型数组（例如，长度为 1000 而不是 100）运行基准测试时，基于循环的实现之间的差异for在 chrome 中变得微不足道。

\n

Chrome 的 V8 引擎知道如何内联简单的匿名函数，reduce因为reduce测试用例比测试用例快得多predefined reduce。Firefox 似乎也在尝试类似的做法，但效率较低。非内联函数调用在 js 中相当慢，因为调用堆栈的效率低于编译软件中的调用堆栈。

\n

与 类似reduce，基于forEach- 和 -jquery的实现使用匿名函数并且相对较慢。lodash有一个专门的sum实现，但它（从 v4.0.0 开始）是作为 的特殊情况实现的sumBy，效率相对较低。

\n

eval是迄今为止最慢的测试用例。这是有道理的，因为使用连接构造字符串可能会导致多次动态分配（速度很慢）。接下来，必须调用解析器，然后才能最终执行代码。

\n

我已经包含了一些递归实现，因为互联网上的一些人声称递归比 js 中的循环更快。我无法重现他们的示例 - 使用benchmark.js，递归非常慢，并且当使用console.time循环时，两个函数花费相同的时间。当计算总和时，正如预期的那样，递归比循环慢得多，可能是由于 js 调用堆栈的大量使用。

\n

最简单的实现是手动添加数组的所有 100 个元素。虽然相当不方便，但这是最快的实现。但幸运的是，for-循环非常接近。在循环周围添加单个函数调用不会损害性能。因此，您可以随意使用上面的实用函数。

\n

我没有解释为什么while循环比循环慢for。反向迭代数组似乎不是这里的问题。

\n

Answer 15

有人在寻找像我一样的功能性oneliner吗？拿着这个:

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

Answer 16

标准的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).我希望这种解决方案没有隐藏的劣势.

Answer 17

ES6 for..of 的

let total = 0;

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

Answer 18

我是JavaScript和编码的初学者,但我发现在数组中对数字求和的简单方法就像这样:

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

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

Answer 19

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

这样你就可以在阵列中放置各种奇特的东西.

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

我只是半开玩笑.

Answer 20

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

Answer 21

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

Answer 22

使用reduce

let arr = [1, 2, 3, 4];

let sum = arr.reduce((v, i) => (v + i));

console.log(sum);

Answer 23

有几个人建议增加.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通话中使用了。

Answer 24

无需initial value！因为如果initial value传递 no ，则不callback function会对列表的第一个元素调用 ，而是将第一个元素作为 传递initial value。非常c 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

Answer 25

这是一个使用堆栈算法的优雅的单行解决方案，尽管人们可能需要一些时间才能理解这种实现的美妙之处。

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

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

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

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

Answer 26

准确性

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

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

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

对于多维数字数组使用arr.flat(Infinity)

arr=[.6,9,.1,.1,.1,.1]

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

console.log('sum:     ',sum);
console.log('sortSum:',sortSum);
console.log('sum==sortSum :', sum==sortSum);

// we use .sort((a,b)=>a-b) instead .sort() because
// that second one treat elements like strings (so in wrong way)
// e.g [1,10,9,20,93].sort() -->  [1, 10, 20, 9, 93]

Answer 27

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

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)

Answer 28

有没有理由不先过滤数组以删除非数字？看起来很简单：

[1, 2, 3, null, 'a'].filter((x) => !isNaN(x)).reduce((a, b) => a + b)