property - object object javascript

¿Cómo enumero las propiedades de un objeto JavaScript?

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo hago un bucle o enumero un objeto JavaScript? 34 respuestas

¿Cómo enumero las propiedades de un objeto JavaScript?

Realmente quiero enumerar todas las variables definidas y sus valores, pero he aprendido que definir una variable en realidad crea una propiedad del objeto de ventana.

Answer 1

Aquí es cómo enumerar las propiedades de un objeto:

var params = { name: ''myname'', age: ''myage'' }
for (var key in params) {
alert(key + "=" + params[key]);
}

Answer 2

Código JavaScript simple:

for(var propertyName in myObject) {
// propertyName is what you want.
// You can get the value like this: myObject[propertyName]
}

jQuery:

jQuery.each(obj, function(key, value) {
// key is what you want.
// The value is in: value
});

Answer 3

Creo que un ejemplo del caso que me ha sorprendido es relevante:

var myObject = { name: "Cody", status: "Surprised" };
for (var propertyName in myObject) {
document.writeln( propertyName + " : " + myObject[propertyName] );
}

Pero para mi sorpresa, la salida es

name : Cody
status : Surprised
forEach : function (obj, callback) {
for (prop in obj) {
if (obj.hasOwnProperty(prop) && typeof obj[prop] !== "function") {
callback(prop);
}
}
}

¿Por qué? Otro script en la página ha extendido el prototipo de Objeto:

Object.prototype.forEach = function (obj, callback) {
for ( prop in obj ) {
if ( obj.hasOwnProperty( prop ) && typeof obj[prop] !== "function" ) {
callback( prop );
}
}
};

Answer 4

El dictado de Python tiene el método de ''claves'', y eso es realmente útil. Creo que en JavaScript podemos tener algo así:

function keys(){
var k = [];
for(var p in this) {
if(this.hasOwnProperty(p))
k.push(p);
}
return k;
}
Object.defineProperty(Object.prototype, "keys", { value : keys, enumerable:false });

EDITAR: Pero la respuesta de @carlos-ruana funciona muy bien. Probé Object.keys (ventana), y el resultado es el que esperaba.

EDITE después de 5 años: no es una buena idea extender Object , ya que puede entrar en conflicto con otras bibliotecas que quieran usar keys en sus objetos y provocará un comportamiento impredecible en su proyecto. La respuesta de @carlos-ruana es la forma correcta de obtener las claves de un objeto.

Answer 5

En los navegadores modernos (ECMAScript 5) para obtener todas las propiedades enumerables que puede hacer:

Object.keys(obj) (verifique el enlace para obtener un fragmento de la compatibilidad con versiones anteriores en navegadores antiguos)

O para obtener también propiedades no enumerables:

Object.getOwnPropertyNames(obj)

Consulte la tabla de compatibilidad de ECMAScript 5

Información adicional: ¿Qué es un atributo enumerable?

Answer 6

La forma estándar, que ya ha sido propuesta varias veces es:

for (var name in myObject) {
alert(name);
}

Sin embargo, Internet Explorer 6, 7 y 8 tienen un error en el intérprete de JavaScript, que tiene el efecto de que algunas claves no están enumeradas. Si ejecuta este código:

var obj = { toString: 12};
for (var name in obj) {
alert(name);
}

Si alertará "12" en todos los navegadores excepto IE. IE simplemente ignorará esta clave. Los valores clave afectados son:

• isPrototypeOf
• hasOwnProperty
• toLocaleString
• toString
• valueOf

Para estar realmente seguro en IE tienes que usar algo como:

for (var key in myObject) {
alert(key);
}
var shadowedKeys = [
"isPrototypeOf",
"hasOwnProperty",
"toLocaleString",
"toString",
"valueOf"
];
for (var i=0, a=shadowedKeys, l=a.length; i<l; i++) {
if map.hasOwnProperty(a[i])) {
alert(a[i]);
}
}

La buena noticia es que EcmaScript 5 define la función Object.keys(myObject) , que devuelve las claves de un objeto como una matriz y algunos navegadores (por ejemplo, Safari 4) ya lo implementan.

Answer 7

Lo encontré ... for (property in object) { // do stuff } listará todas las propiedades, y por lo tanto todas las variables declaradas globalmente en el objeto de la ventana ...

Answer 8

Puedes usar el for loop.

Si quieres usar una matriz:

Object.keys(object1)

Árbitro. Object.keys(obj)

Answer 9

Si está intentando enumerar las propiedades para escribir código nuevo contra el objeto, recomendaría usar un depurador como Firebug para verlas visualmente.

Otra técnica útil es usar el Objeto.toJSON () de Prototype para serializar el objeto a JSON, que le mostrará tanto los nombres como los valores de las propiedades.

var data = {name: ''Violet'', occupation: ''character'', age: 25, pets: [''frog'', ''rabbit'']};
Object.toJSON(data);
//-> ''{"name": "Violet", "occupation": "character", "age": 25, "pets": ["frog","rabbit"]}''

http://www.prototypejs.org/api/object/tojson

Answer 10

Si está utilizando la biblioteca Underscore.js , puede usar las keys función:

_.keys({one : 1, two : 2, three : 3});
=> ["one", "two", "three"]

Answer 11

Suficientemente simple:

for(var propertyName in myObject) {
// propertyName is what you want
// you can get the value like this: myObject[propertyName]
}

Ahora, no obtendrá variables privadas de esta manera porque no están disponibles.

EDITAR: @bitwiseplatypus tiene razón en que, a menos que use el método hasOwnProperty() , obtendrá propiedades que se heredan. Sin embargo, no sé por qué alguien familiarizado con la programación orientada a objetos esperaría algo menos. Normalmente, alguien que lo menciona ha sido sujeto a las advertencias de Douglas Crockford sobre esto, que aún me confunden un poco. Una vez más, la herencia es una parte normal de los lenguajes OO y, por lo tanto, es parte de JavaScript, a pesar de ser prototípico.

Ahora, dicho esto, hasOwnProperty() es útil para el filtrado, pero no necesitamos hacer una advertencia como si hubiera algo peligroso en obtener propiedades heredadas.

EDIT 2: @bitwiseplatypus muestra la situación que ocurriría si alguien agregara propiedades / métodos a sus objetos en un momento posterior al que escribió originalmente sus objetos (a través de su prototipo), si bien es cierto que esto puede causar un comportamiento inesperado , Yo personalmente no veo que sea mi problema por completo. Sólo una cuestión de opinión. Además, ¿qué sucede si diseño las cosas de tal manera que uso prototipos durante la construcción de mis objetos y, sin embargo, tengo un código que se repite sobre las propiedades del objeto y quiero todas las propiedades heredadas? No usaría hasOwnProperty() . Entonces, digamos, alguien agrega nuevas propiedades más tarde. ¿Es mi culpa si las cosas se comportan mal en ese momento? No lo creo. Creo que esta es la razón por la que jQuery, como ejemplo, ha especificado formas de extender su funcionamiento (a través de jQuery.extend y jQuery.fn.extend ).

Answer 12

Todavía soy un principiante en JavaScript, pero escribí una pequeña función para imprimir de forma recursiva todas las propiedades de un objeto y sus hijos:

getDescription(object, tabs) {
var str = "{/n";
for (var x in object) {
str += Array(tabs + 2).join("/t") + x + ": ";
if (typeof object[x] === ''object'' && object[x]) {
str += this.getDescription(object[x], tabs + 1);
} else {
str += object[x];
}
str += "/n";
}
str += Array(tabs + 1).join("/t") + "}";
return str;
}

Answer 13

Use un bucle for..in para enumerar las propiedades de un objeto, pero tenga cuidado. La enumeración devolverá las propiedades no solo del objeto que se está enumerando, sino también de los prototipos de cualquier objeto principal.

var myObject = {foo: ''bar''};
for (var name in myObject) {
alert(name);
}
// results in a single alert of ''foo''
Object.prototype.baz = ''quux'';
for (var name in myObject) {
alert(name);
}
// results in two alerts, one for ''foo'' and one for ''baz''

Para evitar incluir propiedades heredadas en su enumeración, verifique hasOwnProperty() :

for (var name in myObject) {
if (myObject.hasOwnProperty(name)) {
alert(name);
}
}

Edición: no estoy de acuerdo con la afirmación de JasonBunting de que no debemos preocuparnos por enumerar las propiedades heredadas. Existe el peligro de enumerar las propiedades heredadas que no espera, porque puede cambiar el comportamiento de su código.

No importa si este problema existe en otros idiomas; el hecho es que existe, y JavaScript es particularmente vulnerable ya que las modificaciones al prototipo de un objeto afectan a los objetos secundarios, incluso si la modificación tiene lugar después de la creación de instancias.

Esta es la razón por la que JavaScript proporciona hasOwnProperty() , y es por eso que debe usarlo para asegurarse de que el código de terceros (o cualquier otro código que pueda modificar un prototipo) no rompa el suyo. Además de agregar algunos bytes adicionales de código, no hay inconveniente en usar hasOwnProperty() .

Answer 14

for (prop in obj) {
alert(prop + '' = '' + obj[prop]);
}