Iterar a través de las propiedades del objeto

var obj = {
    name: "Simon",
    age: "20",
    clothing: {
        style: "simple",
        hipster: false
    }
}

for(var propt in obj){
    console.log(propt + ': ' + obj[propt]);
}

¿Cómo funciona la variable propt representar las propiedades del objeto? No es un método o una propiedad incorporados. ¿Por qué aparece con todas las propiedades del objeto?

preguntado el 29 de noviembre de 11 a las 10:11

if (typeof(obj[propt]) === 'object') {/* Hazlo otra vez */ } -

Bueno, realmente lo siento por esta pregunta. Sé lo que es un bucle, no pude entender "recorrer las propiedades del objeto", lo que creo que ya se borró. Además, me recomendaron "JavaScript Step by Step 2nd Edition - Steve Suehring en la escuela. -

Esta es una buena pregunta para principiantes. Agregaría que tengo 15 años de experiencia profesional con otros idiomas y necesitaba esta respuesta. Me gustaría más 2000 si pudiera. -

Es una locura, pero he estado viniendo a esta página cada pocos meses durante años para volver a aprender la sintaxis sobre cómo hacer esto. No me molesto en recordar cómo hacer esto ... Solo recuerdo que esta página siempre está aquí en SO. -

Esta es la página más extraña que he visto en StackOverflow. Si lee la pregunta con atención, solo una respuesta comienza a intentar responder lo que realmente se pregunta, y tiene una puntuación de -6. La respuesta con la puntuación más alta, que fue aceptada, no solo no responde, sino que simplemente es incorrecta. -

30 Respuestas

La iteración sobre las propiedades requiere esta hasOwnProperty comprobar:

for (var prop in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
        // do stuff
    }
}

Es necesario porque el prototipo de un objeto contiene propiedades adicionales para el objeto que técnicamente son parte del objeto. Estas propiedades adicionales se heredan de la clase de objeto base, pero siguen siendo propiedades de obj.

hasOwnProperty simplemente comprueba si se trata de una propiedad específica de esta clase y no heredada de la clase base.


También es posible llamar hasOwnProperty a través del objeto en sí:

if (obj.hasOwnProperty(prop)) {
    // do stuff
}

Pero esto fallará si el objeto tiene un campo no relacionado con el mismo nombre:

var obj = { foo: 42, hasOwnProperty: 'lol' };
obj.hasOwnProperty('foo');  // TypeError: hasOwnProperty is not a function

Por eso es más seguro llamarlo Object.prototype en lugar:

var obj = { foo: 42, hasOwnProperty: 'lol' };
Object.prototype.hasOwnProperty.call(obj, 'foo');  // true

Respondido 16 ago 19, 03:08

@BT Según el Documentación de Mozilla: "Si solo desea considerar las propiedades adjuntas al objeto en sí, y no sus prototipos, use getOwnPropertyNames o realizar una comprobación hasOwnProperty (propertyIsEnumerable también se puede utilizar). "- Davidmdem

¿Cuál es exactamente el punto de llamar object.hasOwnProperty()? ¿No es el hecho de que property tiene cualquier valor que implique que está en object? - Alex s

Porque, Alex S, el prototipo de un objeto contiene propiedades adicionales para el objeto que son técnicamente parte del objeto. Se heredan de la clase de objeto base, pero siguen siendo propiedades. hasOwnProperty simplemente comprueba si esta es una propiedad específica de esta clase y no una heredada de la clase base. Una buena explicación: brianflove.com/2013/09/05/javascripts-hasownproperty-method - kyle richter

Creo que debería mencionar, sin embargo, que Object.keys (obj) es ahora una solución mucho mejor para obtener las claves del objeto en sí. Enlace a la documentación de Mozilla: desarrollador.mozilla.org/en-US/docs/Web/JavaScript/Reference/… - kyle richter

Falta un dato importante. property es una cadena aquí, debería haber sido llamado propertyName. De lo contrario, puede causar confusión para los novatos de JS como yo, es decir, qué hacer dentro del if. - Neolisco

A partir de JavaScript 1.8.5 puede utilizar Object.keys(obj) para obtener una matriz de propiedades definidas en el objeto en sí (las que devuelven verdadero para obj.hasOwnProperty(key)).

Object.keys(obj).forEach(function(key,index) {
    // key: the name of the object key
    // index: the ordinal position of the key within the object 
});

Esto es mejor (y más legible) que usar un bucle for-in.

Es compatible con estos navegadores:

  • Firefox (Geco): 4 (2.0)
  • Cromo: 5
  • Internet Explorer: 9

Vea la Red de desarrolladores de Mozilla Object.keys ()referencia de para obtener más información.

respondido 30 mar '18, 21:03

Y si necesita soporte para navegadores antiguos, puede usar este polyfill - KyleMit

En entornos que admiten esta construcción de lenguaje, este método permite llamar a Array.foreach: Object.keys(myObject).forEach(function(key,index) { //key = the name of the object key //index = the ordinal position of the key within the object }); - Precio de Todd

@ AJ_83 No hay una buena forma de salir de un forEach (). Use some () en este caso, y regrese verdadero para romper - daniel z

¿Por qué es más legible que for-in? for candidate in candidateStatus... me parece legible - Jona

Chicas y chicos, estamos en 2019 y no tenemos tanto tiempo para escribir ... Así que hagamos este nuevo e interesante ECMAScript 2016:

Object.keys(obj).forEach(e => console.log(`key=${e}  value=${obj[e]}`));

Respondido 18 Oct 19, 09:10

¿En qué se diferencia esto de la respuesta de Danny R? - krilgar

Es un delineador único y usa map en lugar de forEach. Y también el estado console.log puede ser interesante para algunas personas. - franco roth

Satly, eso no funciona cuando obj=window.performance.memory :-/ Mientras que for in lo hace. es decir var obj = window.performance.memory; for( key in obj ) console.log( 'key=' + key + ' val=' + obj[key] ); - miguelangel007

window.performance.memory solo es compatible con Chrome y Object.keys(obj) devuelve una matriz vacía. Esto no tiene nada que ver con .map. - franco roth

En caso de que alguien no quiera reestructurar esta línea simple para hacer más de una cosa a la vez con e, He publicado esta esencia. Básicamente, es como la mayoría de las implementaciones de hash y utiliza ( (key) => (value) ) en lugar de { key => value }, pero si no ha tenido que lidiar con eso antes, podría ayudarlo a visualizarlo mejor: gist.github.com/the-nose-knows/9f06e745a56ff20519707433e28a4fa8 - kayleefrye_ondeck

Es el for...in statement (DND, Especificaciones de ECMAScript).

Puedes leerlo como " cada propiedad IN el obj objeto, asigne cada propiedad al PROPÓSITO variable a su vez ".

Respondido 17 Abr '14, 09:04

Muchas gracias, ahora lo entiendo. Me estaba golpeando la cabeza, revisando libros y Google. - Rafay

De acuerdo con @RightSaidFred, el in operador y el for declaración no están involucrados en absoluto, el for-in ambiental representa una producción gramatical por sí sola: for ( LeftHandSideExpression in Expression ), for ( var VariableDeclarationNoIn in Expression ) - Christian C. Salvado

Curiosa, esta respuesta tiene tantos votos a favor, especialmente porque estos comentarios populares parecen contradecirla. - doug molineux

¿Por qué está marcado esto como la respuesta? Es muy posible que sea el menos útil en este hilo .. - Computador

¿La respuesta menos útil? Depende de lo que creas que estaba pidiendo el OP; Cuando leí la pregunta por primera vez, parecía desconcertado sobre el mecanismo por el cual una variable puede usarse para inspeccionar las propiedades de un objeto, y cuál este La respuesta explica elocuentemente (a pesar del nombre inapropiado de 'for-in'). La pregunta "¿Por qué aparecen todas las propiedades" que veo podría implicar que el OP estaba buscando hasOwnProperty pero no lo sabe, pero creo que es más probable este era lo que el OP quería saber y ha aceptado incorrectamente una respuesta correcta a una pregunta diferente. :-) - Con baches

En implementaciones actualizadas de ES, puede utilizar Object.entries:

for (const [key, value] of Object.entries(obj)) { }

or

Object.entries(obj).forEach(([key, value]) => ...)

Si solo desea iterar sobre los valores, use Object.values:

for (const value of Object.values(obj)) { }

or

Object.values(obj).forEach(value => ...)

Respondido 29 Oct 19, 21:10

esta sería la mejor solución (object.entries ...), pero no puedo usarla. Cuando desee hacer esto varias veces y no pueda admitirlo en su marco, puede usar el polyfill en esta página: desarrollador.mozilla.org/nl/docs/Web/JavaScript/Reference/… - Mario

La tercera sugerencia es excelente si solo usa los valores de las propiedades. ¡Impresionante! - gzg

esta es la mejor respuesta, debes usar for (const [key, value] of Object.entries(obj)) { } - OzzyCheca

Es solamente un for...in círculo. Verificar la documentación en Mozilla.

Respondido 18 Feb 21, 22:02

El enlace está roto :(. - Burak

@Burak gracias por hacérmelo saber - arreglado. En el futuro, siéntase libre de sugerir una edición :) - pelota mate

if (typeof obj === 'object' && obj !== null) {
    Object.keys(obj).forEach(key => {
        console.log("\n" + key + ": " + obj[key]);
    });
}

// *** Explanation line by line ***

// Explaining the bellow line
// It checks if obj is neither null nor undefined, which means it's safe to get its keys. 
// Otherwise it will give you a "TypeError: Cannot convert undefined or null to object" if obj is null or undefined.
// NOTE 1: You can use Object.hasOwnProperty() instead of Object.keys(obj).length
// NOTE 2: No need to check if obj is an array because it will work just fine.
// NOTE 3: No need to check if obj is a string because it will not pass the if typeof obj is Object statement.
// NOTE 4: No need to check if Obj is undefined because it will not pass the if type obj is Object statement either.
if (typeof obj === 'object' && obj !== null) {

    // Explaining the bellow line
    // Just like in the previous line, this returns an array with
    // all keys in obj (because if code execution got here, it means 
    // obj has keys.) 
    // Then just invoke built-in javascript forEach() to loop
    // over each key in returned array and calls a call back function 
    // on each array element (key), using ES6 arrow function (=>)
    // Or you can just use a normal function ((key) { blah blah }).
    Object.keys(obj).forEach(key => {

        // The bellow line prints out all keys with their 
        // respective value in obj.
        // key comes from the returned array in Object.keys(obj)
        // obj[key] returns the value of key in obj
        console.log("\n" + key + ": " + obj[key]);
    });
}

Respondido el 07 de Septiembre de 21 a las 23:09

Hola, ¿podría agregar más información sobre su respuesta? - Nicolas

Hola @Nicolas, agregué una explicación línea por línea al código. Avísame si aún no está claro. Fouad Boukredine

Porque forEach omite valores vacíos, Creo que podrías deshacerte del si y simplemente hacer Object.keys(obj).forEach(e => console.log(`key=${e} value=${obj[e]}`)); como la respuesta de Frank Roth. - Producto oscuro

Si su entorno es compatible ES2017 entonces lo recomendaria Entradas de objeto:

Object.entries(obj).forEach(([key, value]) => {
  console.log(`${key} ${value}`);
});

Como se muestra en Entradas de Objeto de Mozillas () documentación:

La Object.entries () El método devuelve una matriz de pares de propiedades [clave, valor] enumerables de un objeto dado, en el mismo orden que el proporcionado por un bucle for ... in (la diferencia es que un bucle for-in enumera las propiedades en la cadena del prototipo como bien).

Básicamente, con Object.entries podemos renunciar al siguiente paso adicional que se requiere con los para ... en bucle:

// This step is not necessary with Object.entries
if (object.hasOwnProperty(property)) {
  // do stuff
}

Respondido 07 Oct 17, 22:10

Dominik's La respuesta es perfecta, prefiero hacerlo de esa manera, ya que es más limpio de leer:

for (var property in obj) {
    if (!obj.hasOwnProperty(property)) continue;

    // Do stuff...
}

Respondido el 28 de enero de 21 a las 08:01

Debieran ser Object con mayúscula o, ¿no? - Jonathan

@Jonathan Tenga en cuenta que es el object variable en la primera línea. - shrekuu

He actualizado el código para evitar confusiones;) - cirilo n

jquery te permite hacer esto ahora:

$.each( obj, function( key, value ) {
  alert( key + ": " + value );
});

respondido 29 mar '16, 16:03

$.each({foo:1, length:0, bar:2}, function(k,v){console.log(k,v)}) $. cada uno es no adecuado para objetos. Si un objeto tiene una propiedad de longitud y su valor es cero, todo el objeto se trata como si fuera una matriz vacía. - bob stein

Beneficios por qué creo que esto es un enfoque que invita a errores. - bob stein

El bucle for ... in representa cada propiedad de un objeto porque es como un bucle for. Definió propt en el bucle for ... in haciendo:

    for(var propt in obj){
alert(propt + ': ' + obj[propt]);
}

Un bucle for ... in recorre las propiedades enumerables de un objeto. Cualquiera que sea la variable que defina, o coloque en el bucle for ... in, cambia cada vez que pasa a la siguiente propiedad que itera. La variable en el bucle for ... in itera a través de las claves, pero su valor es el valor de la clave. Por ejemplo:

    for(var propt in obj) {
      console.log(propt);//logs name
      console.log(obj[propt]);//logs "Simon"
    }

Puede ver en qué se diferencia la variable del valor de la variable. Por el contrario, un bucle for ... of hace lo contrario.

Espero que esto ayude.

Respondido el 24 de enero de 16 a las 03:01

Las respuestas anteriores son un poco molestas porque no explican lo que hace dentro del bucle for después de asegurarse de que es un objeto: ¡NO ACCEDE A ELLO DIRECTAMENTE! En realidad, solo se le entrega la CLAVE que necesita para aplicar al OBJ:

var obj = {
  a: "foo",
  b: "bar",
  c: "foobar"
};

// We need to iterate the string keys (not the objects)
for(var someKey in obj)
{
  // We check if this key exists in the obj
  if (obj.hasOwnProperty(someKey))
  {
    // someKey is only the KEY (string)! Use it to get the obj:
    var myActualPropFromObj = obj[someKey]; // Since dynamic, use [] since the key isn't literally named "someKey"

    // NOW you can treat it like an obj
    var shouldBeBar = myActualPropFromObj.b;
  }
}

Todo esto es seguro para ECMA5. Incluso funciona en las versiones poco convincentes de JS como Rhino;)

Respondido 27 Feb 18, 16:02

shouldBeBar no está definido para las tres iteraciones. - Antonio Hatchkins

undefined es imposible ya que, bueno, está claramente definido frente a ti :) Esto se deduce de 2 posibilidades: (1) ¿Estás buscando shouldBeBar FUERA del bloque if ()? Entonces sí, estará indefinido (fuera de alcance). O (2) ¿Escribiste el nombre de var? - dylanh724

Para agregar el uso de ES2015 de Reflect.ownKeys(obj) y también iterando sobre las propiedades a través de un iterador.

Por ejemplo:

let obj = { a: 'Carrot', b: 'Potato', Car: { doors: 4 } };

puede ser iterado por

// logs each key
Reflect.ownKeys(obj).forEach(key => console.log(key));

Si desea iterar directamente sobre los valores de las claves de un objeto, puede definir un iterator, al igual que los iteradores predeterminados de JavaScipts para cadenas, matrices, matrices escritas, Map y Set.

JS intentará iterar a través de la propiedad del iterador predeterminada, que debe definirse como Symbol.iterator.

Si desea poder iterar sobre todos los objetos, puede agregarlo como un prototipo de Objeto:

Object.prototype[Symbol.iterator] = function*() { 
    for(p of Reflect.ownKeys(this)){ yield this[p]; }
}

Esto le permitiría iterar sobre los valores de un objeto con un bucle for ... of, por ejemplo:

for(val of obj) { console.log('Value is:' + val ) }

Precaución: Al momento de escribir esta respuesta (junio de 2018), todos los demás navegadores, excepto IE, admiten generadores y for...of iteración a través de Symbol.iterator

Respondido el 28 de junio de 18 a las 13:06

Aunque en realidad no está respondiendo a la pregunta del OP, esto fue muy útil para mí, todavía no sabía sobre Reflect. - Michiel

let obj = {"a": 3, "b": 2, "6": "a"}

Object.keys(obj).forEach((item) => {console.log("item", obj[item])})

// a
// 3
// 2

Respondido 28 Abr '21, 15:04

Como se mencionó en otros comentarios, forEach es más apropiado aquí, ya que map tiene la intención de devolver una nueva matriz con los resultados de llamar al bloque de código en cada iteración. Pero solo nos interesan los efectos secundarios de cada iteración, no el valor de retorno, por lo tanto, no necesitamos esa nueva matriz que map Nos da. - Danny

Puedes usar Lodash. La documentación

var obj = {a: 1, b: 2, c: 3};
_.keys(obj).forEach(function (key) {
    ...
});

respondido 01 mar '17, 02:03

¿Por qué diablos esta "respuesta" tiene 10 votos a favor? No responde por completo a la pregunta. Estoy empezando a perder la fe en la inteligencia del desarrollador de JS promedio. - desarrolladorbmw

@developerbmw Entiendo que usar las funciones de ES6 es más correcto, pero respondí hace un año. Por favor, comparta sus pensamientos con nosotros cuando tenga un minuto. - viktarpunko

La idea es centrarse más en los métodos nativos, en lugar de sugerir al usuario que agregue una biblioteca de 10000 líneas a su página. No me malinterpretes, me gusta usar Lodash pero hay un momento y un lugar para ello y no es este. - usuario9016207

@ user9016207 esta respuesta es de 2016, y era más aplicable entonces, especialmente si ya estaba usando lodash. hoy en día, si necesita fns individuales de lodash, puede obtenerlos uno a la vez, por ejemplo npmjs.com/package/lodash.keys - Brian Burns,

Puede acceder a las propiedades anidadas del objeto utilizando el for...in y forEach lazo.

para ... en:

for (const key in info) {
    console.log(info[key]);
}

para cada:

Object.keys(info).forEach(function(prop) {
    console.log(info[prop]);
    // cities: Array[3], continent: "North America", images: Array[3], name: "Canada"
    // "prop" is the property name
    // "data[prop]" is the property value
});

Respondido 20 Abr '21, 07:04

Object.keys(obj).forEach(key =>
  console.log(`key=${key} value=${obj[key]}`)
);

Respondido 25 Abr '18, 12:04

Hoy en día, puede convertir un objeto JS estándar en un objeto iterable simplemente agregando un método Symbol.iterator. Entonces puedes usar un for of bucle y acceda a sus valores directamente o incluso puede usar un operador de propagación en el objeto también. Frio. Veamos cómo podemos hacerlo:

var o = {a:1,b:2,c:3},
    a = [];
o[Symbol.iterator] = function*(){
                       var ok = Object.keys(this);
                            i = 0;
                       while (i < ok.length) yield this[ok[i++]];
                     };
for (var value of o) console.log(value);
// or you can even do like
a = [...o];
console.log(a);

respondido 20 nov., 16:03

Una forma interesante de hacer eso. Gracias por la function* ¡descubrimiento! - Benj

Buena, incluso puedes usar métodos, ¡si las propiedades también son objetos! - Dmitry

Tus for El bucle está iterando sobre todas las propiedades del objeto. obj. propt se define en la primera línea de su bucle for. Es una cadena que es un nombre de una propiedad del obj objeto. En la primera iteración del bucle, propt sería "nombre".

respondido 29 nov., 11:14

Los objetos en JavaScript son colecciones de propiedades y, por lo tanto, se pueden colocar en bucle para cada declaración.

Deberías pensar en obj como una colección de valores clave.

respondido 29 nov., 11:14

! con la importante diferencia de que estas 'listas de propiedades' pueden tener nombres como claves, mientras que las matrices JS normales solo pueden tener números como claves. - Qqwy

Si corres Nodo Yo lo recomiendo:

Object.keys(obj).forEach((key, index) => {
    console.log(key);
});

Respondido 11 ago 17, 05:08

Si bien la respuesta mejor calificada es correcta, aquí hay un caso de uso alternativo, es decir, si está iterando sobre un objeto y desea crear una matriz al final. Usar .map en lugar de forEach

const newObj = Object.keys(obj).map(el => {
    //ell will hold keys 
   // Getting the value of the keys should be as simple as obj[el]
})

Respondido el 30 de Septiembre de 19 a las 11:09

Quiero agregar a las respuestas anteriores, porque es posible que tenga intenciones diferentes a las de Javascript. Un objeto JSON y un objeto Javascript son cosas diferentes, y es posible que desee iterar a través de las propiedades de un objeto JSON utilizando las soluciones propuestas anteriormente y luego sorprenderse.

Suponga que tiene un objeto JSON como:

var example = {
    "prop1": "value1",
    "prop2": [ "value2_0", value2_1"],
    "prop3": {
         "prop3_1": "value3_1"
    }
}

La forma incorrecta de iterar a través de sus 'propiedades':

function recursivelyIterateProperties(jsonObject) {
    for (var prop in Object.keys(example)) {
        console.log(prop);
        recursivelyIterateProperties(jsonObject[prop]);
    }
}

Es posible que se sorprenda al ver el registro de la consola 0, 1, etc. al iterar a través de las propiedades de prop1 y prop2 y de prop3_1. Esos objetos son secuencias y los índices de una secuencia son propiedades de ese objeto en Javascript.

Una mejor manera de iterar de forma recursiva a través de las propiedades de un objeto JSON sería comprobar primero si ese objeto es una secuencia o no:

function recursivelyIterateProperties(jsonObject) {
    for (var prop in Object.keys(example)) {
        console.log(prop);
        if (!(typeof(jsonObject[prop]) === 'string')
            && !(jsonObject[prop] instanceof Array)) {
                recursivelyIterateProperties(jsonObject[prop]);

            }

     }
}

Respondido el 28 de enero de 16 a las 20:01

También agregando la forma recursiva:

function iterate(obj) {
    // watch for objects we've already iterated so we won't end in endless cycle
    // for cases like var foo = {}; foo.bar = foo; iterate(foo);
    var walked = [];
    var stack = [{obj: obj, stack: ''}];
    while(stack.length > 0)
    {
        var item = stack.pop();
        var obj = item.obj;
        for (var property in obj) {
            if (obj.hasOwnProperty(property)) {
                if (typeof obj[property] == "object") {
                  // check if we haven't iterated through the reference yet
                  var alreadyFound = false;
                  for(var i = 0; i < walked.length; i++)
                  {
                    if (walked[i] === obj[property])
                    {
                      alreadyFound = true;
                      break;
                    }
                  }
                  // new object reference
                  if (!alreadyFound)
                  {
                    walked.push(obj[property]);
                    stack.push({obj: obj[property], stack: item.stack + '.' + property});
                  }
                }
                else
                {
                    console.log(item.stack + '.' + property + "=" + obj[property]);
                }
            }
        }
    }
}

Uso:

iterate({ foo: "foo", bar: { foo: "foo"} }); 

Respondido 22 Feb 16, 08:02

@faiz: vea mis comentarios, es una protección contra quedarse atascado en un bucle sin fin cuando camina de forma recurrente a través de un objeto que tiene referencias cíclicas - Ondrej Svejdar

Lo que hace el bucle for..in es que crea una nueva variable (var someVariable) y luego almacena cada propiedad del objeto dado en esta nueva variable (someVariable) una por una. Por lo tanto, si usa el bloque {}, puede iterar. Considere el siguiente ejemplo.

var obj = {
     name:'raman',
     hobby:'coding',
     planet:'earth'
     };

for(var someVariable in obj) {
  //do nothing..
}

console.log(someVariable); // outputs planet

respondido 29 mar '15, 09:03

Votando esto, dada su simplicidad. En mi caso de uso, necesito verificar todos los atributos en un objeto en busca de valores dudosos: NaN, nulos, indefinidos (eran puntos en un gráfico y estos valores impedían que se dibujara el gráfico). Para obtener el valor en lugar del nombre, en el bucle simplemente haría obj[someVariable]. Quizás la razón por la que se votó en contra es porque no es recursivo. Por lo tanto, esta no sería una solución adecuada si tiene un objeto muy estructurado. - catalina osborne

@KatharineOsborne o quizás es porque la siguiente frase es un poco críptica: "Por lo tanto, si usas el bloque {}, puedes iterar". El código dice más que el texto. - bvdb

Aquí estoy iterando cada nodo y creando nombres de nodo significativos. Si observa, instanceOf Array y instanceOf Object prácticamente hacen lo mismo (en mi aplicación, sin embargo, estoy dando una lógica diferente)

function iterate(obj,parent_node) {
    parent_node = parent_node || '';
    for (var property in obj) {
        if (obj.hasOwnProperty(property)) {
            var node = parent_node + "/" + property;
            if(obj[property] instanceof Array) {
                //console.log('array: ' + node + ":" + obj[property]);
                iterate(obj[property],node)
            } else if(obj[property] instanceof Object){
                //console.log('Object: ' + node + ":" + obj[property]);
                iterate(obj[property],node)
            }
            else {
                console.log(node + ":" + obj[property]);
            }
        }
    }
}

nota: me inspira la respuesta de Ondrej Svejdar. Pero esta solución tiene un mejor rendimiento y menos ambigua

Respondido 21 Feb 16, 16:02

Básicamente, desea recorrer cada propiedad del objeto.

JSFiddle

var Dictionary = {
  If: {
    you: {
      can: '',
      make: ''
    },
    sense: ''
  },
  of: {
    the: {
      sentence: {
        it: '',
        worked: ''
      }
    }
  }
};

function Iterate(obj) {
  for (prop in obj) {
    if (obj.hasOwnProperty(prop) && isNaN(prop)) {
      console.log(prop + ': ' + obj[prop]);
      Iterate(obj[prop]);
    }
  }
}
Iterate(Dictionary);

Respondido el 23 de junio de 16 a las 23:06

Para refinar aún más la respuesta aceptada, vale la pena señalar que si crea una instancia del objeto con un var object = Object.create(null) luego object.hasOwnProperty(property) activará un TypeError. Entonces, para estar seguro, necesitaría llamarlo desde el prototipo de esta manera:

for (var property in object) {
    if (Object.prototype.hasOwnProperty.call(object, property)) {
        // do stuff
    }
}

Respondido 29 ago 17, 08:08

Tipo de cheque

Puede comprobar cómo representan las propiedades del objeto mediante

typeof propt

para descubrir que es solo una cadena (nombre de la propiedad). Se le ocurrieron todas las propiedades en el objeto debido a la forma de cómo for-in js funciona el bucle "incorporado".

var obj = {
    name: "Simon",
    age: "20",
    clothing: {
        style: "simple",
        hipster: false
    }
}

for(var propt in obj){
    console.log(typeof propt,  propt + ': ' + obj[propt]);
}

Respondido el 26 de junio de 20 a las 19:06

Si solo desea iterar para asignar valores de propiedad, lodash tiene _.mapValues

const obj = {
  a: 2,
  b: 3
}
const res = _.mapValues(obj, v => v * 2)
console.log(res)
<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>

Respondido 30 Jul 21, 00:07

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.