EDIT : Todos os exemplos abaixo nesta resposta foram editados para incluir uma nova variável de caminho produzida pelo iterador conforme a solicitação do @ supersan . A variável path é uma matriz de cadeias em que cada cadeia na matriz representa cada chave acessada para obter o valor iterado resultante do objeto de origem original. A variável path pode ser inserida na função / método get do lodash . Ou você pode escrever sua própria versão do get do lodash, que lida apenas com matrizes da seguinte forma:
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"]));
EDIT : Esta resposta editada resolve percursos de loop infinito.
Parando travessias de objetos infinitos traquinas
Esta resposta editada ainda fornece um dos benefícios adicionais da minha resposta original, que permite que você use a função de gerador fornecida para usar uma interface iterável mais limpa e simples (pense em usar for ofloops como for(var a of b)onde bé um iterável e aé um elemento do iterável ) Usando a função de gerador além de ser uma API simples que também ajuda com a reutilização de código, tornando-a assim que você não tem que repetir a lógica iteração em todos os lugares que você quer iterate profundamente sobre as propriedades do objeto e também torna possível breakfora do o loop se você gostaria de interromper a iteração anteriormente.
Uma coisa que noto que não foi abordada e que não está na minha resposta original é que você deve ter cuidado ao atravessar objetos arbitrários (ou seja, qualquer conjunto "aleatório" de)), porque os objetos JavaScript podem ser auto-referenciados. Isso cria a oportunidade de ter percursos de loop infinitos. Dados JSON não modificados, no entanto, não podem ser auto-referenciados; portanto, se você estiver usando esse subconjunto específico de objetos JS, não precisará se preocupar com percursos de loop infinito e poderá consultar minha resposta original ou outras respostas. Aqui está um exemplo de uma travessia sem fim (observe que não é um trecho de código executável, porque, caso contrário, poderia travar a guia do navegador).
Também no objeto gerador no meu exemplo editado, optei por usar, em Object.keysvez de for initerar apenas chaves não protótipo no objeto. Você pode trocar isso sozinho se quiser incluir as chaves do protótipo. Veja minha seção de resposta original abaixo para ambas as implementações com Object.keyse for in.
Pior - Isso fará um loop infinito em objetos auto-referenciais:
//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 se salvar disso, você pode adicionar um conjunto em um fechamento, para que, quando a função for chamada pela primeira vez, comece a criar uma memória dos objetos que viu e não continue a iteração depois de encontrar um objeto já visto. O trecho de código abaixo faz isso e, portanto, lida com casos de loop infinito.
Melhor - Isso não fará um loop infinito em objetos auto-referenciais:
//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);
}
Resposta original
Para uma maneira mais nova de fazer isso, se você não se importa em deixar o IE e principalmente oferecer suporte a navegadores mais atuais (verifique a tabela es6 da kangax para compatibilidade). Você pode usar os geradores es2015 para isso. Atualizei a resposta do @ TheHippo de acordo. Obviamente, se você realmente deseja suporte ao IE, pode usar o transpiler babel JavaScript.
//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);
}
Se você deseja apenas propriedades enumeráveis (basicamente propriedades de cadeia que não são protótipos), é possível alterá-lo para iterar usando Object.keysum for...ofloop:
//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);
}