Maneira mais rápida de achatar / desappend objects JSON nesteds

Eu joguei alguns códigos juntos para nivelar e não achatar objects JSON complexos / nesteds. Funciona, mas é um pouco lento (aciona o aviso de ‘script longo’).

Para os nomes achatados eu quero “.” como o delimitador e [INDEX] para matrizes.

Exemplos:

un-flattened | flattened --------------------------- {foo:{bar:false}} => {"foo.bar":false} {a:[{b:["c","d"]}]} => {"a[0].b[0]":"c","a[0].b[1]":"d"} [1,[2,[3,4],5],6] => {"[0]":1,"[1].[0]":2,"[1].[1].[0]":3,"[1].[1].[1]":4,"[1].[2]":5,"[2]":6} 

Eu criei um benchmark que ~ simula meu caso de uso http://jsfiddle.net/WSzec/

  • Obter um object JSON nested
  • Aplainar
  • Olhe através dele e, possivelmente, modifique-o enquanto achatado
  • Desencaixá-lo de volta ao formato original nested para ser enviado

Eu gostaria de um código mais rápido: para esclarecimento, o código que completa o benchmark JSFiddle ( http://jsfiddle.net/WSzec/ ) é significativamente mais rápido (~ 20% + seria bom) no IE 9+, FF 24+ e no Chrome 29 +.

Aqui está o código JavaScript relevante: Atual mais rápido: http://jsfiddle.net/WSzec/6/

 JSON.unflatten = function(data) { "use strict"; if (Object(data) !== data || Array.isArray(data)) return data; var result = {}, cur, prop, idx, last, temp; for(var p in data) { cur = result, prop = "", last = 0; do { idx = p.indexOf(".", last); temp = p.substring(last, idx !== -1 ? idx : undefined); cur = cur[prop] || (cur[prop] = (!isNaN(parseInt(temp)) ? [] : {})); prop = temp; last = idx + 1; } while(idx >= 0); cur[prop] = data[p]; } return result[""]; } JSON.flatten = function(data) { var result = {}; function recurse (cur, prop) { if (Object(cur) !== cur) { result[prop] = cur; } else if (Array.isArray(cur)) { for(var i=0, l=cur.length; i<l; i++) recurse(cur[i], prop ? prop+"."+i : ""+i); if (l == 0) result[prop] = []; } else { var isEmpty = true; for (var p in cur) { isEmpty = false; recurse(cur[p], prop ? prop+"."+p : p); } if (isEmpty) result[prop] = {}; } } recurse(data, ""); return result; } 

EDIT 1 Modificado acima para a implementação de @Bergi, que é atualmente a mais rápida. Como um aparte, usar “.indexOf” em vez de “regex.exec” é cerca de 20% mais rápido em FF, mas 20% mais lento no Chrome; então eu vou ficar com o regex já que é mais simples (aqui está minha tentativa de usar o indexOf para replace o regex http://jsfiddle.net/WSzec/2/ ).

EDIT 2 Com base na ideia da @Bergi, consegui criar uma versão mais rápida sem regex (3x mais rápida em FF e ~ 10% mais rápida no Chrome). http://jsfiddle.net/WSzec/6/ Na implementação this (atual) as regras para nomes de chaves são simples, chaves não podem iniciar com um inteiro ou conter um ponto.

Exemplo:

  • {“foo”: {“bar”: [0]}} => {“foo.bar.0”: 0}

EDIT 3 Adicionar a abordagem de análise de caminho in-line do @AaditMShah (em vez de String.split) ajudou a melhorar o desempenho não-plano. Estou muito feliz com a melhoria geral de desempenho alcançada.

O mais recente jsfiddle e jsperf:

http://jsfiddle.net/WSzec/14/

http://jsperf.com/flatten-un-flatten/4

Aqui está minha implementação muito mais curta:

 Object.unflatten = function(data) { "use strict"; if (Object(data) !== data || Array.isArray(data)) return data; var regex = /\.?([^.\[\]]+)|\[(\d+)\]/g, resultholder = {}; for (var p in data) { var cur = resultholder, prop = "", m; while (m = regex.exec(p)) { cur = cur[prop] || (cur[prop] = (m[2] ? [] : {})); prop = m[2] || m[1]; } cur[prop] = data[p]; } return resultholder[""] || resultholder; }; 

flatten não mudou muito (e eu não tenho certeza se você realmente precisa desses casos isEmpty ):

 Object.flatten = function(data) { var result = {}; function recurse (cur, prop) { if (Object(cur) !== cur) { result[prop] = cur; } else if (Array.isArray(cur)) { for(var i=0, l=cur.length; i 

Juntos, eles executam seu benchmark em aproximadamente a metade do tempo (Opera 12.16: ~ 900ms em vez de ~ 1900ms, Chrome 29: ~ 800ms em vez de ~ 1600ms).

Eu escrevi duas funções para flatten e unflatten um object JSON.


Aplainar um object JSON :

 var flatten = (function (isArray, wrapped) { return function (table) { return reduce("", {}, table); }; function reduce(path, accumulator, table) { if (isArray(table)) { var length = table.length; if (length) { var index = 0; while (index < length) { var property = path + "[" + index + "]", item = table[index++]; if (wrapped(item) !== item) accumulator[property] = item; else reduce(property, accumulator, item); } } else accumulator[path] = table; } else { var empty = true; if (path) { for (var property in table) { var item = table[property], property = path + "." + property, empty = false; if (wrapped(item) !== item) accumulator[property] = item; else reduce(property, accumulator, item); } } else { for (var property in table) { var item = table[property], empty = false; if (wrapped(item) !== item) accumulator[property] = item; else reduce(property, accumulator, item); } } if (empty) accumulator[path] = table; } return accumulator; } }(Array.isArray, Object)); 

Desempenho :

  1. É mais rápido que a solução atual no Opera. A solução atual é 26% mais lenta no Opera.
  2. É mais rápido que a solução atual no Firefox. A solução atual é 9% mais lenta no Firefox.
  3. É mais rápido que a solução atual no Chrome. A solução atual é 29% mais lenta no Chrome.

Desclassificar um object JSON :

 function unflatten(table) { var result = {}; for (var path in table) { var cursor = result, length = path.length, property = "", index = 0; while (index < length) { var char = path.charAt(index); if (char === "[") { var start = index + 1, end = path.indexOf("]", start), cursor = cursor[property] = cursor[property] || [], property = path.slice(start, end), index = end + 1; } else { var cursor = cursor[property] = cursor[property] || {}, start = char === "." ? index + 1 : index, bracket = path.indexOf("[", start), dot = path.indexOf(".", start); if (bracket < 0 && dot < 0) var end = index = length; else if (bracket < 0) var end = index = dot; else if (dot < 0) var end = index = bracket; else var end = index = bracket < dot ? bracket : dot; var property = path.slice(start, end); } } cursor[property] = table[path]; } return result[""]; } 

Desempenho :

  1. É mais rápido que a solução atual no Opera. A solução atual é 5% mais lenta no Opera.
  2. É mais lento que a solução atual no Firefox. Minha solução é 26% mais lenta no Firefox.
  3. É mais lento que a solução atual no Chrome. Minha solução é 6% mais lenta no Chrome.

Achatar e desalinhar um object JSON :

No geral, minha solução funciona igualmente bem ou até melhor que a solução atual.

Desempenho :

  1. É mais rápido que a solução atual no Opera. A solução atual é 21% mais lenta no Opera.
  2. É tão rápido quanto a solução atual no Firefox.
  3. É mais rápido que a solução atual no Firefox. A solução atual é 20% mais lenta no Chrome.

Formato de saída :

Um object nivelado usa a notação de ponto para as propriedades do object e a notação do colchete para os índices da matriz:

  1. {foo:{bar:false}} => {"foo.bar":false}
  2. {a:[{b:["c","d"]}]} => {"a[0].b[0]":"c","a[0].b[1]":"d"}
  3. [1,[2,[3,4],5],6] => {"[0]":1,"[1][0]":2,"[1][1][0]":3,"[1][1][1]":4,"[1][2]":5,"[2]":6}

Na minha opinião, este formato é melhor do que apenas usando a notação de ponto:

  1. {foo:{bar:false}} => {"foo.bar":false}
  2. {a:[{b:["c","d"]}]} => {"a.0.b.0":"c","a.0.b.1":"d"}
  3. [1,[2,[3,4],5],6] => {"0":1,"1.0":2,"1.1.0":3,"1.1.1":4,"1.2":5,"2":6}

Vantagens :

  1. Achatar um object é mais rápido que a solução atual.
  2. Achatar e desalinhar um object é tão rápido quanto ou mais rápido que a solução atual.
  3. Objetos achatados usam a notação de ponto e a notação de colchetes para facilitar a leitura.

Desvantagens :

  1. Desacelerar um object é mais lento que a solução atual na maioria dos casos (mas não em todos).

A demonstração atual do JSFiddle deu os seguintes valores como saída:

 Nested : 132175 : 63 Flattened : 132175 : 564 Nested : 132175 : 54 Flattened : 132175 : 508 

Minha demo JSFiddle atualizada deu os seguintes valores como saída:

 Nested : 132175 : 59 Flattened : 132175 : 514 Nested : 132175 : 60 Flattened : 132175 : 451 

Eu não tenho certeza do que isso significa, então eu vou ficar com os resultados do jsPerf. Afinal jsPerf é um utilitário de benchmarking de desempenho. JSFiddle não é.

Com base no código do @ Bergi, criei uma página simples para achatar o // unflatten.

http://fiddle.jshell.net/blowsie/S2hsS/show/light/

insira a descrição da imagem aqui

 JSON.flatten = function (data) { var result = {}; function recurse(cur, prop) { if (Object(cur) !== cur) { result[prop] = cur; } else if (Array.isArray(cur)) { for (var i = 0, l = cur.length; i < l; i++) recurse(cur[i], prop + "[" + i + "]"); if (l == 0) result[prop] = []; } else { var isEmpty = true; for (var p in cur) { isEmpty = false; recurse(cur[p], prop ? prop + "." + p : p); } if (isEmpty && prop) result[prop] = {}; } } recurse(data, ""); return result; }; JSON.unflatten = function (data) { "use strict"; if (Object(data) !== data || Array.isArray(data)) return data; var regex = /\.?([^.\[\]]+)|\[(\d+)\]/g, resultholder = {}; for (var p in data) { var cur = resultholder, prop = "", m; while (m = regex.exec(p)) { cur = cur[prop] || (cur[prop] = (m[2] ? [] : {})); prop = m[2] || m[1]; } cur[prop] = data[p]; } return resultholder[""] || resultholder; }; $("#process").click(function () { var flatten = $("#flatten").is(":checked"); var result = flatten ? JSON.stringify(JSON.flatten(JSON.parse($("#input").val())), null, "\t") : JSON.stringify(JSON.unflatten(JSON.parse($("#input").val())), null, "\t") $("#output").val(result); $("#formatted").text(result); }); 
 body { padding:20px; } 
  

JSON Flattener



Aqui está outra abordagem que é mais lenta (cerca de 1000ms) do que a resposta acima, mas tem uma ideia interessante 🙂

Em vez de iterar em cada cadeia de propriedade, ele seleciona a última propriedade e usa uma tabela de consulta para o restante para armazenar os resultados intermediários. Essa tabela de consulta será iterada até que não haja mais cadeias de propriedades e todos os valores residam em propriedades não consolidadas.

 JSON.unflatten = function(data) { "use strict"; if (Object(data) !== data || Array.isArray(data)) return data; var regex = /\.?([^.\[\]]+)$|\[(\d+)\]$/, props = Object.keys(data), result, p; while(p = props.shift()) { var m = regex.exec(p), target; if (m.index) { var rest = p.slice(0, m.index); if (!(rest in data)) { data[rest] = m[2] ? [] : {}; props.push(rest); } target = data[rest]; } else { target = result || (result = (m[2] ? [] : {})); } target[m[2] || m[1]] = data[p]; } return result; }; 

Ele atualmente usa o parâmetro de input de data para a tabela e coloca muitas propriedades nele – uma versão não destrutiva também deve ser possível. Talvez um uso lastIndexOf inteligente tenha um desempenho melhor que o regex (depende do mecanismo regex).

Veja isso em ação aqui .

3 ½ anos depois …

Para meu próprio projeto, eu queria nivelar objects JSON em notação de ponto mongoDB e surgiu com uma solução simples:

 /** * Recursively flattens a JSON object using dot notation. * * NOTE: input must be an object as described by JSON spec. Arbitrary * JS objects (eg {a: () => 42}) may result in unexpected output. * MOREOVER, it removes keys with empty objects/arrays as value (see * examples bellow). * * @example * // returns {a:1, 'b.0.c': 2, 'b.0.d.e': 3, 'b.1': 4} * flatten({a: 1, b: [{c: 2, d: {e: 3}}, 4]}) * // returns {a:1, 'b.0.c': 2, 'b.0.de0': true, 'b.0.de1': false, 'b.0.de2.f': 1} * flatten({a: 1, b: [{c: 2, d: {e: [true, false, {f: 1}]}}]}) * // return {a: 1} * flatten({a: 1, b: [], c: {}}) * * @param obj item to be flattened * @param {Array.string} [prefix=[]] chain of prefix joined with a dot and prepended to key * @param {Object} [current={}] result of flatten during the recursion * * @see https://docs.mongodb.com/manual/core/document/#dot-notation */ function flatten (obj, prefix, current) { prefix = prefix || [] current = current || {} // Remember kids, null is also an object! if (typeof (obj) === 'object' && obj !== null) { Object.keys(obj).forEach(key => { this.flatten(obj[key], prefix.concat(key), current) }) } else { current[prefix.join('.')] = obj } return current } 

Recursos e / ou advertências

  • Só aceita objects JSON. Então, se você passar algo como {a: () => {}} você pode não conseguir o que queria!
  • Remove matrizes e objects vazios. Então, este {a: {}, b: []} é achatado para {} .

Esse código aplaina recursivamente objects JSON.

Eu incluí meu mecanismo de temporização no código e ele me dá 1ms, mas não tenho certeza se é o mais preciso.

  var new_json = [{ "name": "fatima", "age": 25, "neighbour": { "name": "taqi", "location": "end of the street", "property": { "built in": 1990, "owned": false, "years on market": [1990, 1998, 2002, 2013], "year short listed": [], //means never } }, "town": "Mountain View", "state": "CA" }, { "name": "qianru", "age": 20, "neighbour": { "name": "joe", "location": "opposite to the park", "property": { "built in": 2011, "owned": true, "years on market": [1996, 2011], "year short listed": [], //means never } }, "town": "Pittsburgh", "state": "PA" }] function flatten(json, flattened, str_key) { for (var key in json) { if (json.hasOwnProperty(key)) { if (json[key] instanceof Object && json[key] != "") { flatten(json[key], flattened, str_key + "." + key); } else { flattened[str_key + "." + key] = json[key]; } } } } var flattened = {}; console.time('flatten'); flatten(new_json, flattened, ""); console.timeEnd('flatten'); for (var key in flattened){ console.log(key + ": " + flattened[key]); } 

Saída:

 flatten: 1ms .0.name: fatima .0.age: 25 .0.neighbour.name: taqi .0.neighbour.location: end of the street .0.neighbour.property.built in: 1990 .0.neighbour.property.owned: false .0.neighbour.property.years on market.0: 1990 .0.neighbour.property.years on market.1: 1998 .0.neighbour.property.years on market.2: 2002 .0.neighbour.property.years on market.3: 2013 .0.neighbour.property.year short listed: .0.town: Mountain View .0.state: CA .1.name: qianru .1.age: 20 .1.neighbour.name: joe .1.neighbour.location: opposite to the park .1.neighbour.property.built in: 2011 .1.neighbour.property.owned: true .1.neighbour.property.years on market.0: 1996 .1.neighbour.property.years on market.1: 2011 .1.neighbour.property.year short listed: .1.town: Pittsburgh .1.state: PA 

Você pode usar https://github.com/hughsk/flat

Pegue um object JavaScript nested e achate-o ou descompacte um object com as teclas delimitadas.

Exemplo do documento

 var flatten = require('flat') flatten({ key1: { keyA: 'valueI' }, key2: { keyB: 'valueII' }, key3: { a: { b: { c: 2 } } } }) // { // 'key1.keyA': 'valueI', // 'key2.keyB': 'valueII', // 'key3.abc': 2 // } var unflatten = require('flat').unflatten unflatten({ 'three.levels.deep': 42, 'three.levels': { nested: true } }) // { // three: { // levels: { // deep: 42, // nested: true // } // } // } 

Versão ES6:

 const flatten = (obj, path = '') => { if (!(obj instanceof Object)) return {[path.replace(/\.$/g, '')]:obj}; return Object.keys(obj).reduce((output, key) => { return obj instanceof Array ? {...output, ...flatten(obj[key], path + '[' + key + '].')}: {...output, ...flatten(obj[key], path + key + '.')}; }, {}); } 

Exemplo:

 console.log(flatten({a:[{b:["c","d"]}]})); console.log(flatten([1,[2,[3,4],5],6])); 

Eu adicionei +/- 10-15% de eficiência à resposta selecionada por refatoração de código menor e movendo a function recursiva para fora do namespace da function.

Veja minha pergunta: As funções de namespace são reavaliadas em todas as chamadas? por que isso diminui as funções aninhadas.

 function _flatten (target, obj, path) { var i, empty; if (obj.constructor === Object) { empty = true; for (i in obj) { empty = false; _flatten(target, obj[i], path ? path + '.' + i : i); } if (empty && path) { target[path] = {}; } } else if (obj.constructor === Array) { i = obj.length; if (i > 0) { while (i--) { _flatten(target, obj[i], path + '[' + i + ']'); } } else { target[path] = []; } } else { target[path] = obj; } } function flatten (data) { var result = {}; _flatten(result, data, null); return result; } 

Veja o benchmark .

Aqui é meu. Ele é executado em <2ms no Script do Google Apps em um objeto considerável. Ele usa traços em vez de pontos para separadores, e não manipula matrizes especialmente como na pergunta do autor da pergunta, mas é isso que eu queria para meu uso.

 function flatten (obj) { var newObj = {}; for (var key in obj) { if (typeof obj[key] === 'object' && obj[key] !== null) { var temp = flatten(obj[key]) for (var key2 in temp) { newObj[key+"-"+key2] = temp[key2]; } } else { newObj[key] = obj[key]; } } return newObj; } 

Exemplo:

 var test = { a: 1, b: 2, c: { c1: 3.1, c2: 3.2 }, d: 4, e: { e1: 5.1, e2: 5.2, e3: { e3a: 5.31, e3b: 5.32 }, e4: 5.4 }, f: 6 } Logger.log("start"); Logger.log(JSON.stringify(flatten(test),null,2)); Logger.log("done"); 

Exemplo de saída:

 [17-02-08 13:21:05:245 CST] start [17-02-08 13:21:05:246 CST] { "a": 1, "b": 2, "c-c1": 3.1, "c-c2": 3.2, "d": 4, "e-e1": 5.1, "e-e2": 5.2, "e-e3-e3a": 5.31, "e-e3-e3b": 5.32, "e-e4": 5.4, "f": 6 } [17-02-08 13:21:05:247 CST] done 

Eu gostaria de adicionar uma nova versão do flatten case (isto é o que eu precisava :)) que, de acordo com minhas sondas com o jsFiddler acima, é um pouco mais rápido que o atualmente selecionado. Além disso, eu pessoalmente vejo esse trecho um pouco mais legível, o que é obviamente importante para projetos com vários desenvolvedores.

 function flattenObject(graph) { let result = {}, item, key; function recurr(graph, path) { if (Array.isArray(graph)) { graph.forEach(function (itm, idx) { key = path + '[' + idx + ']'; if (itm && typeof itm === 'object') { recurr(itm, key); } else { result[key] = itm; } }); } else { Reflect.ownKeys(graph).forEach(function (p) { key = path + '.' + p; item = graph[p]; if (item && typeof item === 'object') { recurr(item, key); } else { result[key] = item; } }); } } recurr(graph, ''); return result; }