展平/取消展平嵌套JSON对象的最快方法
展平/取消展平嵌套JSON对象的最快方法
提问于 2013-10-01 00:05:46
我拼凑了一些代码来扁平化和取消扁平化复杂/嵌套的JSON对象。它可以工作，但有点慢(会触发“long script”警告)。
用于我想要的扁平化名称“。作为数组的分隔符和索引。
示例：
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}我创建了一个基准测试来模拟我的用例http://jsfiddle.net/WSzec/
- 获取嵌套的JSON对象
- 将其展平
- 查看它并可能对其进行修改，同时将其恢复为原始的嵌套格式以便运走
我想要更快的代码:为了澄清，在IE 9+、FF 24+和Chrome 29+中完成JSFiddle benchmark ()的代码明显更快(~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;
}EDIT 1将上面的修改为@Bergi的实现，这是目前最快的。顺便说一句，使用".indexOf“代替"regex.exec”在FF中大约快了20%，但在Chrome中慢了20%；所以我将继续使用正则表达式，因为它更简单(这里是我用indexOf代替正则表达式http://jsfiddle.net/WSzec/2/的尝试)。
编辑2基于@Bergi的想法我设法创建了一个更快的非正则表达式版本(在FF中快3倍，在Chrome中快约10%)。http://jsfiddle.net/WSzec/6/在这个(当前)实现中，键名称的规则很简单，键不能以整数或包含句点开头。
示例：
- {"foo":{"bar":}} => {"foo.bar.0":0}
EDIT 3增加了@AaditMShah的内联路径解析方法(而不是String.split)，帮助改善了非扁平化性能，我对整体性能的提升感到非常高兴。
最新的jsfiddle和jsperf：
回答 17
Stack Overflow用户
回答已采纳
发布于 2013-10-01 02:30:34
下面是我的简短实现：
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;
}加在一起，它们的run your benchmark时间大约是一半(Opera12.16：~900ms而不是~ 1900ms，Chrome29：~800ms而不是~1600ms)。
注意：这个解决方案和这里回答的大多数其他解决方案都关注速度，容易受到prototype pollution的影响，不应用于不受信任的对象。
Stack Overflow用户
发布于 2013-10-06 11:02:20
我为flatten和unflatten对象编写了两个函数。
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));Performance
- 它比Opera中当前的解决方案更快。目前的解决方案在Opera.
- 中的速度比在火狐中的要快26%。在Firefox.
- It's中，当前的解决方案比在Chrome中的当前解决方案慢9%。目前的解决方案在Chrome中要慢29%。
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[""];
}Performance
- 它比Opera中当前的解决方案更快。目前的解决方案在Opera.
- 中比在火狐中慢5%。我在Firefox.
- It's中的解决方案比目前在Chrome中的解决方案慢26%。我的解决方案在Chrome上要慢6%。
总体而言，我的解决方案的性能与当前的解决方案一样好，甚至更好。
Performance
- 它比Opera中当前的解决方案更快。目前的解决方案在Firefox.
- It's中要慢21%。
- 它和Opera中的当前解决方案一样快，比火狐中的当前解决方案更快。目前的解决方案在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}
优势
在readability.中同时使用点符号和括号符号时，
- 展平对象的速度比当前的readability.
快，而取消展平对象的速度与当前solution.
- Flattened对象的速度一样快或更快
Disadvantages
在大多数(但不是所有)情况下，
- Unflattening对象的速度比当前解决方案慢。
当前的JSFiddle demo给出了以下值作为输出：
Nested : 132175 : 63
Flattened : 132175 : 564
Nested : 132175 : 54
Flattened : 132175 : 508我更新的JSFiddle demo给出了以下值作为输出：
Nested : 132175 : 59
Flattened : 132175 : 514
Nested : 132175 : 60
Flattened : 132175 : 451我不太确定这是什么意思，所以我将继续使用jsPerf结果。毕竟，jsPerf是一个性能基准测试实用程序。JSFiddle并非如此。
Stack Overflow用户
发布于 2018-03-01 13:02:02
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 + '.')};
}, {});
}示例：
console.log(flatten({a:[{b:["c","d"]}]}));
console.log(flatten([1,[2,[3,4],5],6]));页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接：
https://stackoverflow.com/questions/19098797
复制相关文章
相似问题
腾讯云开发者
