最简单的方法来平整/不平坦的嵌套JSON对象
我将一些代码放在一起，使复杂/嵌套的JSON对象变平和不变。 它的工作，但有点慢（触发'长脚本'的警告）。
我想要的扁平名称“。” 作为数组的分隔符和[INDEX]。
例子：
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} 我创build了一个基准，模拟我的用例http://jsfiddle.net/WSzec/
- 获取一个嵌套的JSON对象
- 压扁它
- 仔细观察，并可能修改它，同时扁平化
- 把它放回原来的嵌套格式来运走
我想要更快的代码：为了说明起见，在IE 9 +，FF 24 +和Chrome 29上完成JSFiddle基准（ http://jsfiddle.net/WSzec/ ）的代码显着更快（〜20％+会更好） +。
以下是相关的JavaScript代码：当前最快： 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; }
编辑1修改上述到@Bergi的实施，这是目前最快的。 另外，使用“.indexOf”而不是“regex.exec”，在FF中快20％左右，而Chrome则慢20％ 所以我会坚持正则expression式，因为它更简单（这里是我的尝试使用indexOf来replace正则expression式http://jsfiddle.net/WSzec/2/ ）。
编辑2基于@Bergi的想法build立我设法创造了一个更快的非正则expression式版本（FF快3倍，在Chrome中快10％）。 http://jsfiddle.net/WSzec/6/在这个（当前）实现中，键名的规则是简单的，键不能以整数开头或者包含句点。
例：
- {“foo”：{“bar”：[0]}} => {“foo.bar.0”：0}
编辑3添加@AaditMShah的内联path分析方法（而不是String.split）有助于提高unflatten性能。 我对所达到的整体performance感到非常满意。
最新的jsfiddle和jsperf：
http://jsfiddle.net/WSzec/14/
http://jsperf.com/flatten-un-flatten/4
这是我的更短的实现：
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并没有太大的变化（我不确定你是否真的需要那些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<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; }
大约一半的时间，他们运行你的基准 （Opera 12.16：〜900ms，而不是〜1900ms，Chrome 29：〜800ms，而不是〜1600ms）。
我写了两个函数来flatten和unflatten一个JSON对象。
平展一个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));
性能 ：
- 它比Opera中的当前解决scheme更快。 目前的解决scheme在Opera中速度降低了26％。
- 它比Firefox中的当前解决scheme更快。 目前的解决scheme比Firefox慢9％。
- 它比Chrome中的当前解决scheme更快。 目前的解决scheme比Chrome慢29％。
解开一个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[""]; }
性能 ：
- 它比Opera中的当前解决scheme更快。 目前的解决scheme在Opera中速度降低了5％。
- 它比Firefox中的当前解决scheme慢。 我的解决scheme比Firefox慢了26％。
- 它比Chrome中的当前解决scheme慢。 Chrome中我的解决scheme速度慢了6％。
平展和解开一个JSON对象 ：
总的来说，我的解决scheme与现有解决scheme的性能相当，甚至更好。
性能 ：
- 它比Opera中的当前解决scheme更快。 目前的解决scheme在Opera中速度降低了21％。
- 它与Firefox中的当前解决scheme一样快。
- 它比Firefox中的当前解决scheme更快。 目前的解决scheme比Chrome慢20％。
输出格式 ：
扁平对象使用对象属性的点表示法和数组索引的括号表示法：
-
{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}
在我看来这种格式比只使用点符号更好：
-
{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}
优点 ：
- 平整一个对象比当前的解决scheme更快。
- 平整和解开对象与当前的解决scheme一样快或者更快。
- 为了便于阅读，拼合对象同时使用点符号和括号符号。
缺点 ：
- 在大多数（但不是全部）情况下，解开对象比当前解决scheme慢。
当前的JSFiddle演示给出了以下值作为输出：
Nested : 132175 : 63 Flattened : 132175 : 564 Nested : 132175 : 54 Flattened : 132175 : 508
我更新的JSFiddle演示给出了以下值作为输出：
Nested : 132175 : 59 Flattened : 132175 : 514 Nested : 132175 : 60 Flattened : 132175 : 451
我不确定这是什么意思，所以我会坚持jsPerf的结果。 毕竟jsPerf是一个性能基准testing工具。 JSFiddle不是。
基于@ Bergi的代码，我做了一个简单的网页，以平整/ / unflatten。
http://fiddle.jshell.net/blowsie/S2hsS/show/light/
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; }
<link href="http://netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap.min.css" rel="stylesheet"/> <h1>JSON Flattener</h1> <div class="form-group"> <label>Mode:</label> <label class="radio-inline"> <input id="flatten" name="mode" type="radio" value="flatten" checked="">Flatten</label> <label class="radio-inline"> <input name="mode" type="radio" value="unflatten">Unflatten</label> </div> <div class="form-group"> <label>Input:</label> <input class="form-control" type="text" name="" id="input"> </div> <div class="form-group"> <label>Output:</label> <textarea class="form-control" name="" id="output" cols="30" rows="5"></textarea> </div> <button id="process" class="btn btn-primary">Process</button> <br/> <br/> <label>Formatted:</label> <pre><code id="formatted"></code></pre>
这是另一种运行比上述答案更慢（大约1000毫秒）的方法，但有一个有趣的想法:-)
而不是遍历每个属性链，它只是select最后一个属性，并使用其余的查找表来存储中间结果。 这个查找表将被迭代，直到没有属性链剩下，所有的值都驻留在uncocatenated属性上。
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; };
它目前使用表的datainput参数，并在其上放置了很多属性 – 一个非破坏性的版本也应该是可能的。 也许一个聪明的lastIndexOf用法performance比正则expression式更好（取决于正则expression式引擎）。
在这里看到它的行动 。
3年半之后…
对于我自己的项目，我想用mongoDB点符号来压扁JSON对象，并提出了一个简单的解决scheme：
/** * 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 }
特点和/或警告
- 它只接受JSON对象。 所以，如果你通过
{a: () => {}}你可能得不到你想要的东西！ - 它删除空的数组和对象。 所以这个
{a: {}, b: []}被压扁到{}。
这段代码recursion地展平JSON对象。
我在代码中包含了我的计时机制，它给了我1ms，但我不确定这是否是最准确的。
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]); }
输出：
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
你可以使用https://github.com/hughsk/flat
采取一个嵌套的JavaScript对象，并把它弄平，或用分隔的键来解开一个对象。
来自文档的示例
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 // } // } // }
我通过次要代码重构为所选答案添加了+/- 10-15％的效率，并将recursion函数移到函数名称空间之外。
看到我的问题： 是否每次调用都重新评估名称空间函数？ 为什么这会降低嵌套function。
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; }
看基准 。
这是我的。 它在Google Apps脚本中的相当大的对象上运行时间<2毫秒。 它使用破折号而不是点分隔符，而且不像处理问题那样专门处理数组，而这正是我想要的。
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; }
例：
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");
示例输出：
[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
我想添加一个新版本的flatten case（这是我需要的:)），根据我的探索与上述jsFiddler，是稍快，那么当前选定的一个。 而且，我个人认为这个片段更具可读性，这对于多开发者项目来说当然是重要的。
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; }
