La somme des valeurs d'un Tableau en JavaScript

J'ai défini une variables JavaScript appelé myData qui est un new Array comme ceci:

var myData = new Array(['2013-01-22', 0], ['2013-01-29', 0], ['2013-02-05', 0],
             ['2013-02-12', 0], ['2013-02-19', 0], ['2013-02-26', 0], 
             ['2013-03-05', 0], ['2013-03-12', 0], ['2013-03-19', 0], 
             ['2013-03-26', 0], ['2013-04-02', 21], ['2013-04-09', 2]);

Je me demande si il est possible d'additionner le nombre de valeurs que l'on retrouve dans le tableau (ex. 0+0+21+2+0 et ainsi de suite) et ont probablement une variable avec le résultat que je peux l'utiliser en dehors de la balise de script parce que j'ai 7 de ce type de tableaux correspondants pour chaque jour de la semaine. Je veux faire une comparaison par la suite sur cette base. C'est la méthode choisie pour ce type d'actions s'est-elle possible?

Parcourir le tableau et ajouter la deuxième éléments de l'intérieur des tableaux.

InformationsquelleAutor Daniela costina Vaduva | 2013-04-17

18

Essayez ce qui suit

JS:
```
var myData = [['2013-01-22', 0], ['2013-01-29', 1], ['2013-02-05', 21]];

var myTotal = 0;  //Variable to hold your total

for(var i = 0, len = myData.length; i < len; i++) {
    myTotal += myData[i][1];  //Iterate over your first array and then grab the second element add the values up
}

document.write(myTotal); //22 in this instance
```
- Je pense que vous vouliez dire myData[i][1]. Et pourquoi utiliser parseFloat si la valeur est déjà un certain nombre de toute façon?
- la sortie de 24156 au lieu de comme il se doit 3. J'ai testé avec un "vide tableau de valeur", et je reçois le même résultat...
- il fonctionne avec myData[i][1] mais comment je fais myTotal disponibles dans d'autres balise de script?
- Daniel, avez-vous corriger la faute de frappe que Félix Kling souligné? Rember à l'écriture de "myData[i][1]" au lieu de la version incorrecte: "myData[1]" dans l'exemple.
- Merci ont édité, et je suppose que j'étais overprecautius en utilisant parseFloat. Daniela je l'ai testé et il fonctionne jetez un oeil ici - jsbin.com/ibajas/1
- Pour le rendre disponible à d'autres balises de script: assurez-vous que le variabele est mondiale. Cela signifie que sa déclaration (ie. "var mytotal") devrait se produire juste après la balise de script et pas à côté des curley accolades "{}". Assurez-vous également que son chargement avant les autres balises de script, sinon la variable ne sera pas initialisé.
- merci pour les conseils 🙂
- Ok merci. Ressemble à ce que je cherchais
InformationsquelleAutor Mark Walters
98

Vous pouvez utiliser le Array.reduce méthode:

JS:
```
const myData = [
  ['2013-01-22', 0], ['2013-01-29', 0], ['2013-02-05', 0],
  ['2013-02-12', 0], ['2013-02-19', 0], ['2013-02-26', 0], 
  ['2013-03-05', 0], ['2013-03-12', 0], ['2013-03-19', 0], 
  ['2013-03-26', 0], ['2013-04-02', 21], ['2013-04-09', 2]
];
const sum = myData
  .map( v => v[1] )                                
  .reduce( (sum, current) => sum + current, 0 );
  
console.log(sum);
```
Voir SOCIÉTÉ
- Il devrait être prev[1], je suppose. Par tous les moyens, le résultat ne sera pas donner 23.
- S'il vous plaît être conscient que Array.reduce est un ECMAscript 5 plus afin de ne pas être pris en charge par tous les navigateurs - voir ici developer.mozilla.org/en-US/docs/JavaScript/Reference/..., qui comprend également un bout de code qui peuvent être mises en œuvre pour surmonter cette
- oublié la valeur initiale, de l'ajouter. Et non, il ne devrait pas être prev[1] @MarkWalters: yep, mais on peut utiliser la cale du MDN-link (voir la réponse)
- Avec un ES6 flèche fonction: var sum = myData.reduce((sum, current) => (sum + current[1]), 0);
InformationsquelleAutor KooiInc
53

Je pense que la façon la plus simple pourrait être:
```
values.reduce(function(a, b){return a+b;})
```
- Ce doit être la accepté de répondre à la question générale posée, mais l'affiche avait une structure de données qui ne fonctionnerait pas avec cela malheureusement. C'est précisément le meilleur moyen de gérer un tableau de nombres si
- En s'assurant qu'ils sont des nombres ne ferait pas de mal: les valeurs.réduire(function(a, b){return +a + +b;})
- retour o[1]; }).réduire(a, b) { return a + b; })
- Avec EC6, cela pourrait ressembler à values.reduce((a + b) => a + b)
InformationsquelleAutor ruhanbidart

Je voudrais utiliser réduire

var myData = new Array(['2013-01-22', 0], ['2013-01-29', 0], ['2013-02-05', 0], ['2013-02-12', 0], ['2013-02-19', 0], ['2013-02-26', 0], ['2013-03-05', 0], ['2013-03-12', 0], ['2013-03-19', 0], ['2013-03-26', 0], ['2013-04-02', 21], ['2013-04-09', 2]);

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

$("#result").text(sum);

Disponible sur jsfiddle

InformationsquelleAutor Xotic750

12

La création d'une somme méthode pourrait fonctionner très bien, par exemple, vous pouvez ajouter la fonction somme de la Matrice de
```
Array.prototype.sum = function(selector) {
    if (typeof selector !== 'function') {
        selector = function(item) {
            return item;
        }
    }
    var sum = 0;
    for (var i = 0; i < this.length; i++) {
        sum += parseFloat(selector(this[i]));
    }
    return sum;
};
```
alors vous pourriez le faire
```
> [1,2,3].sum()
6
```
et dans votre cas,
```
> myData.sum(function(item) { return item[1]; });
23
```
Edit: l'Extension de la les builtins peut être mal vu parce que si tout le monde faisait ça nous permettrait de faire les choses de façon inattendue substituant les uns aux autres (collisions d'espace de noms). vous pouvez ajouter la fonction somme pour certains de module et d'accepter un tableau comme argument si vous le souhaitez.
que pourrait signifier que l'évolution de la signature de myModule.sum = function(arr, selector) { puis this deviendrait arr

InformationsquelleAutor lee penkman
7

Ou dans l'ES6

values.reduce((a, b) => a + b),

exemple:
```
[1,2,3].reduce((a, b)=>a+b) //return 6
```
InformationsquelleAutor Honzík
2

Si vous voulez vous débarrasser de la matrice en même temps que la sommation, vous pourriez faire (dire, stack est le tableau):
```
var stack = [1,2,3],
    sum = 0;
while(stack.length > 0) { sum += stack.pop() };
```
InformationsquelleAutor btk

Vous pouvez utiliser le natif de la carte de méthode pour les Tableaux.
Méthode map (Tableau) (JavaScript)

var myData = new Array(['2013-01-22', 0], ['2013-01-29', 0], ['2013-02-05', 0],
             ['2013-02-12', 0], ['2013-02-19', 0], ['2013-02-26', 0], 
             ['2013-03-05', 0], ['2013-03-12', 0], ['2013-03-19', 0], 
             ['2013-03-26', 0], ['2013-04-02', 21], ['2013-04-09', 2]);
var a = 0;
myData.map( function(aa){ a += aa[1];  return a; });

un est votre résultat

InformationsquelleAutor bjhamltn

0

Le javascript intégré pour réduire les Tableaux n'est pas un standard, mais vous pouvez utiliser underscore.js:
```
var data = _.range(10);
var sum = _(data).reduce(function(memo, i) {return memo + i});
```
qui devient
```
var sumMyData = _(myData).reduce(function(memo, i) {return memo + i[1]}, 0);
```
pour votre cas. Jetez un oeil à cette violon aussi.

InformationsquelleAutor Gismo Ranas

Ancienne (si vous n'avez pas maintenant la longueur d'arguments/paramètres)

 >> function sumla1(){

    result=0
    for(let i=0; i<arguments.length;i++){

        result+=arguments[i];

    }
    return result;
    }
    >> sumla1(45,67,88);
    >> 200

ES6 (déstructuration de la matrice)

>> function sumla2(...x){return x.reduce((a,b)=>a+b)}
>>
>> sumla2(5,5,6,7,8)
>>
>> 31
>>
>> var numbers = [4, 9, 16, 25];
>> sumla2(...numbers);
>> 54

InformationsquelleAutor Musa

Vous devez vous connecter pour publier un commentaire.