我有一个大对象，我想转换为JSON并发送。但它具有圆形结构。我想抛出任何存在的循环引用并发送任何可以进行字符串化的内容。我该怎么做？
感谢。
var obj = {
a: "foo",
b: obj
}
我想将obj字符串化为：
{"a":"foo"}
答案 0 :(得分：543)
在Node.js中，您可以使用util.inspect(object)。它会自动用“[Circular]”替换循环链接。
虽然内置（无需安装），但您必须将其导入
import * as util from 'util' // has no default export
import { inspect } from 'util' // or directly
// or
var util = require('util')
console.log(util.inspect(myObject))
另请注意，您可以传递选项对象以检查（请参阅上面的链接）
inspect(myObject[, options: {showHidden, depth, colors, showProxy, ...moreOptions}])
请阅读下面的评论者并给予赞誉......
答案 1 :(得分：488)
将JSON.stringify与自定义替换程序一起使用。例如：
// Demo: Circular reference
var o = {};
o.o = o;
// Note: cache should not be re-used by repeated calls to JSON.stringify.
var cache = [];
JSON.stringify(o, function(key, value) {
if (typeof value === 'object' && value !== null) {
if (cache.indexOf(value) !== -1) {
// Duplicate reference found
try {
// If this value does not reference a parent it can be deduped
return JSON.parse(JSON.stringify(value));
} catch (error) {
// discard key if value cannot be deduped
return;
}
}
// Store value in our collection
cache.push(value);
}
return value;
});
cache = null; // Enable garbage collection
此示例中的替换程序不是100％正确（取决于您对“重复”的定义）。在以下情况中，将丢弃一个值：
var a = {b:1}
var o = {};
o.one = a;
o.two = a;
// one and two point to the same object, but two is discarded:
JSON.stringify(o, ...);
但概念是：使用自定义替换器，并跟踪解析的对象值。
答案 2 :(得分：63)
我想知道为什么还没有人发布proper solution from MDN page ...
const getCircularReplacer = () => {
const seen = new WeakSet();
return (key, value) => {
if (typeof value === "object" && value !== null) {
if (seen.has(value)) {
return;
}
seen.add(value);
}
return value;
};
};
JSON.stringify(circularReference, getCircularReplacer());
可见值应存储在一个 中，而不是存储在数组中（而不是在数组中存储（替换元素在每个元素上被称为 ）），并且无需尝试JSON.stringify < em>链中的每个元素会导致循环引用。
就像接受的答案一样，此解决方案会删除所有重复值，而不只是循环值。但是至少它没有指数复杂性。
答案 3 :(得分：61)
只是做
npm i --save circular-json
然后在你的js文件中
const JSON = require('circular-json');
...
const json = JSON.stringify(obj);
您也可以
const CircularJSON = require('circular-json');
https://github.com/WebReflection/circular-json
注意：我与此软件包无关。但我确实用它。
答案 4 :(得分：47)
我真的很喜欢Trindaz的解决方案 - 更详细，但它有一些错误。我把它们固定在喜欢它的人身上。
另外，我在缓存对象上添加了长度限制。
如果我打印的对象非常大 - 我的意思是无限大 - 我想限制我的算法。
JSON.stringifyOnce = function(obj, replacer, indent){
var printedObjects = [];
var printedObjectKeys = [];
function printOnceReplacer(key, value){
if ( printedObjects.length > 2000){ // browsers will not print more than 20K, I don't see the point to allow 2K.. algorithm will not be fast anyway if we have too many objects
return 'object too long';
}
var printedObjIndex = false;
printedObjects.forEach(function(obj, index){
if(obj===value){
printedObjIndex = index;
}
});
if ( key == ''){ //root element
printedObjects.push(obj);
printedObjectKeys.push("root");
return value;
}
else if(printedObjIndex+"" != "false" && typeof(value)=="object"){
if ( printedObjectKeys[printedObjIndex] == "root"){
return "(pointer to root)";
}else{
return "(see " + ((!!value && !!value.constructor) ? value.constructor.name.toLowerCase() : typeof(value)) + " with key " + printedObjectKeys[printedObjIndex] + ")";
}
}else{
var qualifiedKey = key || "(empty key)";
printedObjects.push(value);
printedObjectKeys.push(qualifiedKey);
if(replacer){
return replacer(key, value);
}else{
return value;
}
}
}
return JSON.stringify(obj, printOnceReplacer, indent);
};
答案 5 :(得分：35)
请注意，Douglas Crockford还实施了JSON.decycle方法。看他的
cycle.js。这允许您对几乎任何标准结构进行字符串化：
var a = [];
a[0] = a;
a[1] = 123;
console.log(JSON.stringify(JSON.decycle(a)));
// result: '[{"$ref":"$"},123]'.
您还可以使用retrocycle方法重新创建原始对象。因此，您不必从对象中删除循环以对其进行字符串化。
然而，这将不用于DOM节点（这是现实生活用例中循环的典型原因）。例如，这将抛出：
var a = [document.body];
console.log(JSON.stringify(JSON.decycle(a)));
我已经做了一个解决这个问题的分叉（参见我的cycle.js fork）。这应该可以正常工作：
var a = [document.body];
console.log(JSON.stringify(JSON.decycle(a, true)));
请注意，在我的fork JSON.decycle(variable)中，与原始版本一样，当variable包含DOM节点/元素时会抛出异常。
使用JSON.decycle(variable, true)时，您接受结果不可逆的事实（retrocycle不会重新创建DOM节点）。但是DOM元素在某种程度上应该是可识别的。例如，如果div元素具有id，则它将替换为字符串"div#id-of-the-element"。
答案 6 :(得分：34)
@ RobW的回答是正确的，但这更高效！因为它使用hashmap / set：
const customStringify = function (v) {
const cache = new Set();
return JSON.stringify(v, function (key, value) {
if (typeof value === 'object' && value !== null) {
if (cache.has(value)) {
// Circular reference found
try {
// If this value does not reference a parent it can be deduped
return JSON.parse(JSON.stringify(value));
}
catch (err) {
// discard key if value cannot be deduped
return;
}
}
// Store value in our set
cache.add(value);
}
return value;
});
};
答案 7 :(得分：22)
我建议您查看@ isaacs中的json-stringify-safe - 它是在NPM中使用的。
BTW-如果你没有使用Node.js，你只需要复制并粘贴来自relevant part of the source code的第4-27行。
安装：
$ npm install json-stringify-safe --save
使用：
// Require the thing
var stringify = require('json-stringify-safe');
// Take some nasty circular object
var theBigNasty = {
a: "foo",
b: theBigNasty
};
// Then clean it up a little bit
var sanitized = JSON.parse(stringify(theBigNasty));
这会产生：
{
a: 'foo',
b: '[Circular]'
}
请注意，就像提到的@Rob W的vanilla JSON.stringify函数一样，您也可以通过将“replacer”函数作为第二个参数传递给
stringify()来自定义清理行为。如果您发现自己需要一个如何执行此操作的简单示例，我只是编写了一个自定义替换程序，它将错误，正则表达式和函数强制转换为人类可读的字符串here。
答案 8 :(得分：11)
对于未来的googlers在不知道所有循环引用的密钥时搜索此问题的解决方案时，您可以使用JSON.stringify函数周围的包装器来排除循环引用。请参阅https://gist.github.com/4653128上的示例脚本。
解决方案基本上归结为保持对数组中先前打印的对象的引用，并在返回值之前在replacer函数中检查它。它比仅排除循环引用更加紧缩，因为它还排除了两次打印对象，其中一个副作用是避免循环引用。
示例包装器：
function stringifyOnce(obj, replacer, indent){
var printedObjects = [];
var printedObjectKeys = [];
function printOnceReplacer(key, value){
var printedObjIndex = false;
printedObjects.forEach(function(obj, index){
if(obj===value){
printedObjIndex = index;
}
});
if(printedObjIndex && typeof(value)=="object"){
return "(see " + value.constructor.name.toLowerCase() + " with key " + printedObjectKeys[printedObjIndex] + ")";
}else{
var qualifiedKey = key || "(empty key)";
printedObjects.push(value);
printedObjectKeys.push(qualifiedKey);
if(replacer){
return replacer(key, value);
}else{
return value;
}
}
}
return JSON.stringify(obj, printOnceReplacer, indent);
}
答案 9 :(得分：4)
将JSON.stringify方法与replacer一起使用。阅读本文档以获取更多信息。 http://msdn.microsoft.com/en-us/library/cc836459%28v=vs.94%29.aspx
var obj = {
a: "foo",
b: obj
}
var replacement = {"b":undefined};
alert(JSON.stringify(obj,replacement));
找出一种用循环引用填充替换数组的方法。您可以使用typeof方法查找属性是否为＆＃39; object＆＃39; （参考）和完全相等的检查（===）来验证循环引用。
答案 10 :(得分：4)
var a={b:"b"};
a.a=a;
JSON.stringify(preventCircularJson(a));
评估为：
"{"b":"b","a":"CIRCULAR_REFERENCE_REMOVED"}"
功能：
/**
* Traverses a javascript object, and deletes all circular values
* @param source object to remove circular references from
* @param censoredMessage optional: what to put instead of censored values
* @param censorTheseItems should be kept null, used in recursion
* @returns {undefined}
*/
function preventCircularJson(source, censoredMessage, censorTheseItems) {
//init recursive value if this is the first call
censorTheseItems = censorTheseItems || [source];
//default if none is specified
censoredMessage = censoredMessage || "CIRCULAR_REFERENCE_REMOVED";
//values that have allready apeared will be placed here:
var recursiveItems = {};
//initaite a censored clone to return back
var ret = {};
//traverse the object:
for (var key in source) {
var value = source[key]
if (typeof value == "object") {
//re-examine all complex children again later:
recursiveItems[key] = value;
} else {
//simple values copied as is
ret[key] = value;
}
}
//create list of values to censor:
var censorChildItems = [];
for (var key in recursiveItems) {
var value = source[key];
//all complex child objects should not apear again in children:
censorChildItems.push(value);
}
//censor all circular values
for (var key in recursiveItems) {
var value = source[key];
var censored = false;
censorTheseItems.forEach(function (item) {
if (item === value) {
censored = true;
}
});
if (censored) {
//change circular values to this
value = censoredMessage;
} else {
//recursion:
value = preventCircularJson(value, censoredMessage, censorChildItems.concat(censorTheseItems));
}
ret[key] = value
}
return ret;
}
答案 11 :(得分：3)
我知道这是一个老问题，但我想建议一个名为smart-circular的NPM软件包，其工作方式与其他方法不同。如果您使用大而深的对象，它会特别有用。
一些功能是：
通过导致第一次出现的路径（而不仅仅是字符串 [circular] ）替换对象内的循环引用或简单重复的结构;
通过在广度优先搜索中查找圆度，包确保此路径尽可能小，这在处理非常大且深的对象时非常重要，其中路径可能会变得烦人且很难follow（JSON.stringify中的自定义替换执行DFS）;
允许个性化替换，方便简化或忽略对象中较不重要的部分;
最后，路径的编写方式完全按照访问引用字段的方式编写，这可以帮助您进行调试。
答案 12 :(得分：2)
JSON.stringify（）的第二个参数还允许您指定键名数组，该键名应保留在数据中遇到的每个对象中。这可能不适用于所有用例，但是是一种更简单的解决方案。
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
var obj = {
a: "foo",
b: this
}
var json = JSON.stringify(obj, ['a']);
console.log(json);
// {"a":"foo"}
注意：奇怪的是，OP的对象定义在最新的Chrome或Firefox中不会引发循环引用错误。修改了此答案中的定义，以便 did 抛出错误。
答案 13 :(得分：1)
我这样解决了这个问题：
var util = require('util');
// Our circular object
var obj = {foo: {bar: null}, a:{a:{a:{a:{a:{a:{a:{hi: 'Yo!'}}}}}}}};
obj.foo.bar = obj;
// Generate almost valid JS object definition code (typeof string)
var str = util.inspect(b, {depth: null});
// Fix code to the valid state (in this example it is not required, but my object was huge and complex, and I needed this for my case)
str = str
.replace(/<Buffer[ \w\.]+>/ig, '"buffer"')
.replace(/\[Function]/ig, 'function(){}')
.replace(/\[Circular]/ig, '"Circular"')
.replace(/\{ \[Function: ([\w]+)]/ig, '{ $1: function $1 () {},')
.replace(/\[Function: ([\w]+)]/ig, 'function $1(){}')
.replace(/(\w+): ([\w :]+GMT\+[\w \(\)]+),/ig, '$1: new Date("$2"),')
.replace(/(\S+): ,/ig, '$1: null,');
// Create function to eval stringifyed code
var foo = new Function('return ' + str + ';');
// And have fun
console.log(JSON.stringify(foo(), null, 4));
答案 14 :(得分：1)
我找到了circular-json library on github，它对我的问题很有效。
我觉得有用的一些好功能：
答案 15 :(得分：1)
该线程中的大多数答案都专门用于JSON.stringify －它们并未显示如何在原始对象树中实际删除循环引用。 （嗯，由于之后没有再调用JSON.parse，这需要重新分配，并且对性能有更高的影响）
要从源对象树中删除循环引用，可以使用以下函数：https://stackoverflow.com/a/63952549/2441655
这些通用的循环引用删除功能然后可以用于使对循环引用敏感功能（例如JSON.stringify）的后续调用安全：
const objTree = {normalProp: true};
objTree.selfReference = objTree;
RemoveCircularLinks(objTree); // without this line, the JSON.stringify call errors
console.log(JSON.stringify(objTree));
答案 16 :(得分：0)
我为我的 LoggingUtilities 类创建了以下方法。 以下方法获取源对象和目标对象，并通过给定的 maxLevel 将源分配给目标。
static assignObjectByLevel(
sourceObject: any,
targetObject: any,
currentLevel: number = 0,
maxLevel: number = 3,
showUndefinedValues = false
): any {
if (currentLevel >= maxLevel) {
return;
}
const objQueue = [];
for (const key in sourceObject) {
if (sourceObject.hasOwnProperty(key)) {
const value = sourceObject[key];
if (typeof value === "object") {
objQueue.push({ key, value });
} else {
targetObject[key] = value;
}
} else {
if (showUndefinedValues) {
targetObject[key] = "undefined/null";
}
}
}
while (objQueue.length > 0) {
const objVal = objQueue.pop();
currentLevel++;
targetObject[objVal.key] = {};
this.assignObjectByLevel(
objVal.value,
targetObject[objVal.key],
currentLevel,
maxLevel,
false
);
}
}
用法示例：
const logObjParam = {
level1: "value1",
level2: {
value2: "value2",
level3: {
value3: "value3",
level4: {
value4: " value4",
level5: {
value5: " value5",
},
},
},
},
};
let logObj = {};
this.assignObjectByLevel(logObjParam, logObj);
结果：
{
"level1": "value1",
"level2": {
"value2": "value2",
"level3": {
"value3": "value3",
"level4": {}
}
}
}
答案 17 :(得分：0)
此代码循环引用将失败：
JSON.stringify(circularReference);
// TypeError: cyclic object value
使用以下代码：
const getCircularReplacer = () => {
const seen = new WeakSet();
return (key, value) => {
if (typeof value === "object" && value !== null) {
if (seen.has(value)) {
return;
}
seen.add(value);
}
return value;
};
};
JSON.stringify(circularReference, getCircularReplacer());
答案 18 :(得分：0)
我们使用object-scan进行数据处理，这可能是一个可行的解决方案。这就是它的工作方式（也可以正确修剪数组）
const objectScan = require('object-scan');
const prune = (data) => objectScan(['**'], {
rtn: 'count',
filterFn: ({ isCircular, parent, property }) => {
if (isCircular) {
if (Array.isArray(parent)) {
parent.splice(property, 1);
} else {
delete parent[property];
}
return true;
}
return false;
},
breakFn: ({ isCircular }) => isCircular === true
})(data);
const obj = { a: 'foo', c: [0] };
obj.b = obj;
obj.c.push(obj);
console.log(obj);
// => { a: 'foo', c: [ 0, [Circular] ], b: [Circular] }
console.log(prune(obj)); // returns circular counts
// => 2
console.log(JSON.stringify(obj));
// => {"a":"foo","c":[0]}
答案 19 :(得分：0)
您可以尝试JSON解析器库：treedoc。它支持循环引用，并使用引用对重复的对象进行重复数据删除。
yarn add treedoc
import {TD} from 'treedoc'
TD.stringify(obj);
如果您想进行更多自定义
import {TD, TDEncodeOption} from 'treedoc'
const opt = new TDEncodeOption();
opt.coderOption.setShowType(true).setShowFunction(true);
opt.jsonOption.setIndentFactor(2);
return TD.stringify(obj, opt);
生成的JSON文件可以由查看器http://treedoc.org查看，该查看器支持通过JSON节点引用进行导航。
[无耻的插件]我是这个图书馆的作者
答案 20 :(得分：0)
在我的解决方案中，如果遇到一个循环，它不仅会说“循环”（或什么也不说），它会显示类似foo的内容：请参见上面的对象＃42，并查看foo指向的位置可以滚动并搜索对象＃42（每个对象启动时都说对象#xxx带有一些整数xxx）
摘要：
(function(){
"use strict";
var ignore = [Boolean, Date, Number, RegExp, String];
function primitive(item){
if (typeof item === 'object'){
if (item === null) { return true; }
for (var i=0; i<ignore.length; i++){
if (item instanceof ignore[i]) { return true; }
}
return false;
} else {
return true;
}
}
function infant(value){
return Array.isArray(value) ? [] : {};
}
JSON.decycleIntoForest = function decycleIntoForest(object, replacer) {
if (typeof replacer !== 'function'){
replacer = function(x){ return x; }
}
object = replacer(object);
if (primitive(object)) return object;
var objects = [object];
var forest = [infant(object)];
var bucket = new WeakMap(); // bucket = inverse of objects
bucket.set(object, 0); // i.e., map object to index in array
function addToBucket(obj){
var result = objects.length;
objects.push(obj);
bucket.set(obj, result);
return result;
}
function isInBucket(obj){
return bucket.has(obj);
// objects[bucket.get(obj)] === obj, iff true is returned
}
function processNode(source, target){
Object.keys(source).forEach(function(key){
var value = replacer(source[key]);
if (primitive(value)){
target[key] = {value: value};
} else {
var ptr;
if (isInBucket(value)){
ptr = bucket.get(value);
} else {
ptr = addToBucket(value);
var newTree = infant(value);
forest.push(newTree);
processNode(value, newTree);
}
target[key] = {pointer: ptr};
}
});
}
processNode(object, forest[0]);
return forest;
};
})();
the = document.getElementById('the');
function consoleLog(toBeLogged){
the.textContent = the.textContent + '\n' + toBeLogged;
}
function show(root){
var cycleFree = JSON.decycleIntoForest(root);
var shown = cycleFree.map(function(tree, idx){ return false; });
var indentIncrement = 4;
function showItem(nodeSlot, indent, label){
leadingSpaces = ' '.repeat(indent);
leadingSpacesPlus = ' '.repeat(indent + indentIncrement);
if (shown[nodeSlot]){
consoleLog(leadingSpaces + label + ' ... see above (object #' + nodeSlot + ')');
} else {
consoleLog(leadingSpaces + label + ' object#' + nodeSlot);
var tree = cycleFree[nodeSlot];
shown[nodeSlot] = true;
Object.keys(tree).forEach(function(key){
var entry = tree[key];
if ('value' in entry){
consoleLog(leadingSpacesPlus + key + ": " + entry.value);
} else {
if ('pointer' in entry){
showItem(entry.pointer, indent+indentIncrement, key);
}
}
});
}
}
showItem(0, 0, 'root');
}
cities4d = {
Europe:{
north:[
{name:"Stockholm", population:1000000, temp:6},
{name:"Helsinki", population:650000, temp:7.6}
],
south:[
{name:"Madrid", population:3200000, temp:15},
{name:"Rome", population:4300000, temp:15}
]
},
America:{
north:[
{name:"San Francisco", population:900000, temp:14},
{name:"Quebec", population:530000, temp:4}
],
south:[
{name:"Rio de Janeiro", population:7500000, temp:24},
{name:"Santiago", population:6300000, temp:14}
]
},
Asia:{
north:[
{name:"Moscow", population:13200000, temp:6}
]
}
};
cities4d.Europe.north[0].alsoStartsWithS = cities4d.America.north[0];
cities4d.Europe.north[0].smaller = cities4d.Europe.north[1];
cities4d.Europe.south[1].sameLanguage = cities4d.America.south[1];
cities4d.Asia.ptrToRoot = cities4d;
show(cities4d)<pre id="the"></pre>
答案 21 :(得分：0)
function myStringify(obj, maxDeepLevel = 2) {
if (obj === null) {
return 'null';
}
if (obj === undefined) {
return 'undefined';
}
if (maxDeepLevel < 0 || typeof obj !== 'object') {
return obj.toString();
}
return Object
.entries(obj)
.map(x => x[0] + ': ' + myStringify(x[1], maxDeepLevel - 1))
.join('\r\n');
}
答案 22 :(得分：0)
要更新覆盖JSON工作方式的答案（可能不推荐，但超级简单），请不要使用circular-json（已弃用）。而是使用扁平的后继者：
https://www.npmjs.com/package/flatted
从上面的@ user1541685的旧答案中借来，但由新答案代替：
npm i --save flatted
然后在您的js文件中
const JSON = require('flatted');
...
const json = JSON.stringify(obj);
您也可以这样做
const CircularJSON = require('flatted');
答案 23 :(得分：0)
尽管已经足够回答，但是您也可以在使用delete运算符进行字符串化之前显式删除相关属性。
delete obj.b;
const jsonObject = JSON.stringify(obj);
这将消除构建或维护复杂逻辑以删除循环引用的需要。
答案 24 :(得分：0)
如果
console.log(JSON.stringify(object));
导致
TypeError：循环对象值
然后你可能想要这样打印：
var output = '';
for (property in object) {
output += property + ': ' + object[property]+'; ';
}
console.log(output);
答案 25 :(得分：0)
试试这个：
enum WaitFor
{
MinusNext = 1 << 0,
OperatorNext = 1 << 1,
NumberNext = 1 << 2,
NewBraquetNext = 1 << 3,
EndBraquetNext = 1 << 4,
FinalEndNext = 1 << 5
};
struct Part
{
void *content;
int priority;
char *parent;
enum PartType type;
};
struct Expression
{
struct Part ***parts;
int level;
int part;
struct Part lastNumber;
};
答案 26 :(得分：0)
答案 27 :(得分：0)
我知道这个问题很老，并且有很多很好的答案，但我发布这个答案是因为它有新的味道（es5 +）
Object.defineProperties(JSON, {
refStringify: {
value: function(obj) {
let objMap = new Map();
let stringified = JSON.stringify(obj,
function(key, value) {
// only for objects
if (typeof value == 'object') {
// If has the value then return a reference to it
if (objMap.has(value))
return objMap.get(value);
objMap.set(value, `ref${objMap.size + 1}`);
}
return value;
});
return stringified;
}
},
refParse: {
value: function(str) {
let parsed = JSON.parse(str);
let objMap = _createObjectMap(parsed);
objMap.forEach((value, key) => _replaceKeyWithObject(value, key));
return parsed;
}
},
});
// *************************** Example
let a = {
b: 32,
c: {
get a() {
return a;
},
get c() {
return a.c;
}
}
};
let stringified = JSON.refStringify(a);
let parsed = JSON.refParse(stringified, 2);
console.log(parsed, JSON.refStringify(parsed));
// *************************** /Example
// *************************** Helper
function _createObjectMap(obj) {
let objMap = new Map();
JSON.stringify(obj, (key, value) => {
if (typeof value == 'object') {
if (objMap.has(value))
return objMap.get(value);
objMap.set(value, `ref${objMap.size + 1}`);
}
return value;
});
return objMap;
}
function _replaceKeyWithObject(key, obj, replaceWithObject = obj) {
Object.keys(obj).forEach(k => {
let val = obj[k];
if (val == key)
return (obj[k] = replaceWithObject);
if (typeof val == 'object' && val != replaceWithObject)
_replaceKeyWithObject(key, val, replaceWithObject);
});
}
答案 28 :(得分：0)
根据其他答案，我最终得到以下代码。它适用于循环引用，具有自定义构造函数的对象。
从要序列化的给定对象
Github链接 - DecycledJSON
DJSHelper = {};
DJSHelper.Cache = [];
DJSHelper.currentHashID = 0;
DJSHelper.ReviveCache = [];
// DOES NOT SERIALIZE FUNCTION
function DJSNode(name, object, isRoot){
this.name = name;
// [ATTRIBUTES] contains the primitive fields of the Node
this.attributes = {};
// [CHILDREN] contains the Object/Typed fields of the Node
// All [CHILDREN] must be of type [DJSNode]
this.children = []; //Array of DJSNodes only
// If [IS-ROOT] is true reset the Cache and currentHashId
// before encoding
isRoot = typeof isRoot === 'undefined'? true:isRoot;
this.isRoot = isRoot;
if(isRoot){
DJSHelper.Cache = [];
DJSHelper.currentHashID = 0;
// CACHE THE ROOT
object.hashID = DJSHelper.currentHashID++;
DJSHelper.Cache.push(object);
}
for(var a in object){
if(object.hasOwnProperty(a)){
var val = object[a];
if (typeof val === 'object') {
// IF OBJECT OR NULL REF.
/***************************************************************************/
// DO NOT REMOVE THE [FALSE] AS THAT WOULD RESET THE [DJSHELPER.CACHE]
// AND THE RESULT WOULD BE STACK OVERFLOW
/***************************************************************************/
if(val !== null) {
if (DJSHelper.Cache.indexOf(val) === -1) {
// VAL NOT IN CACHE
// ADD THE VAL TO CACHE FIRST -> BEFORE DOING RECURSION
val.hashID = DJSHelper.currentHashID++;
//console.log("Assigned", val.hashID, "to", a);
DJSHelper.Cache.push(val);
if (!(val instanceof Array)) {
// VAL NOT AN [ARRAY]
try {
this.children.push(new DJSNode(a, val, false));
} catch (err) {
console.log(err.message, a);
throw err;
}
} else {
// VAL IS AN [ARRAY]
var node = new DJSNode(a, {
array: true,
hashID: val.hashID // HashID of array
}, false);
val.forEach(function (elem, index) {
node.children.push(new DJSNode("elem", {val: elem}, false));
});
this.children.push(node);
}
} else {
// VAL IN CACHE
// ADD A CYCLIC NODE WITH HASH-ID
this.children.push(new DJSNode(a, {
cyclic: true,
hashID: val.hashID
}, false));
}
}else{
// PUT NULL AS AN ATTRIBUTE
this.attributes[a] = 'null';
}
} else if (typeof val !== 'function') {
// MUST BE A PRIMITIVE
// ADD IT AS AN ATTRIBUTE
this.attributes[a] = val;
}
}
}
if(isRoot){
DJSHelper.Cache = null;
}
this.constructorName = object.constructor.name;
}
DJSNode.Revive = function (xmlNode, isRoot) {
// Default value of [isRoot] is True
isRoot = typeof isRoot === 'undefined'?true: isRoot;
var root;
if(isRoot){
DJSHelper.ReviveCache = []; //Garbage Collect
}
if(window[xmlNode.constructorName].toString().indexOf('[native code]') > -1 ) {
// yep, native in the browser
if(xmlNode.constructorName == 'Object'){
root = {};
}else{
return null;
}
}else {
eval('root = new ' + xmlNode.constructorName + "()");
}
//CACHE ROOT INTO REVIVE-CACHE
DJSHelper.ReviveCache[xmlNode.attributes.hashID] = root;
for(var k in xmlNode.attributes){
// PRIMITIVE OR NULL REF FIELDS
if(xmlNode.attributes.hasOwnProperty(k)) {
var a = xmlNode.attributes[k];
if(a == 'null'){
root[k] = null;
}else {
root[k] = a;
}
}
}
xmlNode.children.forEach(function (value) {
// Each children is an [DJSNode]
// [Array]s are stored as [DJSNode] with an positive Array attribute
// So is value
if(value.attributes.array){
// ITS AN [ARRAY]
root[value.name] = [];
value.children.forEach(function (elem) {
root[value.name].push(elem.attributes.val);
});
//console.log("Caching", value.attributes.hashID);
DJSHelper.ReviveCache[value.attributes.hashID] = root[value.name];
}else if(!value.attributes.cyclic){
// ITS AN [OBJECT]
root[value.name] = DJSNode.Revive(value, false);
//console.log("Caching", value.attributes.hashID);
DJSHelper.ReviveCache[value.attributes.hashID] = root[value.name];
}
});
// [SEPARATE ITERATION] TO MAKE SURE ALL POSSIBLE
// [CYCLIC] REFERENCES ARE CACHED PROPERLY
xmlNode.children.forEach(function (value) {
// Each children is an [DJSNode]
// [Array]s are stored as [DJSNode] with an positive Array attribute
// So is value
if(value.attributes.cyclic){
// ITS AND [CYCLIC] REFERENCE
root[value.name] = DJSHelper.ReviveCache[value.attributes.hashID];
}
});
if(isRoot){
DJSHelper.ReviveCache = null; //Garbage Collect
}
return root;
};
DecycledJSON = {};
DecycledJSON.stringify = function (obj) {
return JSON.stringify(new DJSNode("root", obj));
};
DecycledJSON.parse = function (json, replacerObject) {
// use the replacerObject to get the null values
return DJSNode.Revive(JSON.parse(json));
};
DJS = DecycledJSON;
示例用法1：
var obj = {
id:201,
box: {
owner: null,
key: 'storm'
},
lines:[
'item1',
23
]
};
console.log(obj); // ORIGINAL
// SERIALIZE AND THEN PARSE
var jsonObj = DJS.stringify(obj);
console.log(DJS.parse(jsonObj));
示例用法2：
// PERSON OBJECT
function Person() {
this.name = null;
this.child = null;
this.dad = null;
this.mom = null;
}
var Dad = new Person();
Dad.name = 'John';
var Mom = new Person();
Mom.name = 'Sarah';
var Child = new Person();
Child.name = 'Kiddo';
Dad.child = Mom.child = Child;
Child.dad = Dad;
Child.mom = Mom;
console.log(Child); // ORIGINAL
// SERIALIZE AND THEN PARSE
var jsonChild = DJS.stringify(Child);
console.log(DJS.parse(jsonChild));