Récupération dynamique des clés de la paire clé-valeur JSON Array - Javascript

J'ai une question qui aimerais solliciter votre expertise.

C'est un tableau JSON que j'ai:

[{"A":20,"B":32,"C":27,"D":30,"E":40}]

Ce que je voudrais faire est de récupérer les touches (A, B, C, D, E) à partir du tableau JSON au lieu de valeurs. Je suis en mesure de récupérer les valeurs mais pas les clés.

Je suis en utilisant ce afin de récupérer les valeurs dynamiquement:

function calculateSum(jsonArray) {
    var result = 0;
    for (var i = jsonArray.length - 1;  i >= 0; --i)
    {
        var o = jsonArray[i];
        A = o.A;
        B = o.B;
        C = o.C;
        D = o.D;
        E = o.E;
        result = A + B + C + D + E;
        return result;
    }

    return result;
}

De même, que dois-je faire pour récupérer le clés à l'aide de JavaScript?

source d'informationauteur Queryer

Êtes-vous à l'aide de D3.js que votre balise implique? Parce que dans ce cas, vous pouvez simplement utiliser d3.keys():

var data = [{"A":20,"B":32,"C":27,"D":30,"E":40}];
d3.keys(data[0]); //["A", "B", "C", "D", "E"]

Si vous voulez que la somme de toutes les valeurs, vous pourriez être mieux à l'aide de d3.values() et d3.sum():

var data = [{"A":20,"B":32,"C":27,"D":30,"E":40}, {"F":50}];
//get total of all object totals
var total = d3.sum(data, function(d) {
    //get total of a single object's values
    return d3.sum(d3.values(d));
});
total; //199

11

De tous les courants posté des solutions ont un problème. Aucun d'entre eux de vérifier pour de l'objet.hasOwnProperty(prop) lors de l'itération sur un objet à l'aide d'un...en boucle. Cela pourrait causer des touches fantômes apparaissent si les propriétés sont ajoutées au prototype.

Citant Douglas Crockford

Être conscient que les membres qui sont ajoutés pour le prototype de l'objet sera inclus dans l'énumération. Il est sage de programme, sur la défensive à l'aide de la hasOwnProperty méthode pour distinguer le vrai membres de l'objet.

Ajout d'une vérification pour hasOwnProperty à maerics' excellente solution.
```
var getKeys = function (arr) {
        var key, keys = [];
        for (i = 0; i < arr.length; i++) {
            for (key in arr[i]) {
                if (arr[i].hasOwnProperty(key)) {
                    keys.push(key);
                }
            }
        }
        return keys;
    };
```

Utilisation for .. in:

var result = 0;

for (var i = jsonArray.length - 1; i >= 0; --i) {
    var o = jsonArray[i];
    for (var key in o) {
      if (o.hasOwnProperty(key)) {
        result += o[key];
      }
    }
    //in your code, you return result here, 
    //which might not give the right result 
    //if the array has more than 1 element
}

return result;

var easy = {
    a: 1,
    b: 2,
    c: 3
}

var keys = [], vals = []
for (var key in easy) {
    keys.push(key)
    vals.push(easy[key])
}

alert(keys+" - tha's how easy baby, it's gonna be")
alert(vals+" - tha's how easy baby, it's gonna be")

défensivement

Y compris @Sahil défensif de la méthode...

for (var key in easy) {
    if (easy.hasOwnProperty(key)) {
        keys.push(key)
        vals.push(easy[key])
    }
}

Essayez d'utiliser le JavaScript .. déclaration:

var getKeys = function(arr) {
  var key, keys = [];
  for (i=0; i<arr.length; i++) {
    for (key in arr[i]) {
      keys.push(key);
    }
  }
  return keys;
};

var a = [{"A":20, "B":32, "C":27, "D":30, "E":40}, {"F":50}]
getKeys(a); //=> ["A", "B", "C", "D", "E", "F"]

Je pense que c'est le plus simple.

var a = [{"A":20,"B":32,"C":27,"D":30,"E":40}];
Object.keys( a[0] );

Résultat :

["A", "B", "C", "D", "E"]

Un for-in-boucle fait le tour. Sur un objet, il ressemble à ceci:

var o = {
    a: 5,
    b: 3
};
var num = 0;

for (var key in o) {
    num += o[key];
}
alert(num);

De l'essayer. C'est simple:

var a = [{"A":20,"B":32,"C":27,"D":30,"E":40}];

for(var i in a){
  for(var j in a[i]){
    console.log(j); //shows key
    console.log(a[i][j]); //shows value
  }
}

Je pense que ce doit être analysé de manière récursive comme ci-dessous

var getKeys = function(previousKeys,obj){
        var currentKeys = Object.keys(obj);
        previousKeys = previousKeys.concat(currentKeys);
        for(var i=0;i<currentKeys.length;i++){
            var innerObj = obj[currentKeys[i]];
            if(innerObj!==null && typeof innerObj === 'object' && !Array.isArray(innerObj)){
            return this.getKeys(previousKeys,innerObj);
            }
        }
        return previousKeys;
    }

utilisation: getKeys([],{"a":"1",n:{c:"3",e:{ f:4,g:[1,2,3]}}})

Résultat:
["a", "n", "c", "e", "f", "g"]

var _ = require('underscore');

var obj = [{"A":20,"B":32,"C":27,"D":30,"E":40},{"F":50}, {"G":60,"H":70},{"I":80}];

var keys = [], values = [];



_.each(obj, function(d) {

     keys.push(_.keys(d));

     values.push(_.values(d));
});


//Keys   ->  [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I' ]
console.log('Keys   -> ', _.flatten(keys ));
//Values ->  [ 20, 32, 27, 30, 40, 50, 60, 70, 80 ]
console.log('Values -> ', _.flatten(values));

0

arrêter de réinventer la roue !
```
Object.keys()
```
MDN

Vous devez vous connecter pour publier un commentaire.