Como encontrar a soma de uma matriz de números

Dada uma matriz [1, 2, 3, 4], como posso encontrar a soma de seus elementos? (Nesse caso, a soma seria 10.)

Eu pensei que $.eachpoderia ser útil, mas não tenho certeza de como implementá-lo.

Recomendado (reduzir com valor padrão)

Array.prototype.reduce pode ser usado para iterar pela matriz, adicionando o valor atual do elemento à soma dos valores anteriores.

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

Sem valor padrão

Você recebe um TypeError

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

Antes das funções de seta 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)
)

Entradas não numéricas

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

Uso de avaliação perigoso não recomendado

Podemos usar eval para executar uma representação em string do código JavaScript. Usando a função Array.prototype.join para converter a matriz em uma string, alteramos [1,2,3] para "1 + 2 + 3", que é avaliado em 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('+'))

É claro que exibir um alerta não é a pior coisa que poderia acontecer. A única razão pela qual incluí isso é como resposta à pergunta de Ortund, pois não acho que tenha sido esclarecida.

No Lisp , esse seria exatamente o trabalho reduce. Você veria esse tipo de código:

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

Felizmente, em JavaScript, também temos reduce! Infelizmente, +é um operador, não uma função. Mas podemos torná-lo bonito! Olhe aqui:

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

Isso não é bonito? :-)

Melhor ainda! Se você estiver usando o ECMAScript 2015 (também conhecido como ECMAScript 6 ), pode ser assim:

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

Por que não reduzir? Geralmente é um pouco contra-intuitivo, mas usá-lo para encontrar uma soma é bem direto:

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

Se você estiver usando o Lodash, poderá usar a função soma

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

Isso é possível repetindo todos os itens e adicionando-os em cada iteração a uma sumvariável.

var array = [1, 2, 3];

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

O JavaScript não sabe o escopo do bloco, por isso sumserá acessível:

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

O mesmo que acima, porém 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: Array.prototype.reduce ()

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

Isso levará em média 1,57 ms / corrida (medido em 1000 execuções em uma matriz de 100 números normais aleatórios), comparado a 3.604 ms / corrida com o eval()método acima e 2.151 ms / corrida com um padrão para (i, comprimento, ++ ) ciclo.

Observação sobre a metodologia: esse teste foi executado em um servidor de scripts do Google Apps, portanto, seus mecanismos javascript são praticamente os mesmos do Chrome.

EDIT: em --ivez de i--economiza 0,12 ms cada execução (i-- é 1,7)

Edição: Santo palavrão, não importa todo este post. Use o método reduzir () mencionado acima, é apenas 1 ms / corrida.

Você também pode usar o reduzaRight.

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

que resulta como 21.

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

Alguém está procurando um oneliner funcional como eu? Pegue isso:

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

OK, imagine que você tenha esta matriz abaixo:

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

Vamos começar a procurar várias maneiras diferentes de fazer isso, pois não encontrei nenhuma resposta abrangente aqui:

1) Usando redução interna ()

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

2) Usando o loop for

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) Usando o loop while

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

4) Usando a matriz forEach

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

e chame assim:

total(arr); //return 10

Não é recomendável prototipar algo assim para o Array ...

Abordagem engraçada:

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

Uma solução JavaScript padrão:

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 */

Isso funciona para mim (o resultado deve ser 5). Espero que não exista desvantagem oculta nesse tipo de solução.

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

Dessa forma, você pode colocar todos os tipos de coisas exóticas na matriz.

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

Estou apenas brincando.

Sou iniciante em JavaScript e codificação em geral, mas descobri que uma maneira simples e fácil de somar os números em uma matriz é assim:

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

Basicamente, eu queria contribuir com isso porque não encontrei muitas soluções que não usem funções internas, e esse método é fácil de escrever e entender.

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 .sum()método ao Array.prototype. Isso geralmente é considerado uma prática ruim, então não estou sugerindo que você faça isso.

Se você ainda insistir em fazê-lo, esta é uma maneira sucinta de escrevê-lo:

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

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

Observe que a função adicionada ao protótipo está usando uma mistura da função ES5 e ES6 e sintaxe da seta. O functioné declarado para permitir que o método obtenha o thiscontexto a partir do Arrayqual você está operando. Eu usei a =>brevidade dentro da reduceligação.

Use um forloop:

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

Ou até um forEachloop:

const array = [1, 2, 3, 4];
let result = 0;

array.forEach(number => {
  result += number;
})

console.log(result); // Should give 10

Para simplificar, use reduce:

const array = [10, 20, 30, 40];
const add = (a, b) => a + b
const result = array.reduce(add);

console.log(result); // Should give 100

Não precisa initial value! Porque se não initial valuefor passado, ele callback functionnão será chamado no primeiro elemento da lista e o primeiro elemento será passado como o initial value. Very c OO l feature :)

[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

Aqui está uma solução elegante de uma linha que usa o algoritmo de pilha , embora possa levar algum tempo para entender a beleza dessa 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 uma matriz e verifica se a matriz contém exatamente um item. Se falso, ele remove o último item da pilha e retorna a matriz atualizada.

A beleza desse snippet é que a função inclui a arr[0]verificação para evitar loop infinito. Quando atinge o último item, ele retorna a soma inteira.

Você pode combinar o método reduzem () com a expressão lambda:

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

Usar reduce

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

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

console.log(sum);

eu vi todas as respostas indo para a solução 'reduzir'

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

Precisão

Classifique a matriz e inicie a soma dos menores números (o snippet mostra a diferença com a não classificação)

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

Para matriz multidimensional de números, use 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

Truques legais aqui, eu tenho uma escolha nítida com muitas das respostas tradicionais seguras que não armazenam em cache o comprimento da matriz.

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 armazenar em cache o comprimento da matriz, o compilador JS precisa percorrer a matriz com todas as iterações do loop para calcular o comprimento; na maioria dos casos, é uma sobrecarga desnecessária. A V8 e muitos navegadores modernos otimizam isso para nós, por isso é menos preocupante do que era, mas existem dispositivos mais antigos que se beneficiam desse cache simples.

Se o comprimento estiver sujeito a alterações, o armazenamento em cache poderá causar efeitos colaterais inesperados, se você não souber por que está armazenando o tamanho em cache, mas para uma função reutilizável cujo único objetivo é pegar uma matriz e adicionar os valores juntos, é um ótimo ajuste.

Aqui está um link CodePen para esta função arraySum. http://codepen.io/brandonbrule/pen/ZGEJyV

É possível que essa seja uma mentalidade desatualizada que esteja presa a mim, mas não vejo uma desvantagem em usá-la nesse contexto.

Essas são realmente ótimas respostas, mas, se os números estiverem em sequência, como na pergunta (1,2,3,4), você poderá fazer isso facilmente aplicando a fórmula (n * (n + 1)) / 2 em que n é o último número

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

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

Um exemplo simples de método:

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