Como encontrar a soma de uma matriz de números
dado um array {[[0]}, Como posso encontrar a soma dos seus elementos? (Neste caso, a soma seria 10
.)
$.each
pode ser útil, mas não sei como implementá-lo.
30 answers
Em Lisp, este seria exactamente o trabalho para reduce
. Você veria este 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! Aqui, olha.
var sum = [1, 2, 3].reduce(add, 0);
function add(a, b) {
return a + b;
}
console.log(sum); // 6
Não é bonito? :-)
Ainda melhor! Se estiver a utilizar o ECMAScript 2015( também conhecido por ECMAScript 6 ), pode ser este bonito:
var sum = [1, 2, 3].reduce((a, b) => a + b, 0);
console.log(sum); // 6
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
Tens um erro tipográfico.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('+'))
Assim podes colocar todo o tipo de coisas exóticas na matriz.
var arr = ['(1/3)','Date.now()','foo','bar()',1,2,3,4]
Só estou a brincar.
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];
Vamos começar a procurar muitas maneiras diferentes de o fazer, pois não encontrei nenhuma resposta completa aqui.
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;
};
E chama-lhe assim:
total(arr); //return 10
Não é recomendado fazer um protótipo deste tipo...
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.
Aqui está uma ligação de CodePen para esta função arraySum. http://codepen.io/brandonbrule/pen/ZGEJyV É possível que seja uma mentalidade ultrapassada que está presa a mim, mas não vejo uma desvantagem. a usá-lo neste contexto.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
initial value
é passado, o callback function
não é invocado no primeiro elemento da lista, e o primeiro elemento é passado como o initial value
. Muito cOOcaracterística:)
[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])