Como listar as propriedades de um objeto JavaScript?

Digamos que eu crie um objeto assim:

var myObject =
        {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

Qual é a melhor maneira de recuperar uma lista dos nomes de propriedades? ou seja, eu gostaria de terminar com algumas 'chaves' variáveis, tais como:

keys == ["ircEvent", "method", "regex"]

Nos navegadores modernos (IE9 +, FF4 +, Chrome5 +, Opera12 +, Safari5 +), você pode usar o método Object.keys incorporado :

var keys = Object.keys(myObject);

O acima tem um polyfill completo, mas uma versão simplificada é:

var getKeys = function(obj){
   var keys = [];
   for(var key in obj){
      keys.push(key);
   }
   return keys;
}

Como alternativa, substitua var getKeyspor Object.prototype.keyspara permitir que você chame .keys()qualquer objeto. A extensão do protótipo tem alguns efeitos colaterais e eu não recomendaria fazê-lo.

Como slashnick apontou, você pode usar a construção "for in" para iterar sobre um objeto para seus nomes de atributo. No entanto, você estará iterando sobre todos os nomes de atributos na cadeia de protótipos do objeto. Se você deseja iterar apenas sobre os próprios atributos do objeto, poderá usar o método Object # hasOwnProperty () . Assim, tendo o seguinte.

for (var key in obj) {
    if (obj.hasOwnProperty(key)) {
        /* useful code here */
    }
}

Como Sam Dutton respondeu, um novo método para esse fim foi introduzido no ECMAScript 5th Edition. Object.keys()fará o que você deseja e é suportado no Firefox 4 , Chrome 6, Safari 5 e IE 9 .

Você também pode implementar muito facilmente o método em navegadores que não o suportam. No entanto, algumas das implementações existentes não são totalmente compatíveis com o Internet Explorer. Aqui está uma solução mais compatível:

Object.keys = Object.keys || (function () {
    var hasOwnProperty = Object.prototype.hasOwnProperty,
        hasDontEnumBug = !{toString:null}.propertyIsEnumerable("toString"),
        DontEnums = [ 
            'toString', 'toLocaleString', 'valueOf', 'hasOwnProperty',
            'isPrototypeOf', 'propertyIsEnumerable', 'constructor'
        ],
        DontEnumsLength = DontEnums.length;

    return function (o) {
        if (typeof o != "object" && typeof o != "function" || o === null)
            throw new TypeError("Object.keys called on a non-object");

        var result = [];
        for (var name in o) {
            if (hasOwnProperty.call(o, name))
                result.push(name);
        }

        if (hasDontEnumBug) {
            for (var i = 0; i < DontEnumsLength; i++) {
                if (hasOwnProperty.call(o, DontEnums[i]))
                    result.push(DontEnums[i]);
            }   
        }

        return result;
    };
})();

Observe que a resposta atualmente aceita não inclui uma verificação de hasOwnProperty () e retornará propriedades herdadas pela cadeia de protótipos. Ele também não é responsável pelo famoso bug DontEnum no Internet Explorer, onde propriedades não enumeráveis ​​na cadeia de protótipos fazem com que propriedades declaradas localmente com o mesmo nome herdem seu atributo DontEnum.

A implementação de Object.keys () fornecerá uma solução mais robusta.

EDIT: após uma discussão recente com kangax , um conhecido colaborador do Prototype, implementei a solução alternativa para o bug DontEnum com base no código para sua Object.forIn()função encontrada aqui .

Observe que Object.keys e outros métodos do ECMAScript 5 são suportados pelo Firefox 4, Chrome 6, Safari 5, IE 9 e superior.

Por exemplo:

var o = {"foo": 1, "bar": 2}; 
alert(Object.keys(o));

Tabela de compatibilidade do ECMAScript 5: http://kangax.github.com/es5-compat-table/

Descrição dos novos métodos: http://markcaudill.com/index.php/2009/04/javascript-new-features-ecma5/

Object.getOwnPropertyNames(obj)

Essa função também mostra propriedades não enumeráveis, além daquelas mostradas por Object.keys(obj) .

Em JS, toda propriedade possui algumas propriedades, incluindo um valor booleano enumerable .

Em geral, propriedades não enumeráveis ​​são mais "internas" e menos usadas, mas é interessante analisá-las algumas vezes para ver o que realmente está acontecendo.

Exemplo:

var o = Object.create({base:0})
Object.defineProperty(o, 'yes', {enumerable: true})
Object.defineProperty(o, 'not', {enumerable: false})

console.log(Object.getOwnPropertyNames(o))
// [ 'yes', 'not' ]

console.log(Object.keys(o))
// [ 'yes' ]

for (var x in o)
    console.log(x)
// yes, base

Observe também como:

• Object.getOwnPropertyNamese Object.keys não suba a cadeia de protótipos para encontrarbase
• for in faz

Mais sobre a cadeia de protótipos aqui: https://stackoverflow.com/a/23877420/895245

Eu sou um grande fã da função de despejo.

http://ajaxian.com/archives/javascript-variable-dump-in-coldfusion

Poderia fazê-lo com jQuery da seguinte maneira:

var objectKeys = $.map(object, function(value, key) {
  return key;
});

se você está tentando obter apenas os elementos, mas não as funções, esse código pode ajudá-lo

this.getKeys = function() {

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

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

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

isso faz parte da minha implementação do HashMap e eu quero apenas as chaves, "this" é o objeto hashmap que contém as chaves

Isso funcionará na maioria dos navegadores, mesmo no IE8, e nenhuma biblioteca de qualquer tipo é necessária. var i é sua chave.

var myJSONObject =  {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"}; 
var keys=[];
for (var i in myJSONObject ) { keys.push(i); }
alert(keys);

Em navegadores que suportam js 1.8:

[i for(i in obj)]

A Mozilla tem detalhes completos de implementação sobre como fazê-lo em um navegador onde não é suportado, se isso ajudar:

if (!Object.keys) {
  Object.keys = (function () {
    var hasOwnProperty = Object.prototype.hasOwnProperty,
        hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
        dontEnums = [
          'toString',
          'toLocaleString',
          'valueOf',
          'hasOwnProperty',
          'isPrototypeOf',
          'propertyIsEnumerable',
          'constructor'
        ],
        dontEnumsLength = dontEnums.length;

    return function (obj) {
      if (typeof obj !== 'object' && typeof obj !== 'function' || obj === null) throw new TypeError('Object.keys called on non-object');

      var result = [];

      for (var prop in obj) {
        if (hasOwnProperty.call(obj, prop)) result.push(prop);
      }

      if (hasDontEnumBug) {
        for (var i=0; i < dontEnumsLength; i++) {
          if (hasOwnProperty.call(obj, dontEnums[i])) result.push(dontEnums[i]);
        }
      }
      return result;
    };
  })();
}

Você pode incluí-lo como quiser, mas possivelmente em algum tipo de extensions.jsarquivo na parte superior da sua pilha de scripts.

Usar Reflect.ownKeys()

var obj = {a: 1, b: 2, c: 3};
Reflect.ownKeys(obj) // ["a", "b", "c"]

Object.keys e Object.getOwnPropertyNames não podem obter propriedades não enumeráveis . Está funcionando mesmo para propriedades não enumeráveis .

var obj = {a: 1, b: 2, c: 3};
obj[Symbol()] = 4;
Reflect.ownKeys(obj) // ["a", "b", "c", Symbol()]

O IE não suporta (i in obj) para propriedades nativas. Aqui está uma lista de todos os acessórios que eu poderia encontrar.

Parece que o stackoverflow faz alguma filtragem estúpida.

A lista está disponível na parte inferior desta postagem do grupo do Google: - https://groups.google.com/group/hackvertor/browse_thread/thread/a9ba81ca642a63e0

Desde que eu uso underscore.js em quase todos os projetos, usaria a keysfunção:

var obj = {name: 'gach', hello: 'world'};
console.log(_.keys(obj));

A saída disso será:

['name', 'hello']

Com base na resposta aceita.

Se o objeto tiver propriedades que você deseja chamar, digamos .properties (), tente!

var keys = Object.keys(myJSONObject);

for (var j=0; j < keys.length; j++) {
  Object[keys[j]].properties();
}

A solução funciona nos meus casos e no navegador cruzado:

var getKeys = function(obj) {
    var type = typeof  obj;
    var isObjectType = type === 'function' || type === 'object' || !!obj;

    // 1
    if(isObjectType) {
        return Object.keys(obj);
    }

    // 2
    var keys = [];
    for(var i in obj) {
        if(obj.hasOwnProperty(i)) {
            keys.push(i)
        }
    }
    if(keys.length) {
        return keys;
    }

    // 3 - bug for ie9 <
    var hasEnumbug = !{toString: null}.propertyIsEnumerable('toString');
    if(hasEnumbug) {
        var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

        var nonEnumIdx = nonEnumerableProps.length;

        while (nonEnumIdx--) {
            var prop = nonEnumerableProps[nonEnumIdx];
            if (Object.prototype.hasOwnProperty.call(obj, prop)) {
                keys.push(prop);
            }
        }

    }

    return keys;
};