У меня есть большой объект, который я хочу преобразовать в JSON и отправить. Однако он имеет круговую структуру. Я хочу подбросить любые циркулярные ссылки и отправить все, что может быть сжато. Как это сделать?
Спасибо.
var obj = {
a: "foo",
b: obj
}
Я хочу привязать obj к:
{"a":"foo"}
Используйте 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, discard key
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, ...);
Но концепция стоит: использовать собственный заменитель и отслеживать проанализированные значения объекта.
В Node.js вы можете использовать util.inspect (объект). Он автоматически заменяет круглые ссылки на "[Круговой]".
Хотя встроенный (установка не требуется), вы должны импортировать его
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}])
Пожалуйста, прочитайте и отдайте должное комментаторам ниже...
Интересно, почему никто не выложил правильное решение со страницы MDN...
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 каждого элемента), и нет необходимости пытаться JSON.stringify каждого элемента в цепочке, ведущей к циклической ссылке.
Как и в принятом ответе, это решение удаляет все повторяющиеся значения, а не только круглые. Но по крайней мере это не имеет экспоненциальной сложности.
просто
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
ПРИМЕЧАНИЕ. Я не имею никакого отношения к этому пакету. Но я использую его для этого.
Мне очень понравилось решение 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);
};
@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;
});
};
Обратите внимание, что есть также метод 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)));
Я сделал ответвление, чтобы решить эту проблему (см. Мой fork.js). Это должно работать нормально:
var a = [document.body];
console.log(JSON.stringify(JSON.decycle(a, true)));
Обратите внимание, что в моем форке JSON.decycle(variable) работает так же, как и в оригинале, и JSON.decycle(variable) исключение, когда variable содержит узлы/элементы DOM.
Когда вы используете JSON.decycle(variable, true) вы принимаете тот факт, что результат не будет обратимым (ретроцикл не будет повторно создавать узлы DOM). Элементы DOM должны быть в некоторой степени идентифицируемыми. Например, если элемент div имеет идентификатор, он будет заменен строкой "div#id-of-the-element".
Я бы рекомендовал проверить json-stringify-safe из @isaacs - он использовался в NPM.
BTW- если вы не используете Node.js, вы можете просто скопировать и вставить строки 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]'
}
Обратите внимание, что, как и в случае с функцией vanilla JSON.stringify, как указано в @Rob W, вы также можете настроить поведение санитарии, передав функцию "replacer" в качестве второго аргумента в
stringify(). Если вам понадобится простой пример того, как это сделать, я просто написал пользовательский заменитель, который принуждает ошибки, регулярные выражения и функции в читаемые человеком строки здесь.
Для будущих гуглеров, которые ищут решение этой проблемы, когда вы не знаете ключей всех циклических ссылок, вы можете использовать оболочку вокруг функции JSON.stringify, чтобы исключить циклические ссылки. Смотрите пример сценария на https://gist.github.com/4653128.
По сути, решение сводится к тому, чтобы хранить ссылку на ранее напечатанные объекты в массиве и проверять ее в функции замены перед возвратом значения. Он более ограничен, чем исключение циклических ссылок, поскольку он также исключает возможность печати объекта дважды, одним из побочных эффектов которого является избегание циклических ссылок.
Пример оболочки:
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);
}
Используйте метод JSON.stringify с помощью замены. Прочтите эту документацию для получения дополнительной информации. 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, чтобы узнать, имеет ли свойство тип "объект" (ссылка) и точную проверку равенства (===) для проверки циклической ссылки.
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;
}
Я знаю, что это старый вопрос, но я хотел бы предложить пакет NPM, который я создал, smart-circular, который отличается от других предложенных способов. Это особенно полезно, если вы используете большие и глубокие объекты.
Некоторые функции:
Замена круговых ссылок или просто повторяющихся структур внутри объекта по пути, ведущему к его первому вхождению (а не только к строке [кружок]);
При поиске круглостей в первом поиске пакет гарантирует, что этот путь как можно меньше, что важно при работе с очень большими и глубокими объектами, где пути могут раздражать долго и трудно следовать (пользовательская замена в JSON.stringify делает DFS);
Позволяет персонализированные замены, удобные для упрощения или игнорирования менее важных частей объекта;
Наконец, пути записываются точно так, как нужно для доступа к указанному полю, что может помочь вам отлаживать.
Если
console.log(JSON.stringify(object));
приводит к
TypeError: значение циклического объекта
Затем вы можете печатать следующим образом:
var output = '';
for (property in object) {
output += property + ': ' + object[property]+'; ';
}
console.log(output);
Второй аргумент 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. Определение в этом ответе было изменено таким образом, чтобы оно выдавало ошибку.
Я нашел круговую json-библиотеку на github, и она хорошо работала для моей проблемы.
Некоторые полезные функции, которые я нашел полезными:
Я разрешаю эту проблему следующим образом:
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));
Я знаю, что этот вопрос старый, и у него много замечательных ответов, но я отправляю этот ответ из-за его нового вкуса (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);
});
} Хотя на этот вопрос был дан достаточный ответ, вы также можете явно удалить данное свойство перед строкой, используя оператор delete.
delete obj.b;
const jsonObject = JSON.stringify(obj);
это избавит от необходимости создавать или поддерживать сложную логику для удаления циклических ссылок.
другое решение для решения этой проблемы с этими типами объектов заключается в том, что с использованием этой библиотеки
https://github.com/ericmuyser/stringy
его просто, и вы можете на нескольких простых шагах решить это.
Основываясь на других ответах, я получаю следующий код. Он хорошо работает с круговыми ссылками, объектами с настраиваемыми конструкторами.
Из заданного объекта, который будет сериализован,
Github Link - 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));
Попробуй это:
var obj = {
a: "foo",
b: obj
};
var circular_replacer = (value) => {
var seen = [];
if (value != null && typeof value == "object") {
if (seen.indexOf(value) >= 0) return;
seen.push(value);
}
return value;
};
obj = circular_replacer(obj);
Чтобы обновить ответ о переопределении работы JSON (возможно, не рекомендуется, но очень просто), не используйте circular-json (не рекомендуется). Вместо этого используйте преемник, flatted:
https://www.npmjs.com/package/flatted
Заимствовано из старого ответа выше @user1541685, но заменено новым:
npm я --save flatted
тогда в вашем файле JS
const JSON = require('flatted');
...
const json = JSON.stringify(obj);
Вы могли бы также сделать
const CircularJSON = require('flatted');
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');
}