¿Cómo accedo a las propiedades de un objeto javascript si no conozco los nombres?

Question

Digamos que tienes un objeto JavaScript como esto:

var data = { foo: 'bar', baz: 'quux' }; 

Puede acceder a las propiedades por el nombre de la propiedad:

var foo = data.foo; 
var baz = data["baz"]; 

Pero ¿es posible obtener estos valores si no se conoce el nombre de las propiedades? ¿La naturaleza desordenada de estas propiedades hace que sea imposible distinguirlas?

En mi caso, estoy pensando específicamente en una situación en la que una función necesita aceptar una serie de pares nombre-valor, pero los nombres de las propiedades pueden cambiar.

Mis pensamientos sobre cómo hacer esto hasta ahora es pasar los nombres de las propiedades a la función junto con los datos, pero esto se siente como un truco. Preferiría hacer esto con introspección si es posible.

Answer 1

Las versiones antiguas de JavaScript (< ES5) requieren el uso de un bucle for..in:

for (var key in data) { 
    if (data.hasOwnProperty(key)) { 
    // do something with key 
    } 
} 

ES5 introduce Object.keys y Array#forEach que hace esto un poco más fácil:

var data = { foo: 'bar', baz: 'quux' }; 

Object.keys(data); // ['foo', 'baz'] 
Object.keys(data).map(function(key){ return data[key] }) // ['bar', 'quux'] 
Object.keys(data).forEach(function (key) { 
    // do something with data[key] 
}); 

ES2017 introduce Object.values y Object.entries.

Object.values(data) // ['bar', 'quux'] 
Object.entries(data) // [['foo', 'bar'], ['baz', 'quux']] 

Answer 2

for(var property in data) { 
    alert(property); 
} 

Answer 3

Puede recorrer las llaves de esta manera:

for (var key in data) { 
    console.log(key); 
} 

Esto registra "Nombre" y "Valor".

Si tiene un tipo de objeto más complejo (no solo un objeto tipo hash simple, como en la pregunta original), solo querrá recorrer las teclas que pertenecen al objeto en sí, a diferencia de las teclas prototype del objeto:

for (var key in data) { 
    if (data.hasOwnProperty(key)) { 
    console.log(key); 
    } 
} 

Como se anotó, las claves no se garantiza que sea en un orden particular. Tenga en cuenta cómo esto difiere de lo siguiente:

for each (var value in data) { 
    console.log(value); 
} 

En este ejemplo se coloca a través de los valores, por lo que sería entrar Property Name y 0. N.B .: La sintaxis for each solo es soportada principalmente en Firefox, pero no en otros navegadores.

Si los navegadores de destino apoyan ES5, o su sitio incluye es5-shim.js (recomendado), también se puede utilizar Object.keys:

var data = { Name: 'Property Name', Value: '0' }; 
console.log(Object.keys(data)); // => ["Name", "Value"] 

y el lazo con Array.prototype.forEach:

Object.keys(data).forEach(function (key) { 
    console.log(data[key]); 
}); 
// => Logs "Property Name", 0 

Answer 4

A menudo se deseará examine las propiedades particulares de una instancia de un objeto, sin todos sus métodos y propiedades prototipo compartidos:

Obj.prototype.toString= function(){ 
     var A= []; 
     for(var p in this){ 
      if(this.hasOwnProperty(p)){ 
       A[A.length]= p+'='+this[p]; 
      } 
     } 

    return A.join(', '); 
} 

Answer 5

var fs = require("fs"); 

fs.stat(process.argv[1], function(err, stats){ 
if (err) { 
    console.log(err.message); 
    return;  
} else { 
console.log(JSON.stringify(stats)); 

/* this is the answer here */ 

    for (var key in Object.keys(stats)){ 
    var t = Object.keys(stats)[key]; 
    console.log(t + " value =: " + stats[t] ); 
    } 

/* to here, run in node */ 
    } 
}); 

Answer 6

var attr, object_information=''; 

for(attr in object){ 

     //Get names and values of propertys with style (name : value) 
     object_information += attr + ' : ' + object[attr] + '\n'; 

    } 


alert(object_information); //Show all Object 

Answer 7

function getDetailedObject(inputObject) { 
    var detailedObject = {}, properties; 

    do { 
     properties = Object.getOwnPropertyNames(inputObject); 
     for (var o in properties) { 
      detailedObject[properties[o]] = inputObject[properties[o]]; 
     } 
    } while (inputObject = Object.getPrototypeOf(inputObject)); 

    return detailedObject; 
} 

Esto hará que todas las propiedades y sus valores (heredadas o propia, enumerable o no) en un nuevo objeto. el objeto original no ha sido tocado Ahora se puede atravesar un objeto nuevo usando

var obj = { 'b': '4' }; //example object 
var detailedObject = getDetailedObject(obj); 
for(var o in detailedObject) { 
    console.log('key: ' + o + ' value: ' + detailedObject[o]); 
}