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

Ответ 1

Рекомендованный (уменьшить значение по умолчанию)

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

console.log(
  [1, 2, 3, 4].reduce((a, b) => a + b, 0)
)
console.log(
  [].reduce((a, b) => a + b, 0)
)

Ответ 2

В 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

Ответ 3

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

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

Ответ 4

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

Ответ 5

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

Ответ 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;
}

Ответ 7

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

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

Ответ 8

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

Ссылка: Array.prototype.reduce()

Ответ 9

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

Это займет в среднем 1,57 мс/прогон (измерено более 1000 прогонов в массиве из 100 случайных нормальных чисел) по сравнению с 3,604 мс/запустит с помощью метода eval() выше и 2.151 мс/запустит со стандартом для ( i, length, ++).

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

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

РЕДАКТИРОВАТЬ: Священный казнь, не обращайте внимания на весь этот пост. Использовать метод reduce(), упомянутый выше, всего 1 мс/запуск.

Ответ 10

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

Ответ 11

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

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

Давайте начнем искать много разных способов сделать это, так как я не смог найти здесь исчерпывающего ответа:

1) Использование встроенного метода limit()

function total(arr) {
  if(!Array.isArray(arr)) return;
  return arr.reduce((a, v)=>a + v);
}

2) Использование для цикла

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

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

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

Ответ 13

Смешной подход:

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

Ответ 14

Стандартное решение для 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). Надеюсь, в этом решении нет скрытого недостатка.

Ответ 15

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

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

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

Ответ 16

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

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

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

Я только наполовину шучу.

Ответ 17

Короткая часть кода 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

Несколько человек предложили добавить .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.

Ответ 19

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

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

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

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

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

Ответ 20

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

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

Ответ 21

Используйте reduce

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

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

console.log(sum);

Ответ 22

Не нужно initial value! Поскольку, если no initial value передано, 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

Ответ 23

Используйте цикл 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

Ответ 24

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

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

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

Ответ 25

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

Ответ 26

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

Это намного проще

function sumArray(arr) {
    var total = 0;
    arr.forEach(function(element){
        total += element;
    })
    return total;
}

var sum = sumArray([1,2,3,4])

console.log(sum)

Ответ 28

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

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

Ответ 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

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

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