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

Як дано масив [1, 2, 3, 4], як я можу знайти суму його елементів? (У цьому випадку сума була б 10.)

Я думав, що $.eachможе бути корисним, але я не знаю, як це здійснити.

Рекомендовано (зменшити за замовчуванням)

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

Ми можемо використовувати 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('+'))

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

У Ліспі це саме та робота 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

Чому б не зменшити? Зазвичай це трохи інтуїтивно зрозуміло, але використовувати його для пошуку суми досить просто:

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

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

Якщо ви використовуєте Lodash, ви можете скористатися функцією суму

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

Це можливо, перебираючи всі елементи та додаючи їх на кожній ітерації до 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;
});

Довідка: Array.prototype.reduce ()

// 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, довжина, ++ ) петля.

Методологічне зауваження: цей тест проводився на сервері сценаріїв Google Apps, тому їх двигуни javascript майже такі ж, як у Chrome.

EDIT: --iзамість i--економії 0,12 мс на кожному пробігу (i-- становить 1,7)

РЕДАКТ: Святий прихильник, не майте уваги на весь цей пост. Використовуйте вказаний вище метод redu (), це лише 1 мс / пробіг.

Ви також можете використовувати ReduRight.

[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("+"))

Гаразд, уявіть, що у вас є цей масив нижче:

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

Почнемо розглядати багато різних способів зробити це, оскільки я не зміг знайти тут всебічної відповіді:

1) Використання вбудованого скорочення ()

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 ...

Стандартне рішення 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). Я сподіваюся, що в такому рішенні немає прихованих недоліків.

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

Таким чином ви можете помістити в масив усілякі екзотичні речі.

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

Я лише наполовину жартую.

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

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

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

Короткий фрагмент коду 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 та синтаксис стрілок. functionОголошується , щоб метод , щоб отримати thisконтекст від Arrayякий ви працюєте на. Я використовував =>для стислості всередині reduceдзвінка.

Використовуйте 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

Не потрібно initial value! Оскільки, якщо не 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

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

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

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

В основному, функція приймає масив і перевіряє, чи містить масив саме один елемент. Якщо помилково, він виводить останній елемент із стека та повертає оновлений масив.

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

Ви можете поєднати метод Redu () з лямбда-виразом:

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

Використовуйте reduce

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

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

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)

Точність

Сортувати масив і почати суму найменших чисел (фрагмент показує різницю з несортовим)

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

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]

Для багатовимірного масиву чисел використовують 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

Прикольні трюки тут, у мене є вибір нитки з безліччю безпечних традиційних відповідей, не кешуючи довжину масиву.

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 - останнє число

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 sumArray(arr) {
    var total = 0;
    arr.forEach(function(element){
        total += element;
    })
    return total;
}

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

console.log(sum)

Простий приклад методу:

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