Underscore.js convertit l'objet array

Je suis relativement nouveau à underscore.js et j'ai un objet en provenance d'un service REST qui ressemble à ceci (j'ai tapé à la main, et il a attribué à une var ici):

var production = [
    {key: ["wind", "1"], value: 5},
    {key: ["wind", "2"], value: 9},
    {key: ["wind", "3"], value: 11},
    {key: ["wind", "4"], value: 7},
    {key: ["solar", "1"], value: 1},
    {key: ["solar", "2"], value: 1},
    {key: ["solar", "3"], value: 2},
    {key: ["solar", "4"], value: 3},
    {key: ["oil", "1"], value: 15},
    {key: ["oil", "2"], value: 16},
    {key: ["oil", "3"], value: 22},
    {key: ["oil", "4"], value: 23},
];

Puis plus bas, j'ai un code qui analyse cet objet et crée des tableaux pour les éléments comme suit:

var orderedProduction = _.chain(production)
      .groupBy(function (entity) {
            return entity.key[0];
      })
      .map(function (values) { 
            return _.map(values, function (entity2) {
                  return entity2.value;
            });
      })
      .value();

Cela donne les résultats suivants:

orderedProduction  = [
  [5, 9, 11, 7],
  [1, 1, 2, 3],
  [15, 16, 22, 23]
]

Qui perd les clés (éolien/solaire/huile). Et est utilisé pour tracer un graphique. Je suis plus en mesure de vérifier si certains de ces tableaux répondre à un certain seuil comme suit:

var threshold = _.map(orderedProduction  , function(arr) {
    return _.max(arr) > 10;
});

Mes besoins ont changé et j'ai maintenant besoin de filtrer ces tableaux par sa somme totale, tout en conservant la clé.

Ce que je voudrais terminer avec un objet de la sorte:

orderedProduction  = {
      "wind": [5, 9, 11, 7],
      "solar": [1, 1, 2, 3],
      "oil": [15, 16, 22, 23]
    }

Ce serait formidable si le correctif inclus un moyen d'additionner les valeurs de la matrice et de supprimer ceux qui ne sont pas au total jusqu'à un certain montant. (c'est à dire exclure solaire, si ce n'est pas ajouter jusqu'à 10).

Ici est un jsfiddle j'ai créé pour tester tout cela sur: http://jsfiddle.net/2mfjw3jk/

Mise à JOUR:
La solution que j'ai réglé pour:

var orderedProduction = _.chain(production)
    .groupBy(function (entity) {
        return entity.key[0];
    })
    .map(function (vals, key) {
        return [key, _.pluck(vals, 'value')]
    })
    .filter(function(arr) {
        var sum = 0;
        _.each(arr[1], function(num){
            sum += num;
        })
        return sum > 10;
    })
    .object()
    .value();

Il filtre également les valeurs par un seuil prédéterminé (10 dans ce cas).

OriginalL'auteur Husman | 2014-09-16

Vous y êtes presque:

var orderedProduction = _.chain(production)
    .groupBy(function (entity) {
        return entity.key[0];
    })
    .map(function (vals, key) {
        return [key, _.pluck(vals, 'value')]
    })
    .object()
    .value();

retourne

{ wind: [ 5, 9, 11, 7 ],
  solar: [ 1, 1, 2, 3 ],
  oil: [ 15, 16, 22, 23 ] }

Génial. J'ai fait le gérer à l'aide d'une chaîne, plumer, uniq, l'objet. Mais cette solution est beaucoup plus soignée. Merci beaucoup.

OriginalL'auteur georg

2

Vous pouvez simplement utiliser la carte() fonction en javascript. L' _.map() est donné pour la compatibilité descendante.
De toute façon, voici le code :
```
var obj = {};
production.map(function(data) {
    if(data.key[0] in obj) {
        obj[data.key[0]] += data.value;
    } else {
        obj[data.key[0]] = 0;
        obj[data.key[0]] += data.value;
    }
});
console.log(obj);
```
Donc ce qui est fait est qu'il fait une boucle à travers la production de tableau. Là, il vérifie si la clé(par exemple, la " clé " est la clé) est dans l'objet obj ou pas. Si elle est là, alors elle incrémente sa valeur ou d'autre fait une nouvelle clé et l'attribue à 0 et l'incrémente.

Pas le plus optimisé le code, mais il fonctionne très bien.

Ceci est utile, mais je n'ai pas besoin totaux. J'ai encore besoin d'un tableau de valeurs (j'.e "huile": [15, 16, 22, 23])

OriginalL'auteur shash7

Ce n'est probablement pas la meilleure exécution de code, mais il fait le travail en utilisant le trait de soulignement.

Démonstration En Direct

var production = [
{key: ["wind", "1"], value: 5},
{key: ["wind", "2"], value: 9},
{key: ["wind", "3"], value: 11},
{key: ["wind", "4"], value: 7},
{key: ["solar", "1"], value: 1},
{key: ["solar", "2"], value: 1},
{key: ["solar", "3"], value: 2},
{key: ["solar", "4"], value: 3},
{key: ["oil", "1"], value: 15},
{key: ["oil", "2"], value: 16},
{key: ["oil", "3"], value: 22},
{key: ["oil", "4"], value: 23}
];
var orderedProduction =  _.chain(production)
.groupBy(function (entity) {
return entity.key[0];
})
.map(function(items, key){
var returnVal = [key]; 
var total = 0; 
returnVal.push(_.map(items, function(obj){
total += obj.value; 
return obj.value; 
})); 
if(total > 10){
return returnVal; 
}
})
.filter(function(num) {
return num !== undefined;
})
.object()
.value();
console.log(production);
console.log(orderedProduction);

C'est assez proche. Il donne un tableau d'objets et supprime le solaire de l'objet. Ce que je voulais, c'était un objet avec des propriétés (éolien/solaire/huile) et chaque propriété a un tableau de nombres.
Ahh, pas sûr de savoir comment j'ai manqué. Je sais que vous avez déjà eu une réponse, mais j'ai corrigé cela de toute façon.

OriginalL'auteur Brandon Boone

Vous devez vous connecter pour publier un commentaire.