Il modo più veloce per appiattire / smontare gli oggetti JSON nidificati

Ho gettato del codice insieme per appiattire e disassemblare gli oggetti JSON complessi / nidificati. Funziona, ma è un po ‘lento (triggers l’avviso’ script lungo ‘).

Per i nomi appiattiti che voglio “.” come delimitatore e [INDICE] per gli array.

Esempi:

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} 

Ho creato un punto di riferimento che simula il mio caso d’uso http://jsfiddle.net/WSzec/

  • Ottieni un object JSON nidificato
  • Appiattiscilo
  • Guardare attraverso di esso e possibilmente modificarlo mentre appiattito
  • Svincolarlo nel suo formato annidato originale per essere spedito via

Gradirei codice più veloce: per chiarimenti, codice che completa il benchmark JSFiddle ( http://jsfiddle.net/WSzec/ ) significativamente più veloce (~ 20% + sarebbe bello) in IE 9+, FF 24+ e Chrome 29 +.

Ecco il codice JavaScript pertinente: Current Fastest: 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; } 

MODIFICA 1 Modificato quanto sopra per l’implementazione di @Bergi che è attualmente la più veloce. Per inciso, utilizzare “.indexOf” invece di “regex.exec” è circa il 20% più veloce in FF ma il 20% più lento in Chrome; quindi rimarrò con la regex poiché è più semplice (ecco il mio tentativo di usare indexOf per sostituire la regex http://jsfiddle.net/WSzec/2/ ).

EDIT 2 Basandosi sull’idea di @Bergi sono riuscito a creare una versione non regex più veloce (3 volte più veloce in FF e ~ 10% più veloce in Chrome). http://jsfiddle.net/WSzec/6/ In questa (l’attuale) implementazione le regole per i nomi delle chiavi sono semplicemente, le chiavi non possono iniziare con un numero intero o contenere un punto.

Esempio:

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

EDIT 3 Aggiunta dell’approccio di analisi dei percorsi inline di @AaditMShah (piuttosto che String.split) ha contribuito a migliorare le prestazioni di non deflazione. Sono molto contento del miglioramento complessivo delle prestazioni raggiunto.

L’ultimo jsfiddle e jsperf:

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

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

Ecco la mia implementazione molto più breve:

 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 non è cambiato molto (e non sono sicuro che tu abbia davvero bisogno di questi casi 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 

Insieme, gestiscono il benchmark in circa la metà del tempo (Opera 12.16: ~ 900 ms anziché ~ 1900 ms, Chrome 29: ~ 800 ms invece di ~ 1600 ms).

Ho scritto due funzioni per flatten e unflatten un object JSON.


Appiattisci un 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)); 

Prestazioni :

  1. È più veloce della soluzione corrente in Opera. La soluzione attuale è del 26% più lenta in Opera.
  2. È più veloce della soluzione corrente in Firefox. La soluzione attuale è il 9% più lenta in Firefox.
  3. È più veloce della soluzione corrente in Chrome. La soluzione attuale è del 29% più lenta in Chrome.

Sblocca un 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[""]; } 

Prestazioni :

  1. È più veloce della soluzione corrente in Opera. La soluzione attuale è del 5% più lenta in Opera.
  2. È più lento dell'attuale soluzione in Firefox. La mia soluzione è il 26% più lenta in Firefox.
  3. È più lento della soluzione corrente in Chrome. La mia soluzione è il 6% più lenta in Chrome.

Appiattisci e svita un object JSON :

Nel complesso, la mia soluzione funziona altrettanto bene o addirittura meglio della soluzione attuale.

Prestazioni :

  1. È più veloce della soluzione corrente in Opera. La soluzione attuale è del 21% più lenta in Opera.
  2. È veloce come la soluzione corrente in Firefox.
  3. È più veloce della soluzione corrente in Firefox. La soluzione attuale è il 20% più lenta in Chrome.

Formato di uscita :

Un object appiattito utilizza la notazione dot per le proprietà dell'object e la notazione parentesi per gli indici array:

  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}

A mio parere, questo formato è migliore rispetto all'uso della notazione a punti:

  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}

Vantaggi :

  1. Appiattire un object è più veloce della soluzione corrente.
  2. Appiattire e sbloccare un object è veloce come o più veloce della soluzione corrente.
  3. Gli oggetti appiattiti utilizzano sia la notazione a punti sia la notazione delle parentesi per la leggibilità.

Svantaggi :

  1. L'annullamento della stabilizzazione di un object è più lento della soluzione corrente nella maggior parte (ma non in tutti) dei casi.

L'attuale demo di JSFiddle ha fornito i seguenti valori come output:

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

La mia demo JSFiddle aggiornata ha fornito i seguenti valori come output:

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

Non sono sicuro di cosa significhi, quindi mi limiterò ai risultati di jsPerf. Dopotutto jsPerf è un'utilità di benchmarking delle prestazioni. JSFiddle non lo è.

Sulla base del codice di @ Bergi ho creato una semplice pagina web per appiattire // unflatten.

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

inserisci la descrizione dell'immagine qui

 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



Ecco un altro approccio che gira più lentamente (circa 1000 ms) rispetto alla risposta sopra, ma ha un’idea interessante 🙂

Invece di scorrere attraverso ciascuna catena di proprietà, seleziona l’ultima proprietà e usa una tabella di ricerca per il resto per memorizzare i risultati intermedi. Questa tabella di ricerca verrà iterata fino a quando non saranno rimaste catene di proprietà e tutti i valori risiedono su proprietà non codificate.

 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; }; 

Attualmente usa il parametro di input dei data per la tabella e mette molte proprietà su di esso – dovrebbe essere ansible anche una versione non distruttiva. Forse un uso intelligente di lastIndexOf è migliore della regex (dipende dal motore regex).

Guardalo in azione qui .

3 anni e mezzo dopo …

Per il mio progetto ho voluto appiattire gli oggetti JSON nella notazione mongoDB dot e ho trovato una soluzione semplice:

 /** * 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 } 

Caratteristiche e / o avvertimenti

  • Accetta solo oggetti JSON. Quindi se passi qualcosa come {a: () => {}} potresti non ottenere ciò che volevi!
  • Rimuove gli array e gli oggetti vuoti. Quindi questo {a: {}, b: []} è appiattito su {} .

Questo codice appiattisce in modo ricorsivo gli oggetti JSON.

Ho incluso il mio meccanismo di temporizzazione nel codice e mi dà 1ms ma non sono sicuro se quello è il più 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]); } 

Produzione:

 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 

È ansible utilizzare https://github.com/hughsk/flat

Prendi un object Javascript annidato e appiattiscilo o svita un object con le chiavi delimitate.

Esempio dal doc

 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 // } // } // } 

Versione 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 + '.')}; }, {}); } 

Esempio:

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

Ho aggiunto un’efficienza del +/- 10-15% alla risposta selezionata mediante il refactoring del codice minore e lo spostamento della funzione ricorsiva al di fuori del namespace della funzione.

Vedi la mia domanda: le funzioni dei nomi sono rivalutate ad ogni chiamata? perché questo rallenta le funzioni annidate.

 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; } 

Vedi benchmark .

Ecco il mio Funziona in <2ms nello script di Google Apps su un oggetto di dimensioni considerevoli. Usa trattini invece di punti per i separatori e non gestisce gli array in modo particolare come nella domanda del richiedente, ma questo è ciò che volevo per il mio 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; } 

Esempio:

 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"); 

Esempio di output:

 [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 

Mi piacerebbe aggiungere una nuova versione di case flatten (questo è quello che mi serviva :)) che, secondo le mie sonde con il jsFiddler sopra, è leggermente più veloce di quella attualmente selezionata. Inoltre, personalmente considero questo frammento un po ‘più leggibile, il che è ovviamente importante per i progetti multi-sviluppatore.

 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; }