Comment trouver les clés de hachage?

Je sais que dans les Objets javascript double hachages mais j'ai été incapable de trouver une fonction intégrée à la remise des clés

var h = {a:'b',c:'d'};

Je veux quelque chose comme

var k = h.keys() ; //k = ['a','c'];

Il est simple d'écrire une fonction moi-même d'itérer sur les éléments et ajouter les clés d'un tableau que je revienne, mais est-il une norme de manière plus propre de le faire?

Je garde le sentiment qu'il doit être un simple construit en fonction que je l'ai raté mais je ne le trouve pas!

Je suis juste de sauter en javascript, mais ce post peut vous aider. dean.edwards.nom/blog/2006/07/enum
Double Possible de Obtenir la matrice de l'objet avec les touches
Mais comment obtenir les valeurs des clés? En outre, obtenir le nombre de clés dans une table de hachage.
2017 réponse: de l'Objet.les touches(h) de l'Objet.valeurs(h)

InformationsquelleAutor Pat | 2008-08-20

271

Il y a de la fonction moderne de JavaScript (ECMAScript 5) appelé de l'Objet.les touches l'exécution de cette opération:
```
var obj = { "a" : 1, "b" : 2, "c" : 3};
alert(Object.keys(obj)); //will output ["a", "b", "c"]
```
Compatibilité de détails peuvent être trouvés ici.

Sur le Site Mozilla il y a aussi un extrait de code pour compatibilité ascendante:
```
if(!Object.keys) Object.keys = function(o){
   if (o !== Object(o))
      throw new TypeError('Object.keys called on non-object');
   var ret=[],p;
   for(p in o) if(Object.prototype.hasOwnProperty.call(o,p)) ret.push(p);
   return ret;
}
```
- ne serait-ce pas ont été de plus naturel? if(!Object.prototype.keys) Object.prototype.keys = function() { if (this !== Object(this)) throw new TypeError('Object.keys called on non-object'); var ret = [], p; for (p in this) if (Object.prototype.hasOwnProperty.call(this, p)) ret.push(p); return ret; } var x = { a: { A: 1, B: 2, C: 3 }, b: { A: 10, B: 20 } }; alert(x.a.keys());
- Comme je comprends ce Object.prototype.keys fera keys disponible pour tous les sous-classes d'Objet, donc pour tous les objets. Ce qui, probablement, vous voulez si vous essayez d'utiliser la programmation orientée objet. De toute façon, cela dépend vraiment de vos besoins.
- Si vous utilisez mootools, l'Objet.les touches() doit être disponible dans tous les navigateurs.
- Est-il rien de l'utiliser dans angulaire modèles? Sa ne fonctionne pas il y a à l'intérieur de partiels.
- Je pense que vous devriez demander à ce que la question avec un exemple de code.
InformationsquelleAutor Ivan Nevostruev
80

Pour la production de code nécessitant une grande compatibilité avec les navigateurs des clients j'ai toujours penser Ivan Nevostruev la réponse ci-dessus avec shim pour assurer Object.keys dans les navigateurs plus anciens. Cependant, il est possible d'obtenir exactement les fonctionnalités demandées à l'aide de l'ECMA nouveau defineProperty fonctionnalité.

Comme ECMAScript 5 - Objet.defineProperty

De ECMA5 vous pouvez utiliser de l'Objet.defineProperty() à définir non énumérable propriétés. Le compatibilité a encore beaucoup à désirer, mais cela devrait à terme devenir utilisable dans tous les navigateurs. (Plus précisément remarque le courant de l'incompatibilité avec IE8!)
```
Object.defineProperty(Object.prototype, 'keys', {
  value: function keys() {
    var keys = [];
    for(var i in this) if (this.hasOwnProperty(i)) {
      keys.push(i);
    }
    return keys;
  },
  enumerable: false
});

var o = {
    'a': 1,
    'b': 2
}

for (var k in o) {
    console.log(k, o[k])
}

console.log(o.keys())

# OUTPUT
# > a 1
# > b 2
# > ["a", "b"]
```
Cependant, depuis ECMA5 déjà ajouté Object.keys vous pourriez aussi bien utiliser:
```
Object.defineProperty(Object.prototype, 'keys', {
  value: function keys() {
    return Object.keys(this);
  },
  enumerable: false
});
```
Réponse originale à cette question
```
Object.prototype.keys = function ()
{
  var keys = [];
  for(var i in this) if (this.hasOwnProperty(i))
  {
    keys.push(i);
  }
  return keys;
}
```
Edit: Depuis cette réponse a été autour pendant un certain temps, je vais partir la dessus intacte. Tous ceux qui lisent ceci devrait également lire Ivan Nevostruev la réponse ci-dessous.

Il n'y a aucun moyen de la fabrication de prototypes de fonctions non-énumérables qui conduit à toujours tourner dans les boucles for-in qui n'utilisent pas hasOwnProperty. Je pense toujours que cette réponse serait l'idéal si l'on prolonge le prototype de l'Objet n'était pas tellement bordélique.
- 'hasOwnProperty exclut des propriétés sur les prototypes de cet objet, ce qui est utile à savoir.
- Réponse acceptée parce que j'ai fini par la mettre en œuvre mais je pense qu'il doit avoir été intégré dans la fonction de la langue.
- Notez que vous devez utiliser "for (var i dans le présent)..." pour éviter de créer une variable globale.
- J'aimerais éviter d'en modifier l'Objet.prototype - comme un autre intervenant a noté ci-dessous, cela peut facilement se casser les scripts qui ne fait pas attention à la vérification de hasOwnProperty(). Au lieu de cela, utiliser le moins de OO-amical: définir un " touches de fonction si elle n'existe pas déjà. (Firefox et Chrome à la fois de mettre en œuvre un natif de touches de fonction() qui fait exactement ce que l'OP veut - c'est à dire qui ne fonctionne pas)
- Il n'y a pas un Object.prototype.keys dans ECMAScript 5. gist.github.com/1034464
- Il semble être une mauvaise idée d'ajouter quelque chose à l'Objet.prototype, qu'elle brise tous les normal de la boucle comme: for (var k dans le tableau) { } ou for (var k dans l'objet), et que l'idiome qu'il est peut-être défectueux - est extrêmement commun. Par exemple, selon Matthieu Darwin réponse ci-dessous, il se casse Google Maps.
- Ce n'est pas la voie à suivre pour un certain nombre de raisons; 1) Vous ne devriez vraiment pas à ajouter des choses à Object.prototype à tous, et certainement pas de cette façon 2) Vous devriez être en utilisant Object.keys comme mentionné dans Ivan Nevostuev réponse
- Je ne suis pas sûr de savoir comment prendre votre commentaire. Je l'ai déjà dit la même chose dans le Modifier une partie de ma réponse.
InformationsquelleAutor Annan
40

vous pouvez utiliser Object.keys
```
Object.keys(h)
```
- Ajouté dans ECMAScript 5, mais devrait fonctionner dans la plupart des principaux navigateurs maintenant
InformationsquelleAutor Leticia Santos
33

Vous pouvez utiliser Underscore.js, qui est un utilitaire de Javascript library.
```
_.keys({one : 1, two : 2, three : 3}); 
//=> ["one", "two", "three"]
```
- Eh bien, ce n'est pas vraiment ce qui était demandé, parce que @Pat est à la recherche d'une fonction intégrée, mais c'est une bibliothèque intéressante néanmoins, et il ne modifie pas Object.prototype
- Ces jours-ci, je pense qu'il est beaucoup plus utile d'utiliser ces chouette petite bibliothèque-permet de continuer à écrire vos propres implémentations... de toute façon, dans la plupart des projets réels, nous sommes de toute façon à l'aide de Soulignement ou équivalent bibliothèques. Personnellement, je préfère aller avec un trait de Soulignement.
- _.keys(obj).length pour voir si il ya toutes les clés.
InformationsquelleAutor timotti
13

C'est le meilleur que vous pouvez faire, autant que je sache...
```
var keys = [];
for (var k in h)keys.push(k);
```
- Cela ne fonctionne pas lorsque l'Objet.le prototype a été testé avec.
- Il serait préférable d'utiliser cela, et de ne pas "gâcher" de l'Objet.le prototype. Il semble que tout se casse si on ajoute des choses pour l'Objet.prototype: c'est un très commun de l'idiome de la boucle sur les touches d'un tableau / objet.
InformationsquelleAutor danb

à l'aide de jQuery vous pouvez obtenir les clés comme ceci:

var bobject =  {primary:"red",bg:"maroon",hilite:"green"};
var keys = [];
$.each(bobject, function(key,val){ keys.push(key); });
console.log(keys); //["primary", "bg", "hilite"]

Ou:

var bobject =  {primary:"red",bg:"maroon",hilite:"green"};
$.map(bobject, function(v,k){return k;});

grâce à @pimlottc

Si vous voulais aller dans cette voie, vous pourriez aussi bien utiliser JQuery.map: $.map(h, function(v,k) { return k; });

InformationsquelleAutor chim

6

Je crois que vous pouvez faire une boucle à travers les propriétés de l'objet à l'aide de/, de sorte que vous pourriez faire quelque chose comme ceci:
```
function getKeys(h) {
  Array keys = new Array();
  for (var key in h)
    keys.push(key);
  return keys;
}
```
- Cela ne fonctionne pas, voir Annan répondre
InformationsquelleAutor palmsey
4

Je voulais utiliser le top rated réponse ci-dessus
```
Object.prototype.keys = function () ...
```
Cependant lors de l'utilisation en conjonction avec l'API google maps v3, google maps est non-fonctionnelle.
```
for (var key in h) ...
```
fonctionne bien.

InformationsquelleAutor Matthew Darwin
1

si vous essayez d'obtenir les éléments, mais pas les fonctions de ce code peut vous aider à
```
this.getKeys = function() {

var keys = new Array();
for(var key in this) {

    if( typeof this[key] !== 'function') {

        keys.push(key);
    }
}
return keys;
```
}

cela fait partie de ma mise en œuvre de la table de hachage et je veux seulement les touches, this est la table de hachage de l'objet qui contient les touches de

InformationsquelleAutor zeacuss

Vous devez vous connecter pour publier un commentaire.