如何找到一个数字数组的总和

【问题标题】：How to find the sum of an array of numbers如何找到一个数字数组的总和
【发布时间】：2010-11-16 20:16:36
【问题描述】：

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

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

【问题讨论】：

  • 这个问题在meta discussion下
  • @tereško 不愿意使用 Google 并不是 Stackoverflow 上的有效关闭理由。如果您觉得问题没有很好地（重新）搜索，请投反对票。 （同样从答案来看 - 这似乎是一个极具争议的话题，有许多可能的解决方案，包括一些高度赞成的不良做法（评估） - 令人惊讶。）
  • 注意：这里的大多数答案本质上是计算a[0] + a[1] + ...，如果数组有非数字元素，它可以变成字符串连接。例如。 ['foo', 42].reduce((a,b)=>a+b, 0) === "0foo42".
  • 没有内置的减速器可以提供给 Array.reduce？想像[1,2,3].reduce(Math.sum)。

标签： javascript jquery arrays


【解决方案1】：

这里有很酷的技巧，我挑选了很多安全的传统答案，不缓存数组的长度。

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

这可能是一种过时的心态一直困扰着我，但我不认为在这种情况下使用它有什么缺点。

【讨论】：

  • 缓存长度的问题是一个红鲱鱼。 JS 引擎会毫不犹豫地为您优化。
【解决方案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)

【讨论】：

    【解决方案3】：

    一个简单的方法示例：

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

    【讨论】：

      【解决方案4】：

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

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

      【讨论】：

        【解决方案5】： 
        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

        【讨论】：

        • 此代码是否会删除您的操作系统？还是它会将您的个人信息发送给我？
        【解决方案6】：

        试试这个...

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

        【讨论】：

        • 请为您的答案添加解释。仅代码答案不解释代码的工作原理。
        【解决方案7】：

        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

        【讨论】：

          【解决方案8】：

          这个函数可以把所有的数字相加-

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

          【讨论】：

            【解决方案9】：

            带 ES6 的 rest 参数

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

            【讨论】：

            • 请注意，给定一个大数组，这将导致堆栈溢出异常（扩展运算符通常会导致大输入）
            【解决方案10】：

            考虑到你有数组

            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

            【讨论】：

              【解决方案11】：

              只要使用这个功能：

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

              【讨论】：

                【解决方案12】：

                一个“重复”问题询问如何对二维数组执行此操作，因此这是回答该问题的简单改编。 （区别只是[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

                【讨论】：

                  【解决方案13】：

                  你可以试试这个：

                  var arr = [100,114,250,1200];
var total = 0; 
for(var i in arr){
  total += parseInt(arr[i]);
}

console.log(total);

                  输出将是：1664

                  或者如果 value 是 Fl​​oat，那么试试这个：

                  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

                  【讨论】：

                    【解决方案14】：

                    我知道这是一篇旧帖子。但我只是想分享我解决问题的方法。

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

                    【讨论】：

                      【解决方案15】： 
                      //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))

                      【讨论】：

                        【解决方案16】：

                        也有人可以使用map() 函数对数组值求和。

                        function sumOfArrVal(arr){
    let sum=0;
    arr.map(val=>sum+=val)
    return sum
}

let result=sumOfArrVal([1,2,3,4])
console.log(result)

                        【讨论】：

                          【解决方案17】：

                          没有人提到函数式编程，但在这种情况下使用 Ramda 将是一种非常干净的方法：

                          //Assuming you use nodejs, but can also be used in browser
const R = require('ramda');

let nums = [2, 4, 6, 8, 10];
console.log(R.sum(nums));

                          【讨论】：

                            【解决方案18】： 
                            getTotal = (arr) => {
    let total = 0
    for (let i = 0; i < arr.length; i++) {
        total += arr[i];
    }
    return total
}

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

                            【讨论】：

                            • 这段代码在其他场景下不起作用（数组长度）。
                            • 你想表达什么？我不明白！
                            • 试试 getTotal([1, 2, 3, 4, 5]) 你就会明白我的意思了
                            • 我添加了一个应该解决这个问题的编辑
                            • 您可以对代码进行小幅编辑，以扩展更多号码。
                            【解决方案19】：

                            使用递归

                            var sum = (arr) => arr.length === 1 ? arr[0] : arr.shift() + sum(arr);
sum([1,2,3,4]) // 10

                            【讨论】：

                            • 无损版本：arr.length === 1 ? arr[0] : arr[0] + sum(arr.slice(1))
                            【解决方案20】：

                            此外，与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);

                            【讨论】：

                              【解决方案21】：

                              对于非常大的数字，循环或减少可能是过程密集型的。用高斯怎么样？

                              sum = (n * (n+1))/2;

                              来自mathcentral。

                              【讨论】：

                              • 这仅适用于从 1 开始的顺序数组，步长为 1。当然，OPs 问题包括一个可能令人困惑的示例，因为 [1, 2, 3, 4] 符合要求.但是如果我们想总结这个：[1, 7, 21, 10009, 300198] 呢？
                              【解决方案22】： 
                                  <!DOCTYPE html>
    <html>
    <body>

      <p>Click the button to join two arrays.</p>
      <button onclick="myFunction()">Try it</button>
      <p id="demo"></p>
    <script>
var hege = [1, 2,4,6,7,8,8];
var stale = [1, 2,4,5];
function myFunction() {
    console.log((hege.length > stale.length))    
    var children  = (hege.length > stale.length)? abc1() :abc2();       document.getElementById("demo").innerHTML = children;
}
function abc1(){
    console.log(hege,"Abc1")    
    var abcd=hege.map(function (num, idx) {
        console.log(hege.length , idx)
        return stale.length>idx?num + stale[idx]:num;
    })
    return abcd;
}

function abc2(){

    console.log(hege,"Abc2",stale)    
    var abcd=stale.map(function (num, idx) {
        console.log(hege.length , idx)
        return hege.length>idx?num + hege[idx]:num;
    })
    return abcd;
}
</script>

</body>
</html>

                              【讨论】：

                              • 只是粘贴代码没有帮助，请尝试解释您的解决方案。
                              【解决方案23】：

                              使用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();

                              【讨论】：

                              • 那是因为在这种情况下使用 map 是错误。将 maps 数组元素映射到某处，如果您想发挥作用，您正在寻找的是 reduce
                              • 谁说过要实用？或者您是指实用意义上的功能性？
                              • 在这种情况下，应使用 forEach 而不是 map。
                              • 在我看来，扩展内置对象的原型是不好的。为这些方法或其他方法使用单独的实用程序类。
                              • 您不正确地使用map()。它应该用于从现有数组生成一个新数组......这正是它在这种情况下所做的。它正在实例化并返回一个完全不必要的数组，其中填充了undefined。最重要的是，您已经用另一个可枚举的属性污染了Array.prototype。数组方法map、forEach、filter、reduce、some 等都是根据特定目的构建的。虽然这可能“起作用”，但它的效率低得离谱，因为它正在做不必要的工作......因为你选择了不合适的方法。
                              猜你喜欢
                              • 2017-05-15
                              • 1970-01-01
                              • 1970-01-01
                              • 1970-01-01
                              • 1970-01-01
                              • 2019-02-01
                              • 1970-01-01
                              • 1970-01-01
                              相关资源
                              最近更新 更多
                              热门标签
                              Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode