Comment trouver la somme d'un tableau de nombres
Étant donné un tableau _[1, 2, 3, 4]_, comment puis-je trouver la somme de ses éléments? (Dans ce cas, la somme serait _10_.)
Je pensais que $.each pourrait être utile, mais je ne sais pas comment le mettre en œuvre.
Recommandé (réduire avec la valeur par défaut)
Array.prototype.reduce peut être utilisé pour parcourir le tableau, en ajoutant la valeur de l'élément en cours à la somme des valeurs des éléments précédents.
console.log(
[1, 2, 3, 4].reduce((a, b) => a + b, 0)
)
console.log(
[].reduce((a, b) => a + b, 0)
)Sans valeur par défaut
Vous obtenez un TypeError
console.log(
[].reduce((a, b) => a + b)
)Avant les fonctions fléchées de l'ES6
console.log(
[1,2,3].reduce(function(acc, val) { return acc + val; }, 0)
)
console.log(
[].reduce(function(acc, val) { return acc + val; }, 0)
)Entrées non numériques
Si les entrées non numériques sont des entrées possibles, vous voudrez peut-être gérer cela?
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))
)Utilisation non recommandée dangereuse
Nous pouvons utiliser eval pour exécuter une représentation sous forme de chaîne de code JavaScript. En utilisant la fonction Array.prototype.join pour convertir le tableau en chaîne, nous changeons [1,2,3] en "1 + 2 + 3", ce qui donne 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('+'))Bien sûr, l'affichage d'une alerte n'est pas la pire chose qui puisse arriver. La seule raison pour laquelle j'ai inclus ceci est une réponse à la question d'Ortund car je ne pense pas qu'elle ait été clarifiée.
Dans LISP , ce serait exactement le travail pour reduce. Vous verriez ce genre de code:
(reduce #'+ '(1 2 3)) ; 6
Heureusement, en JavaScript, nous avons aussi reduce ! Malheureusement, + est un opérateur, pas une fonction. Mais nous pouvons le rendre joli! Ici, regardez:
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
N'est-ce pas joli? :-)
Encore mieux! Si vous utilisez ECMAScript 2015 (ou ECMAScript 6 ), cela peut être joli:
const sum = [1, 2, 3].reduce((partial_sum, a) => partial_sum + a,0);
console.log(sum); // 6
Pourquoi ne pas réduire? C'est généralement un peu contre-intuitif, mais l'utiliser pour trouver une somme est assez simple:
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;
});
Cela est possible en passant en boucle sur tous les éléments et en les ajoutant à chaque itération à une variable sum-.
var array = [1, 2, 3];
for (var i = 0, sum = 0; i < array.length; sum += array[i++]);
JavaScript ne connaît pas la portée du bloc, donc sum sera accessible:
console.log(sum); // => 6
Les mêmes que ci-dessus, cependant annotés et préparés comme une simple fonction:
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;
}
Si vous utilisez Lodash, vous pouvez utiliser la fonction sum
array = [1, 2, 3, 4];
sum = _.sum(array); // sum == 10
arr.reduce(function (a, b) {
return a + b;
});
Référence: Array.prototype.reduce ()
// Given array 'arr'
var i = arr.length;
var sum = 0;
while (--i) sum += arr[i];
Cela prendra en moyenne 1,57 ms/exécution (mesurée sur 1 000 exécutions sur un tableau de 100 nombres normaux aléatoires), contre 3,604 ms/exécution avec la méthode eval() ci-dessus et 2,151 ms/exécution avec un standard pour (i , longueur, ++) boucle.
Remarque méthodologique: ce test a été exécuté sur un serveur de script Google Apps. Par conséquent, leurs moteurs javascript sont similaires à ceux de Chrome.
EDIT: --i au lieu de i-- enregistre 0,12 ms à chaque exécution (i-- vaut 1,7)
EDIT: Saint explétif, peu importe tout ce post. tilisez la méthode de réduction () mentionnée ci-dessus, c'est seulement 1 ms/run.
OK, imaginez que vous avez ce tableau ci-dessous:
const arr = [1, 2, 3, 4];
Commençons par regarder de nombreuses façons différentes de le faire car je ne trouvais pas de réponse complète ici:
1) Utilisation de la réduction intégrée ()
function total(arr) {
if(!Array.isArray(arr)) return;
return arr.reduce((a, v)=>a + v);
}
2) Utilisation de for loop
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;
}
) Utilisation de la boucle while
function total(arr) {
if(!Array.isArray(arr)) return;
let totalNumber = 0, i=-1;
while (++i < arr.length) {
totalNumber+=arr[i];
}
return totalNumber;
}
4) Utilisation du tableau pour chaque
function total(arr) {
if(!Array.isArray(arr)) return;
let sum=0;
arr.forEach(each => {
sum+=each;
});
return sum;
};
et appelez comme ça:
total(arr); //return 10
Il n'est pas recommandé de prototyper quelque chose comme ça pour Array ...
Vous pouvez également utiliser reductionRight.
[1,2,3,4,5,6].reduceRight(function(a,b){return a+b;})
ce qui donne un résultat de 21.
Référence: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
Quelqu'un cherche un oneliner fonctionnel comme moi? Prends ça:
sum= arr.reduce(function (a, b) {return a + b;}, 0);
Approche drôle:
eval([1,2,3].join("+"))
Une solution JavaScript standard:
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 */
Cela fonctionne pour moi (le résultat devrait être 5). J'espère qu'il n'y a pas de désavantage caché dans ce type de solution.
Je suis un débutant avec JavaScript et le codage en général, mais j’ai trouvé qu’un moyen simple et facile de faire la somme des nombres dans un tableau ressemblait à ceci:
var myNumbers = [1,2,3,4,5]
var total = 0;
for(var i = 0; i < myNumbers.length; i++){
total += myNumbers[i];
}
En gros, je voulais contribuer à cela car je n’avais pas vu beaucoup de solutions qui n’utilisaient pas de fonctions intégrées, et cette méthode est facile à écrire et à comprendre.
var totally = eval(arr.join('+'))
De cette façon, vous pouvez mettre toutes sortes de choses exotiques dans le tableau.
var arr = ['(1/3)','Date.now()','foo','bar()',1,2,3,4]
Je plaisante à moitié.
Quelques personnes ont suggéré d'ajouter une méthode .sum() au Array.prototype. Ceci est généralement considéré comme une mauvaise pratique, donc je ne suggère pas que vous le fassiez.
Si vous persistez à le faire, c’est une façon succincte de l’écrire:
Array.prototype.sum = function() {return [].reduce.call(this, (a,i) => a+i, 0);}
alors: [1,2].sum(); // 3
Notez que la fonction ajoutée au prototype utilise un mélange de syntaxe de fonction et de flèche ES5 et ES6. La variable function est déclarée pour permettre à la méthode d'obtenir le contexte this à partir de la variable Array sur laquelle vous travaillez. J'ai utilisé le => par souci de brièveté dans l'appel reduce.
Un petit morceau de code JavaScript ferait ce travail:
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)
Vous pouvez combiner la méthode reduction () avec une expression lambda:
[1, 2, 3, 4].reduce((accumulator, currentValue) => accumulator + currentValue);
Voici une solution élégante à une ligne qui utilise algorithme de pile , bien que l'on puisse prendre un certain temps pour comprendre la beauté de cette implémentation.
const getSum = arr => (arr.length === 1) ? arr[0] : arr.pop() + getSum(arr);
getSum([1, 2, 3, 4, 5]) //15
Fondamentalement, la fonction accepte un tableau et vérifie si le tableau contient exactement un élément. Si la valeur est false, le dernier élément extrait de la pile est extrait et le tableau mis à jour est renvoyé.
La beauté de cet extrait de code réside dans le fait que la fonction inclut la vérification de arr[0] pour empêcher les boucles infinies. Une fois le dernier élément atteint, il renvoie la somme entière.
Utilisez reduce
let arr = [1, 2, 3, 4];
let sum = arr.reduce((v, i) => (v + i));
console.log(sum);Pas besoin de initial value! Parce que si aucun initial value n'est transmis, le callback function n'est pas appelé sur le premier élément de la liste et le premier élément est plutôt transmis sous la forme initial value. Très c OO l caractéristique :)
[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
j'ai vu toutes les réponses pour la solution 'réduire'
var array = [1,2,3,4]
var total = 0
for (var i = 0; i < array.length; i++) {
total += array[i]
}
console.log(total)
Un exemple de méthode simple:
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]));
Trucs sympas ici, j'ai un choix judicieux avec beaucoup des réponses traditionnelles sûres qui ne cachent pas la longueur du tableau.
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 ) );
Sans mettre en cache la longueur du tableau, le compilateur JS doit parcourir le tableau à chaque itération de la boucle pour calculer la longueur. Dans la plupart des cas, cela représente un temps système inutile. La V8 et de nombreux navigateurs modernes optimisent cela pour nous, de sorte que le problème est moins préoccupant que par le passé, mais certains appareils plus anciens bénéficient de cette mise en cache simple.
Si la longueur est sujette à modification, la mise en cache risque d’avoir des effets secondaires inattendus si vous ne savez pas pourquoi vous mettez la longueur en cache, mais dans le cas d’une fonction réutilisable dont le seul but est de prendre un tableau et d’ajouter les valeurs, c’est un bon ajustement.
Voici un lien CodePen pour cette fonction arraySum. http://codepen.io/brandonbrule/pen/ZGEJyV
Il est possible qu'il s'agisse d'un état d'esprit dépassé qui me tient à coeur, mais je ne vois pas d'inconvénient à l'utiliser dans ce contexte.
C'est beaucoup plus facile
function sumArray(arr) {
var total = 0;
arr.forEach(function(element){
total += element;
})
return total;
}
var sum = sumArray([1,2,3,4])
console.log(sum)
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
Ce sont vraiment d'excellentes réponses, mais juste au cas où les nombres sont en séquence comme dans la question (1,2,3,4), vous pouvez facilement le faire en appliquant la formule (n * (n + 1))/2 où n est le dernier numéro
Vanilla JavaScript est tout ce dont vous avez besoin:
> 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
Cette fonction peut résumer tous les nombres -
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])
essaye ça...
function arrSum(arr){
total = 0;
arr.forEach(function(key){
total = total + key;
});
return total;
}
Avec paramètre de repos ES6
let array = [1, 2, 3, 4]
function sum(...numbers) {
let total = 0;
for (const number of numbers) {
total += number;
}
return total;
}
console.log(sum(...array));Une question "en double" demandait comment faire cela pour un tableau à deux dimensions, il s'agit donc d'une simple adaptation pour répondre à cette question. (La différence réside uniquement dans les six caractères [2], 0, qui trouve le troisième élément dans chaque sous-tableau et transmet une valeur initiale de zéro):
const twoDimensionalArray = [
[10, 10, 1],
[10, 10, 2],
[10, 10, 3],
];
const sum = twoDimensionalArray.reduce( (partial_sum, a) => partial_sum + a[2], 0 ) ;
console.log(sum); // 6Utilisez une boucle for:
function findSumOfElements(numbers) {
let sum = 0;
for (let i = 0; i < numbers.length - 1; i++) {
sum += numbers[i];
}
return sum;
}
Il suffit d'utiliser cette fonction:
function sum(pArray)
{
pArray = pArray.reduce(function (a, b) {
return a + b;
}, 0);
return pArray;
}
function sum(pArray)
{
pArray = pArray.reduce(function (a, b) {
return a + b;
}, 0);
return pArray;
}
var arr = [1, 4, 5];
console.log(sum(arr));