Как найти сумму массива чисел

дан массив [1, 2, 3, 4], Как я могу найти сумму его элементов? (В этом случае сумма будет 10.)

Я думал $.each может быть полезно, но я не уверен, как это реализовать.

30 ответов


на Лисп, это была бы точно работа для reduce. Вы увидите такой код:

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

К счастью, в JavaScript у нас также есть reduce! К сожалению, + является оператором, а не функцией. Но мы можем сделать его красивым! Вот, смотри:

var sum = [1, 2, 3].reduce(add, 0);

function add(a, b) {
    return a + b;
}

console.log(sum); // 6

разве это не красиво? :-)

еще лучше! Если вы используете ECMAScript 2015 (он же ECMAScript 6), это может быть довольно:

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

почему бы не уменьшить? Обычно это немного интуитивно понятный счетчик, но использовать его для поиска суммы довольно просто:

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

рекомендуется (уменьшить значение по умолчанию)

массив.прототип.уменьшить можно использовать для итерации по массиву, добавляя текущее значение элемента к сумме предыдущих значений элементов.

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. Использование массива.прототип.функция 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, поскольку я не думаю, что он был разъяснен.


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

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

это возможно путем зацикливания всех элементов и добавления их на каждой итерации в 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;
}

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

ссылки: массив.прототип.reduce ()


Если вы используете Lodash, вы можете использовать sum функции

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

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

это займет в среднем 1.57 ms / run (измеряется более 1000 запусков на массиве из 100 случайных нормальных чисел), по сравнению с 3.604 ms/run с eval() метод выше и 2.151 ms / run со стандартным циклом for(i,length,++).

методология Примечание: этот тест был запущен на сервере сценариев Google Apps, поэтому их движки javascript в значительной степени такие же, как Chrome.

EDIT:--i вместо i-- сохраняет 0.12 ms каждый запуск (i-- is 1.7)

изменить: Святое ругательство, не обращай внимания на весь этот пост. используйте метод reduce (), упомянутый выше, это только 1 ms/run.


вы также можете использовать 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


кто-нибудь ищет функциональный oneliner, как я? Возьмите это:

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

забавный подход:

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

стандартное решение 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). Я надеюсь, что в таком решении нет скрытых недостатков.


Я новичок в JavaScript и кодировании в целом, но я обнаружил, что простой и легкий способ суммировать числа в массиве выглядит так:

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

в основном, я хотел внести свой вклад, потому что я не видел много решений, которые не используют встроенные функции, и этот метод легко написать и понять.


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

таким образом, вы можете поместить все виды экзотических вещей в массив.

var arr = ['(1/3)','Date.now()','foo','bar()',1,2,3,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)

несколько человек предложили добавить .sum() метод Array.prototype. Это обычно считается плохой практикой, поэтому я не предлагаю вам это делать.

если вы все еще настаиваете на этом, то это краткий способ написать его:

Array.prototype.sum = function() {return [].reduce.call(this, (a,i) => a+i, 0);}

затем: [1,2].sum(); // 3

обратите внимание, что функция, добавленная в прототип, использует смесь функций ES5 и ES6 и синтаксиса стрелки. The function объявлено, чтобы позволить методу получить this связи с the Array что вы оперируете. Я использовал => для краткости внутри reduce звонок.


использовать reduce

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

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

console.log(sum);

вот элегантное однострочное решение, которое использует алгоритм стека, хотя может занять некоторое время, чтобы понять красоту этой реализации.

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

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

в принципе, функция принимает массив и проверяет, содержит ли массив ровно один элемент. Если false, он вытащит последний элемент из стека и вернет обновленный массив.

красота этого фрагмента заключается в том, что функция включает arr[0] проверка для предотвращения бесконечного цикла. Однажды доходит до последнего пункта, возвращает всю сумму.


хорошо, представьте, что у вас есть этот массив ниже:

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 loop

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 loop

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

не рекомендуется прототипировать что-то вроде этого для массива...


классные трюки здесь, у меня есть выбор nit с большим количеством безопасных традиционных ответов, не кэширующих длину массива.

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 и многие современные браузеры оптимизируют это для нас, поэтому это меньше беспокоит, но есть более старые устройства, которые выигрывают от этого простого кэширование.

Если длина может быть изменена, кэширование может вызвать некоторые неожиданные побочные эффекты, если вы не знаете, почему вы кэшируете длину, но для многоразовой функции, единственной целью которой является взять массив и добавить значения вместе, это отличная подгонка.

вот ссылка CodePen для этой функции arraySum. http://codepen.io/brandonbrule/pen/ZGEJyV

возможно, это устаревшее мышление, которое застряло со мной, но я не вижу недостатков в этом контексте.


Это действительно отличные ответы, но на всякий случай, если числа находятся в последовательности, как в вопросе (1,2,3,4) , вы можете легко сделать это, применив формулу (n*(n+1))/2, где n-последнее число


Это гораздо проще!--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)

Я видел, что все ответы идут на решение "уменьшить"

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

вы можете объединить метод reduce () с лямбда-выражением:

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

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

попробуйте это...

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

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

не нужно initial value! Потому что если нет initial value, то callback function не вызывается на первом элементе списка, и первый элемент вместо этого передается как initial value. Очень cООфункция л :)

[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

эта функция может суммировать все цифры -

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