Como encontrar a soma de uma matriz de números

Porque não reduzir? Normalmente é um pouco contra intuitivo, mas usá-lo para encontrar uma soma é bastante simples:

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

Recomendado (reduzir com o valor por omissão)

Matriz.prototipo.reduzir pode ser usado para iterar através da matriz, adicionando o valor do elemento actual à soma dos valores dos elementos anteriores.

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

Sem valor por omissão

console.log(
  [].reduce((a, b) => a + b)
)

Antes das funções arrow do ES6

console.log(
  [1,2,3].reduce(function(acc, val) { return acc + val; }, 0)
)

console.log(
  [].reduce(function(acc, val) { return acc + val; }, 0)
)

Não-Número inputs

Se não-números são possíveis entradas, você pode querer lidar com isso?

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

Não recomendado perigoso uso eval

Podemos usar eval para executar uma representação de texto do código JavaScript. Usando a matriz.prototipo.juntar a função para converter o array para uma string, nós mudamos [1,2,3] em "1+2+3" , que avalia a 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('+'))

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

Isto é possível através de looping sobre todos os itens, e adicionando-os em cada iteração a uma sum - variável.

var array = [1, 2, 3];

for (var i = 0, sum = 0; i < array.length; sum += array[i++]);

O JavaScript não sabe escopar em bloco, por isso sum será acessível:

console.log(sum); // => 6

O mesmo que acima, mas anotado e preparado como uma função simples:

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

Referência: Matriz.prototipo.Reduzir()

Se por acaso estiver a utilizar Lodash pode utilizar a função 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];

Isto irá demorar, em média, 1, 57 ms/run (medido em mais de 1000 corridas num conjunto de 100 números normais aleatórios), em comparação com 3,604 ms/run com o método eval() acima e 2, 151 ms / run com um padrão para o laço(i, comprimento,++).

Editar: --i em vez de i-- grava 0, 12 ms cada execução (I-- is 1, 7)

Edite: Holy expletive, esqueça. todo este post. Use o método de redução() mencionado acima, é apenas 1 ms / execução.

Também pode utilizar reduceRight.

[1,2,3,4,5,6].reduceRight(function(a,b){return a+b;})

Que resulta em 21.

Referência: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight

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

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

Uma solução padrão de 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 */

Isto funciona para mim (o resultado deve ser 5). Espero que não haja uma desvantagem oculta neste tipo de solução.

Eu sou um iniciante com JavaScript e codificação em geral, mas eu descobri que uma maneira simples e fácil de somar os números em um array é assim:

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

Basicamente, eu queria contribuir com isso porque eu não vi muitas soluções que não usam funções construídas, e este método é fácil de escrever e entender.

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

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

Um pequeno pedaço de código JavaScript faria este trabalho:

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)

Algumas pessoas sugeriram adicionar um método .sum() Ao Array.prototype. Isto é geralmente considerado uma má prática, por isso não estou a sugerir que o faças.

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

Então: [1,2].sum(); // 3

Note que a função adicionada ao protótipo está usando uma mistura de função ES5 e ES6 e sintaxe de seta. O function é declarado para permitir que o método para obter o contexto this do Array que você é a operar. Eu usei o => para brevidade dentro da chamada reduce.

Uso reduce

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

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

console.log(sum);

Aqui está uma elegante solução de linha única que usa algoritmo de pilha, embora se possa levar algum tempo para entender a beleza desta implementação.

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

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

Basicamente, a função aceita um array e verifica se o array contém exatamente um item. Se for falso, extrai o último item da pilha e devolve a lista actualizada.

A beleza deste excerto é que a função inclui arr[0] Verificar para evitar looping infinito. Uma vez que atinge o último item, devolve a soma inteira.

OK, imagine que você tem este array abaixo:

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

1) usar a redução incorporada()

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

2) Usar para o ciclo

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) Usar o ciclo de While

function total(arr) {
  if(!Array.isArray(arr)) return;
  let totalNumber = 0, i=-1;
  while (++i < arr.length) {
     totalNumber+=arr[i];
  }
  return totalNumber;
}

4) Usar o 'array forEach'

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

total(arr); //return 10

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

Sem cachar o comprimento do array que o compilador JS precisa para passar pelo array com cada iteração do loop para calcular o comprimento, é desnecessário overhead na maioria dos casos. V8 e um monte de navegadores modernos otimizar isso para nós, por isso é menos preocupante do que era, mas há dispositivos mais antigos que se beneficiam com este simples cache.

Se o comprimento está sujeito a alteração, cache pode causar alguns efeitos secundários inesperados se você não sabe por que você está cache o comprimento, mas para uma função reutilizável que o único propósito é pegar um array e adicionar os valores juntos é um grande ajuste.

Essas são realmente grandes respostas, mas apenas no caso de os números estarem em sequência como na pergunta (1,2,3,4) você pode facilmente fazer isso aplicando a fórmula (n*(n+1))/2 em que n é o último número

Isto é muito mais fácil

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)

Pode combinar o método reduce () com a expressão lambda:

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

> 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

[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

Esta função pode resumir todos os números -

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