Agrégation de valeurs d'objet de tableaux JavaScript?

Question

En JavaScript, nombre n donné de tableaux en entrée dans ce format: (n = 2)

array1: 
[{x: 1, y: 5},{x: 2, y: 3},{x: 3, y: 6}] 

array2: 
[{x: 1, y: 2},{x: 2, y: 6},{x: 3, y: 2}] 

Comment puis-je cumuler les valeurs Y facilement et obtenir ce tableau résultant:

arrayOutput: 
[{x: 1, y: 7},{x: 2, y: 9},{x: 3, y: 8}] 

Je vous remercie.

Answer 1

Mise à jour: Le commentaire supplémentaire sur les x valeurs et leurs positions dans les tableaux ci-dessous rend le hors de propos.

Il n'y a pas de truc particulier, il vous suffit de faire une boucle dans les tableaux et de construire votre résultat. Ce n'est rien de plus qu'une boucle imbriquée. Si vous essayez d'optimiser l'efficacité sur une large gamme de moteurs JavaScript, évitez les appels de fonction inutiles.

Quelque chose le long des lignes de:

function sumYValues(arrays) { 
    var outer, inner, array, entry, sum, result, x; 

    // Create our result array with a copy of the first array 
    result = []; 
    if (arrays.length > 0) { 
     array = arrays[0]; 
     for (inner = 0; inner < array.length; ++inner) { 
      entry = array[inner]; 
      result[inner] = {x: entry.x, y: entry.y}; 
     } 

     // Add in the remaining values 
     for (outer = 1; outer < arrays.length; ++outer) { 
      array = arrays[outer]; 
      // You might want an assert here verifying that result.length == array.length 
      for (inner = 0; inner < array.length; ++inner) { 
       entry = array[inner]; 
       // You might want an assert here verifying that result[inner].x == entry.x 
       result[inner].y += entry.y; 
      } 
     } 
    } 

    return result; 
} 

Ces boucles comptent de 0 (ou 1) à array.length - 1. Vous pouvez profiler si revenir en arrière (array.length - 1 à 0 (ou 1)) est plus rapide, la plupart du temps le "jusqu'à 0". J'avais l'habitude de supposer que c'était parce qu'il était en C quand j'étais un jeune visage frais (les comparaisons à 0 sont plus rapides que les comparaisons à une autre variable), mais cette hypothèse peut ou ne peut pas être valide en JavaScript.

---

Il n'y a pas de raccourci particulier, il vous suffit de faire une boucle dans les tableaux, d'effectuer vos comparaisons et de construire votre résultat. Si les valeurs x sont uniques dans chaque tableau, il peut être plus facile de suivre votre somme en cours en utilisant un objet plutôt qu'un tableau et en utilisant les valeurs x comme clés, puis de les convertir en tableau lorsque vous c'est fait. .: par exemple

function sumYValues(arrays) { 
    var outer, inner, ar, entry, sum, result, x; 

    sum = {}; 
    for (outer = 0; outer < arrays.length; ++outer) { 
     ar = arrays[outer]; 
     for (inner = 0; inner < arrays.length; ++inner) { 
      entry = ar[inner]; 
      sum[entry.x] = (sum[entry.x] || 0) + entry.y; 
     } 
    } 

    result = []; 
    for (x in sum) { 
     result.push({x: x, y: sum[x]}); 
    } 

    return result; 
} 

Ce qui précède est la plupart du temps juste pour démontrer l'utilisation sum, un objet, comme une carte de x =>y valeurs, même si elle n'implémente au moins une partie de la logique de sommation ainsi.

Cette ligne peut nécessiter quelques explications:

  sum[entry.x] = (sum[entry.x] || 0) + entry.y; 

Si sum ne dispose pas d'entrée pour cette valeur x, sum[entry.x] sera undefined, qui est une valeur « Falsey ». Donc, nous utilisons le curiously-powerful || operator soit pour obtenir la valeur pour ce x de sumou0, et ensuite ajouter le y actuel de l'entrée et de stocker le résultat.

Answer 2

Benchmark Example

Notez que le code mixte est plus rapide suivie par des boucles suivies par natif/underscore.

function createOutput(arr1, arr2, arr3 /*, ... */) { 
    return Array.prototype.reduce.call(arguments, function (prev, curr) { 
     return prev.map(function(val, index) { 
      return { 
       x: val.x, 
       y: val.y + curr[index].y 
      } 
     }); 
    }); 
} 

Suppose tableaux sont triés et contiennent toutes les valeurs de x pour 1..n sans lacunes.

Type de requiert ES5. Cela peut être échangé pour _ qui donne ce genre de fonctionnalité d'une manière croisée de navigateur.

Avec underscore il est

function createOutput() { 
    return _.reduce(arguments, function (memo, arr) { 
     return _.map(memo, function(val, index) { 
      return { x: val.x, y: val.y + arr[index].y }; 
     }); 
    }); 
}