javascript - objetos - Cómo encontrar la suma de una matriz de números.

suma de n numeros en javascript

Question

Dada una matriz [1, 2, 3, 4] , ¿cómo puedo encontrar la suma de sus elementos? (En este caso, la suma sería 10 ).

Pensé que $.each podría ser útil, pero no estoy seguro de cómo implementarlo.

Answer 1

Recomendado (reducir con valor predeterminado)

Array.prototype.reduce se puede usar para iterar a través de la matriz, agregando el valor del elemento actual a la suma de los valores del elemento anterior.

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

Sin valor por defecto

Obtienes un TypeError

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

Antes de las funciones de flecha de 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 no numeradas

Si los no números son entradas posibles, ¿podría querer manejar eso?

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 evaluación peligroso no recomendado

Podemos usar eval para ejecutar una representación de cadena de código JavaScript. Usando la función Array.prototype.join para convertir la matriz en una cadena, cambiamos [1,2,3] a "1 + 2 + 3", que se evalúa 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(''+''))

Por supuesto, mostrar una alerta no es lo peor que podría pasar. La única razón por la que he incluido esto es como respuesta a la pregunta de Ortund, ya que no creo que se haya aclarado.

Answer 2

¿Alguien en busca de un oneliner funcional como yo? Toma esto:

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

Answer 3

¿Por qué no reducir? Generalmente es un poco contrario a la intuición, pero usarlo para encontrar una suma es bastante sencillo:

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

Answer 4

Algunas personas han sugerido agregar un método .sum() al Array.prototype . Esto generalmente se considera una mala práctica, así que no estoy sugiriendo que lo hagas.

Si aún insistes en hacerlo, esta es una forma sucinta de escribirlo:

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

entonces: [1,2].sum(); // 3 [1,2].sum(); // 3

Tenga en cuenta que la función agregada al prototipo está utilizando una mezcla de la función ES5 y ES6 y la sintaxis de flecha. La function está declarada para permitir que el método obtenga this contexto de la Array que está operando. Utilicé el => por brevedad dentro de la llamada reduce .

Answer 5

Aquí hay trucos geniales, tengo una selección de liendres con muchas de las respuestas tradicionales seguras que no almacenan en caché la longitud de la 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 ) );

Sin almacenar en caché la longitud de la matriz, el compilador JS necesita pasar por la matriz con cada iteración del bucle para calcular la longitud, es una sobrecarga innecesaria en la mayoría de los casos. V8 y muchos navegadores modernos optimizan esto para nosotros, por lo que es una preocupación menor de lo que era, pero hay dispositivos más antiguos que se benefician de este simple almacenamiento en caché.

Si la duración está sujeta a cambios, el almacenamiento en caché puede causar algunos efectos secundarios inesperados si no sabe por qué está almacenando en caché la longitud, pero para una función reutilizable cuyo único propósito es tomar una matriz y sumar los valores, es un gran ajuste

Aquí hay un enlace de CodePen para esta función arraySum. http://codepen.io/brandonbrule/pen/ZGEJyV

Es posible que esta sea una mentalidad obsoleta que se me quede grabada, pero no veo una desventaja en su uso en este contexto.

Answer 6

Aquí hay una solución elegante de una sola línea que utiliza el algoritmo de pila , aunque uno puede tomar algún tiempo para comprender la belleza de esta implementación.

const getSum = arr => (arr.length === 1) ? arr[0] : arr.pop() + getSum(arr);
getSum([1, 2, 3, 4, 5]) //15

Básicamente, la función acepta una matriz y verifica si la matriz contiene exactamente un elemento. Si es falso, saca el último elemento de la pila y devuelve la matriz actualizada.

La belleza de este fragmento de código es que la función incluye arr[0] para evitar el bucle infinito. Una vez que llega al último artículo, devuelve la suma completa.

Answer 7

En Lisp , este sería exactamente el trabajo para reduce . Verías este tipo de código:

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

Afortunadamente, en JavaScript, también tenemos reduce ! Desafortunadamente, + es un operador, no una función. ¡Pero podemos hacerlo bonito! Aquí, mira:

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

¿No es eso bonito? :-)

¡Aun mejor! Si estás usando ECMAScript 2015 (también conocido como ECMAScript 6 ), puede ser así:

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

Answer 8

Enfoque divertido:

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

Answer 9

Esas son respuestas realmente geniales, pero en caso de que los números estén en secuencia como en la pregunta (1,2,3,4), puede hacerlo fácilmente aplicando la fórmula (n * (n + 1)) / 2 donde n es el último número

Answer 10

Esta función puede resumir todos los 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])

Answer 11

Esto es mucho mas facil

function sumArray(arr) {
var total = 0;
arr.forEach(function(element){
total += element;
})
return total;
}
var sum = sumArray([1,2,3,4])
console.log(sum)

Answer 12

Esto es posible haciendo un bucle sobre todos los elementos y agregándolos en cada iteración a una variable -variable.

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

JavaScript no sabe el alcance del bloque, por lo que la sum será accesible:

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

Lo mismo que arriba, sin embargo anotado y preparado como una función simple:

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

Answer 13

No hay necesidad de initial value ! Porque si no se pasa ningún initial value , la callback function no se invoca en el primer elemento de la lista, y el primer elemento se pasa como initial value . Muy c OO l caracterí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

Answer 14

OK, imagina que tienes esta matriz a continuación:

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

Comencemos a buscar diferentes maneras de hacerlo ya que no pude encontrar una respuesta completa aquí:

1) Utilizando reducir ()

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

2) Usando para bucle

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 while loop

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

4) Usando array para cada

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

y llámalo así:

total(arr); //return 10

No se recomienda hacer un prototipo de algo así para Array ...

Answer 15

Puedes combinar el método reduce () con la expresión lambda:

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

Answer 16

Si estás usando Lodash puedes usar la función de sum

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

Answer 17

Soy un principiante con JavaScript y codificación en general, pero encontré que una manera simple y fácil de sumar los números en una matriz es la siguiente:

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

Básicamente, quería contribuir con esto porque no veía muchas soluciones que no usan funciones integradas, y este método es fácil de escribir y entender.

Answer 18

También puedes usar reduceRight.

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

que resulta de salida como 21.

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

Answer 19

Un pequeño fragmento de código JavaScript haría este trabajo:

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)

Answer 20

Una solución estándar 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 */

Esto funciona para mí (el resultado debe ser 5). Espero que no haya una desventaja oculta en este tipo de solución.

Answer 21

Usar reduce

let arr = [1, 2, 3, 4];
let sum = arr.reduce((v, i) => (v + i));
console.log(sum);

Answer 22

Vanilla JavaScript es todo lo que necesitas:

> 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

Answer 23

Vi todas las respuestas en busca de una solución ''reducida''

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

Answer 24

prueba esto...

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

Answer 25

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

Esto tomará un promedio de 1.57 ms / ejecución (medido en 1000 ejecuciones en una matriz de 100 números aleatorios normales), en comparación con 3.604 ms / corrida con el método eval() anterior y 2.151 ms / corrida con un estándar para (i, longitud , ++) bucle.

Nota sobre la metodología: esta prueba se ejecutó en un servidor de Google Apps Script, por lo que sus motores de javascript son casi iguales a Chrome.

EDITAR: --i lugar de i-- guarda 0.12 ms en cada ejecución (i-- es 1.7)

EDITAR: Holy expletivo, no importa este post completo. Utilice el método reduce () mencionado anteriormente, solo es 1 ms / ejecutar.

Answer 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

Answer 27

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

Referencia: Array.prototype.reduce

Answer 28

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

Answer 29

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

Answer 30

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

De esa manera puedes poner todo tipo de cosas exóticas en la matriz.

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

Sólo estoy bromeando a medias.