EDITAR : Todos los ejemplos a continuación en esta respuesta se han editado para incluir una nueva variable de ruta producida por el iterador según la solicitud de @ supersan . La variable de ruta es una matriz de cadenas donde cada cadena en la matriz representa cada clave a la que se accedió para obtener el valor iterado resultante del objeto fuente original. La variable de ruta se puede alimentar a la función / método get de lodash . O podría escribir su propia versión de lodash get que maneja solo matrices de esta manera:
function get (object, path) {
return path.reduce((obj, pathItem) => obj ? obj[pathItem] : undefined, object);
}
const example = {a: [1,2,3], b: 4, c: { d: ["foo"] }};
// these paths exist on the object
console.log(get(example, ["a", "0"]));
console.log(get(example, ["c", "d", "0"]));
console.log(get(example, ["b"]));
// these paths do not exist on the object
console.log(get(example, ["e", "f", "g"]));
console.log(get(example, ["b", "f", "g"]));
EDITAR : Esta respuesta editada resuelve recorridos en bucle infinito.
Detener molestos recorridos de objetos infinitos
Esta respuesta editada aún proporciona uno de los beneficios adicionales de mi respuesta original, que le permite usar la función de generador proporcionada para usar una interfaz iterativa más limpia y simple (piense en usar for ofbucles como en for(var a of b)donde bes iterable y aes un elemento del iterable). ) Al usar la función de generador, además de ser una API más simple, también ayuda con la reutilización del código al hacer que no tenga que repetir la lógica de iteración en todas partes donde desee iterar profundamente en las propiedades de un objeto y también hace posiblebreak salir de el bucle si desea detener la iteración antes.
Una cosa que noté que no se ha abordado y que no está en mi respuesta original es que debe tener cuidado al atravesar objetos arbitrarios (es decir, cualquier conjunto "aleatorio"), porque los objetos JavaScript pueden ser auto-referenciados. Esto crea la oportunidad de tener recorridos en bucle infinito. Sin embargo, los datos JSON no modificados no pueden ser auto-referenciados, por lo que si está utilizando este subconjunto particular de objetos JS, no tiene que preocuparse por los recorridos de bucle infinito y puede consultar mi respuesta original u otras respuestas. Aquí hay un ejemplo de un recorrido sin fin (tenga en cuenta que no es un código ejecutable, porque de lo contrario se bloquearía la pestaña del navegador).
También en el objeto generador en mi ejemplo editado, opté por usar en Object.keyslugar de for inque itera solo claves no prototipo en el objeto. Puede cambiar esto usted mismo si desea que se incluyan las claves prototipo. Vea mi sección de respuestas original a continuación para ambas implementaciones con Object.keysy for in.
Peor: esto hará un bucle infinito en objetos autorreferenciales:
//your object
var o = {
foo:"bar",
arr:[1,2,3],
subo: {
foo2:"bar2"
}
};
// this self-referential property assignment is the only edited line
// from the below original example which makes the traversal
// non-terminating (i.e. it makes it infinite loop)
o.o = o;
function* traverse(o, path=[]) {
for (var i of Object.keys(o)) {
const itemPath = path.concat(i);
yield [i,o[i],itemPath];
if (o[i] !== null && typeof(o[i])=="object") {
//going one step down in the object tree!!
yield* traverse(o[I], itemPath);
}
}
}
//that's all... no magic, no bloated framework
for(var [key, value, path] of traverse(o)) {
// do something here with each key and value
console.log(key, value, path);
}
Para salvarse de esto, puede agregar un conjunto dentro de un cierre, de modo que cuando se llama a la función por primera vez, comience a construir una memoria de los objetos que ha visto y no continúe la iteración una vez que se encuentre con un objeto ya visto. El siguiente fragmento de código hace eso y, por lo tanto, maneja casos de bucle infinito.
Mejor: este no será un bucle infinito en objetos autorreferenciales:
//your object
var o = {
foo:"bar",
arr:[1,2,3],
subo: {
foo2:"bar2"
}
};
// this self-referential property assignment is the only edited line
// from the below original example which makes more naive traversals
// non-terminating (i.e. it makes it infinite loop)
o.o = o;
function* traverse(o) {
const memory = new Set();
function * innerTraversal (o, path=[]) {
if(memory.has(o)) {
// we've seen this object before don't iterate it
return;
}
// add the new object to our memory.
memory.add(o);
for (var i of Object.keys(o)) {
const itemPath = path.concat(i);
yield [i,o[i],itemPath];
if (o[i] !== null && typeof(o[i])=="object") {
//going one step down in the object tree!!
yield* innerTraversal(o[i], itemPath);
}
}
}
yield* innerTraversal(o);
}
console.log(o);
//that's all... no magic, no bloated framework
for(var [key, value, path] of traverse(o)) {
// do something here with each key and value
console.log(key, value, path);
}
Respuesta original
Para obtener una forma más nueva de hacerlo si no le importa descartar IE y admitir principalmente navegadores más actuales (consulte la tabla es6 de kangax para ver la compatibilidad). Puede usar generadores es2015 para esto. He actualizado la respuesta de @ TheHippo en consecuencia. Por supuesto, si realmente desea el soporte de IE, puede usar el transpilador JavaScript de babel .
//your object
var o = {
foo:"bar",
arr:[1,2,3],
subo: {
foo2:"bar2"
}
};
function* traverse(o, path=[]) {
for (var i in o) {
const itemPath = path.concat(i);
yield [i,o[i],itemPath];
if (o[i] !== null && typeof(o[i])=="object") {
//going one step down in the object tree!!
yield* traverse(o[i], itemPath);
}
}
}
//that's all... no magic, no bloated framework
for(var [key, value, path] of traverse(o)) {
// do something here with each key and value
console.log(key, value, path);
}
Si solo desea propiedades propias enumerables (básicamente propiedades de cadena no prototipo), puede cambiarlo para iterar usando Object.keysy un for...ofbucle en su lugar:
//your object
var o = {
foo:"bar",
arr:[1,2,3],
subo: {
foo2:"bar2"
}
};
function* traverse(o,path=[]) {
for (var i of Object.keys(o)) {
const itemPath = path.concat(i);
yield [i,o[i],itemPath];
if (o[i] !== null && typeof(o[i])=="object") {
//going one step down in the object tree!!
yield* traverse(o[i],itemPath);
}
}
}
//that's all... no magic, no bloated framework
for(var [key, value, path] of traverse(o)) {
// do something here with each key and value
console.log(key, value, path);
}