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

J'ai pensé que cela $.eachpourrait ê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 d'élément actuelle à la somme des valeurs d'élément précédentes.

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 une TypeError

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

Avant les fonctions fléchées d'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 des non-nombres 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 dangereuse de l' évaluateur non recommandée

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, afficher une alerte n'est pas la pire chose qui puisse arriver. La seule raison pour laquelle j'ai inclus ceci est comme une réponse à la question d'Ortund car je ne pense pas qu'elle ait été clarifiée.

À Lisp , ce serait exactement le travail pour reduce. Vous verriez ce type de code:

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

Heureusement, en JavaScript, nous en avons aussi reduce! Malheureusement, +c'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 (alias ECMAScript 6 ), cela peut être assez 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;
});

Si vous utilisez Lodash, vous pouvez utiliser la fonction somme

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

Cela est possible en bouclant sur tous les éléments et en les ajoutant à chaque itération à une sumvariable.

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 des blocs, il sumsera donc accessible:

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

Le même que ci-dessus, cependant annoté et préparé comme une fonction 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;
}

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 / run (mesuré sur 1000 runs sur un tableau de 100 nombres normaux aléatoires), contre 3,604 ms / run avec la eval()méthode ci-dessus et 2,151 ms / run avec un standard pour (i, length, ++ ) boucle.

Remarque sur la méthodologie: ce test a été exécuté sur un serveur de script Google Apps, de sorte que leurs moteurs javascript sont à peu près les mêmes que Chrome.

EDIT: --iau lieu d' i--enregistrer 0,12 ms à chaque exécution (i-- est 1,7)

EDIT: Holy expletive, peu importe tout ce post. Utilisez la méthode Reduce () mentionnée ci-dessus, c'est seulement 1 ms / run.

Vous pouvez également utiliser ReduceRight.

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

ce qui donne une sortie de 21.

Référence: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight

Quelqu'un à la recherche d'un oneliner fonctionnel comme moi? Prends ça:

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

OK, imaginez que vous avez ce tableau ci-dessous:

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

Commençons à chercher de nombreuses façons de le faire car je n'ai trouvé aucune 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 la boucle 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) 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 de array forEach

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

et appelez-le comme ceci:

total(arr); //return 10

Il n'est pas recommandé de prototyper quelque chose comme ça à Array ...

Approche amusante:

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 aucun inconvénient caché dans ce type de solution.

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 ne plaisante qu'à moitié.

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 additionner les nombres dans un tableau est comme ceci:

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

Fondamentalement, je voulais y contribuer car je n'ai pas vu beaucoup de solutions qui n'utilisent pas de fonctions intégrées, et cette méthode est facile à écrire et à comprendre.

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

Quelques personnes ont suggéré d'ajouter une .sum()méthode 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 insistez toujours pour le faire, voici une façon succincte de l'écrire:

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

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

Notez que la fonction ajoutée au prototype utilise un mélange de fonctions ES5 et ES6 et de syntaxe de flèche. Le functionest déclaré pour permettre à la méthode d'extraire le thiscontexte de celui sur Arraylequel vous travaillez. J'ai utilisé =>pour plus de concision dans l' reduceappel.

Utilisez une forboucle:

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 même une forEachboucle:

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

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

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

Pour plus de simplicité, utilisez reduce:

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

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

Pas besoin initial value! Parce que si non initial valueest passé, le callback functionn'est pas invoqué sur le premier élément de la liste, et le premier élément est plutôt passé en tant que initial value. Très c OO l fonctionnalité :)

[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

Voici une élégante solution à une ligne qui utilise un 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. S'il est faux, il fait sortir le dernier élément de la pile et renvoie le tableau mis à jour.

La beauté de cet extrait est que la fonction inclut une arr[0]vérification pour éviter une boucle infinie. Une fois qu'il a atteint le dernier élément, il retourne la somme entière.

Vous pouvez combiner la méthode Reduce () avec l'expression lambda:

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

Utilisation reduce

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

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

console.log(sum);

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)

Précision

Tableau de tri et somme de début sous forme de plus petits nombres (l'extrait de code montre la différence avec le non tri)

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

Pour un tableau multidimensionnel de nombres, utilisez 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

Trucs sympas ici, j'ai un choix avec beaucoup de réponses traditionnelles sûres ne mettant pas en cache 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, c'est une surcharge inutile dans la plupart des cas. La V8 et de nombreux navigateurs modernes optimisent cela pour nous, c'est donc moins un problème que par le passé, mais il existe des appareils plus anciens qui bénéficient de cette mise en cache simple.

Si la longueur est sujette à changement, la mise en cache peut provoquer des effets secondaires inattendus si vous ne savez pas pourquoi vous mettez en cache la longueur, mais pour une fonction réutilisable, le seul but est de prendre un tableau et d'ajouter les valeurs ensemble, c'est un grand ajustement.

Voici un lien CodePen pour cette fonction arraySum. http://codepen.io/brandonbrule/pen/ZGEJyV

Il est possible que ce soit un état d'esprit dépassé qui m'est resté, mais je ne vois aucun inconvénient à l'utiliser dans ce contexte.

Ce sont vraiment d'excellentes réponses, mais juste au cas où si les nombres sont dans l'ordre 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 nombre

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

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)

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