我拼凑了一些代码来扁平化和取消扁平化复杂/嵌套的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/
我想要更快的代码:为了澄清,在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/在这个(当前)实现中,键名称的规则很简单,键不能以整数或包含句点开头。
示例:
EDIT 3增加了@AaditMShah的内联路径解析方法(而不是String.split),帮助改善了非扁平化性能,我对整体性能的提升感到非常高兴。
最新的jsfiddle和jsperf:
发布于 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的影响,不应用于不受信任的对象。
发布于 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
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
总体而言,我的解决方案的性能与当前的解决方案一样好,甚至更好。
Performance
输出格式
平面化对象使用点表示法表示对象属性,使用括号表示法表示数组索引:
{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.中同时使用点符号和括号符号时,
快,而取消展平对象的速度与当前solution.
Disadvantages
在大多数(但不是所有)情况下,
当前的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并非如此。
发布于 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]));
https://stackoverflow.com/questions/19098797
复制相似问题