How can I print a circular structure in a JSON-like format

Question

I have a big object I want to convert to JSON and send  However it has circular structure  I want to toss whatever circular references exist and send whatever can be stringified  How do I do that   Thanks   var obj       a   foo     b  obj     I want to stringify obj into     a   foo

User · Answer

For future googlers searching for a solution to this problem when you don't know the keys of all circular references, you could use a wrapper around the JSON.stringify function to rule out circular references. See an example script at https://gist.github.com/4653128.

The solution essentially boils down to keeping a reference to previously printed objects in an array, and checking that in a replacer function before returning a value. It's more constrictive than only ruling out circular references, because it also rules out ever printing an object twice, one of the side affects of which is to avoid circular references.

Example wrapper:

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);
}

User · Answer

The second argument to JSON stringify   also allows you to specify an array of key names that should be preserved from every object it encounters within your data  This may not work for all use cases  but is a much simpler solution   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     Note  Strangely  the object definition from OP does not throw a circular reference error in the latest Chrome or Firefox  The definition in this answer was modified so that it did throw an error

User · Answer

If   console log JSON stringify object      results in a      TypeError  cyclic object value   Then you may want to print like this   var output       for  property in object      output    property          object property          console log output

User · Answer

Although this has been answered sufficiently  you could also explicitly delete the property in question before stringification using the delete operator    delete obj b   const jsonObject   JSON stringify obj     delete operator  this will remove the need to build or maintain complex logic to remove circular references

User · Answer

I resolve this problem like this   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   lt Buffer   w     gt  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

User · Answer

I know this question is old and has lots of great answers but I post this answer because of it s new flavor  es5      x000D   x000D  Object defineProperties JSON    x000D    refStringify    x000D      value  function obj    x000D   x000D        let objMap   new Map    x000D        let stringified   JSON stringify obj  x000D          function key  value    x000D   x000D               only for objects x000D            if  typeof value     object     x000D                 If has the value then return a reference to it x000D              if  objMap has value   x000D                return objMap get value   x000D   x000D              objMap set value   ref  objMap size   1     x000D              x000D            return value  x000D              x000D        return stringified  x000D        x000D       x000D    refParse    x000D      value  function str    x000D   x000D        let parsed   JSON parse str   x000D        let objMap    createObjectMap parsed   x000D        objMap forEach  value  key    gt   replaceKeyWithObject value  key    x000D        return parsed  x000D        x000D       x000D      x000D   x000D                                 Example x000D  let a     x000D    b  32  x000D    c    x000D      get a     x000D          return a  x000D           x000D        get c     x000D          return a c  x000D          x000D      x000D     x000D  let stringified   JSON refStringify a   x000D  let parsed   JSON refParse stringified  2   x000D  console log parsed  JSON refStringify parsed    x000D                                  Example x000D   x000D                                 Helper x000D  function  createObjectMap obj    x000D   x000D    let objMap   new Map    x000D    JSON stringify obj   key  value    gt    x000D      if  typeof value     object     x000D        if  objMap has value   x000D          return objMap get value   x000D        objMap set value   ref  objMap size   1     x000D   x000D        x000D      return value  x000D        x000D    return objMap  x000D    x000D   x000D  function  replaceKeyWithObject key  obj  replaceWithObject   obj    x000D   x000D    Object keys obj  forEach k   gt    x000D   x000D      let val   obj k   x000D      if  val    key  x000D        return  obj k    replaceWithObject   x000D      if  typeof val     object   amp  amp  val    replaceWithObject  x000D         replaceKeyWithObject key  val  replaceWithObject   x000D        x000D    x000D   x000D   x000D

User · Answer

I wonder why nobody posted the proper solution from MDN page yet     const getCircularReplacer        gt      const seen   new WeakSet      return  key  value    gt        if  typeof value      object   amp  amp  value     null          if  seen has value             return                seen add value             return value           JSON stringify circularReference  getCircularReplacer       Seen values should be stored in a set  not in array  replacer gets called on every element  and there is no need to try JSON stringify each element in the chain leading to a circular reference   Like in the accepted answer  this solution removes all repeating values  not just the circular ones  But at least it does not have exponential complexity

User · Answer

Based on the other answers I end up with the following code  It works pretty well with circular references  objects with custom constructors   From the given object to be serialized     Cache all the object you come across while traversing the object and assign each of them a unique hashID  an auto-incrementing number also works  Once a circular reference is found mark that field in the new object as circular and store the hashID of the original object as an attribute    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 - gt  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     gt  -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    Example Usage 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      Example Usage 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

User · Answer

just do   npm i --save circular-json   then in your js file  const CircularJSON   require  circular-json        const json   CircularJSON stringify obj     https   github com WebReflection circular-json  NOTE  I have nothing to do with this package  But I do use it for this   Update 2020  Please note CircularJSON is in maintenance only and flatted is its successor

User · Answer

To update the answer of overriding the way JSON works  probably not recommended  but super simple   don t use circular-json  it s deprecated   Instead  use the successor  flatted   https   www npmjs com package flatted  Borrowed from the old answer above from  user1541685   but replaced with the new one   npm i --save flatted  then in your js file  const CircularJSON   require  flatted    const json   CircularJSON stringify obj

User · Answer

We use object-scan for our data processing and it might be a viable solution here  This is how it could work  also pruning arrays correctly   x000D   x000D     const objectScan   require  object-scan     const prune    data    gt  objectScan             rtn   count     filterFn     isCircular  parent  property      gt        if  isCircular          if  Array isArray parent             parent splice property  1           else           delete parent property                 return true            return false         breakFn     isCircular      gt  isCircular     true    data    const obj     a   foo   c   0     obj b   obj  obj c push obj   console log obj        gt    a   foo   c    0   Circular     b   Circular     console log prune obj       returns circular counts      gt  2  console log obj        gt    a   foo   c    0     x000D   as-console-wrapper  max-height  100   important  top  0  x000D   lt script src  https   bundle run object-scan 13 8 0  gt  lt  script gt  x000D   x000D   x000D   Disclaimer  I m the author of object-scan

User · Answer

Use the JSON stringify method with a replacer  Read this documentation for more information  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      Figure out a way to populate the replacement array with cyclic references  You can use the typeof method to find if an the property is of type  object    reference   and an exact equality check         to verify circular reference

User · Answer

In Node js  you can use util inspect object   It automatically replaces circular links with  quot  Circular  quot    Albeit being built-in  no installation is required   you must import it import   as util from  util     has no default export import   inspect   from  util     or directly    or  var util   require  util     To use it  simply call console log util inspect myObject    Also be aware that you can pass options object to inspect  see link above  inspect myObject   options   showHidden  depth  colors  showProxy     moreOptions       Please  read and give kudos to commenters below

User · Answer

RobW s answer is correct  but this is more performant   Because it uses a hashmap set   const customStringify   function  v      const cache   new Set      return JSON stringify v  function  key  value        if  typeof value      object   amp  amp  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

User · Answer

Note that there is also a JSON decycle method implemented by Douglas Crockford  See his cycle js  This allows you to stringify almost any standard structure   var a       a 0    a  a 1    123  console log JSON stringify JSON decycle a        result       ref       123      You can also recreate original object with retrocycle method  So you don t have to remove cycles from objects to stringify them   However this will not work for DOM Nodes  which are typical cause of cycles in real life use-cases   For example this will throw   var a    document body   console log JSON stringify JSON decycle a       I ve made a fork to solve that problem  see my cycle js fork   This should work fine   var a    document body   console log JSON stringify JSON decycle a  true       Note that in my fork JSON decycle variable  works as in the original and will throw an exception when the variable contain DOM nodes elements   When you use JSON decycle variable  true  you accept the fact that the result will not be reversible  retrocycle will not re-create DOM nodes   DOM elements should be identifiable to some extent though  For example if a div element has an id then it will be replaced with a string  div id-of-the-element

User · Answer

You could try the JSON parser library  treedoc  it supports circular references and also dedupes the repeated objects with references  yarn add treedoc import  TD  from  treedoc  TD stringify obj    If you want more customization import  TD  TDEncodeOption  from  treedoc   const opt   new TDEncodeOption    opt coderOption setShowType true  setShowFunction true   opt jsonOption setIndentFactor 2   return TD stringify obj  opt    The generated JSON file can be viewed by the viewer http   treedoc org  which supports the navigation through JSON node references   shameless plug  I m the author of this library

User · Answer

Use JSON stringify with a custom replacer  For example      Demo  Circular reference var circ       circ circ   circ      Note  cache should not be re-used by repeated calls to JSON stringify  var cache       JSON stringify circ   key  value    gt      if  typeof value      object   amp  amp  value     null           Duplicate reference found  discard key     if  cache includes value   return          Store value in our collection     cache push value         return value      cache   null     Enable garbage collection   The replacer in this example is not 100  correct  depending on your definition of  duplicate    In the following case  a value is discarded   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          But the concept stands  Use a custom replacer  and keep track of the parsed object values   As a utility function written in es6      safely handles circular references JSON safeStringify    obj  indent   2    gt      let cache         const retVal   JSON stringify      obj       key  value    gt        typeof value      object   amp  amp  value     null           cache includes value              undefined    Duplicate reference found  discard key             cache push value   amp  amp  value    Store value in our collection           value      indent        cache   null    return retVal         Example  console log  options   JSON safeStringify options

User · Answer

function myStringify obj  maxDeepLevel   2      if  obj     null        return  null         if  obj     undefined        return  undefined         if  maxDeepLevel  lt  0    typeof obj      object         return obj toString          return Object      entries obj       map x   gt  x 0           myStringify x 1   maxDeepLevel - 1        join   r n

User · Answer

This code will fail for circular reference      JSON stringify circularReference      TypeError  cyclic object value  Use the below code   const getCircularReplacer        gt      const seen   new WeakSet      return  key  value    gt        if  typeof value      quot object quot   amp  amp  value     null          if  seen has value             return                seen add value             return value           JSON stringify circularReference  getCircularReplacer

User · Answer

I found circular-json library on github and it worked well for my problem   Some good features I found useful    Supports multi-platform usage but I only tested it with node js so far  API is same so all you need to do is include and use it as a JSON replacement  It have it s own parsing method so you can convert the  circular  serialized data back to object

User · Answer

Try this   var obj         a   foo       b  obj     var circular replacer    value    gt        var seen           if  value    null  amp  amp  typeof value     object             if  seen indexOf value   gt   0  return          seen push value             return value      obj   circular replacer obj

User · Answer

I d recommend checking out json-stringify-safe from  isaacs-- it s used in NPM      BTW- if you re not using Node js  you can just copy and paste lines 4-27 from the relevant part of the source code    To install     npm install json-stringify-safe --save   To use      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      This yields       a   foo     b    Circular          Note that  just like with the vanilla JSON stringify function as  Rob W mentioned  you can also customize the sanitization behavior by passing in a  replacer  function as the second argument to stringify     If you find yourself needing a simple example of how to do this  I just wrote a custom replacer which coerces errors  regexps  and functions into human-readable strings here

User · Answer

I really liked Trindaz s solution - more verbose  however it had some bugs  I fixed them for whoever likes it too   Plus  I added a length limit on my cache objects    If the object I am printing is really big - I mean infinitely big - I want to limit my algorithm     JSON stringifyOnce   function obj  replacer  indent       var printedObjects           var printedObjectKeys            function printOnceReplacer key  value           if   printedObjects length  gt  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   amp  amp  typeof value    object                if   printedObjectKeys printedObjIndex      root                    return   pointer to root                 else                  return   see         value  amp  amp    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

User · Answer

an other solution for resolving this issue with these kind of objects is that using this library  https   github com ericmuyser stringy  its simple and you can in a few simple step solve this

User · Answer

Most of the answers in this thread are catered to use with JSON stringify specifically -- they do not show how to actually remove circular-references in the original object-tree   well  short of calling JSON parse again afterward -- which requires reassignment  and has a higher performance impact  For removing circular-references from the source object-tree  you can use a function such as this  https   stackoverflow com a 63952549 2441655 These general-purpose circular-reference-remover functions can then be used to make subsequent calls to circular-reference-sensitive functions  like JSON stringify  safe  const objTree    normalProp  true   objTree selfReference   objTree  RemoveCircularLinks objTree      without this line  the JSON stringify call errors console log JSON stringify objTree

User · Answer

I know this is an old question  but I d like to suggest an NPM package I ve created called smart-circular  which works differently from the other ways proposed  It s specially useful if you re using big and deep objects    Some features are    Replacing circular references or simply repeated structures inside the object by the path leading to its first occurrence  not just the string  circular    By looking for circularities in a breadth-first search  the package ensures this path is as small as possible  which is important when dealing with very big and deep objects  where the paths can get annoyingly long and difficult to follow  the custom replacement in JSON stringify does a DFS   Allows personalised replacements  handy to simplify or ignore less important parts of the object  Finally  the paths are written exactly in the way necessary to access the field referenced  which can help you debugging

User · Answer

var a  b  b    a a a  JSON stringify preventCircularJson a      evaluates to      b   b   a   CIRCULAR REFERENCE REMOVED      with the function          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

[javascript] How can I print a circular structure in a JSON-like format?

Examples related to javascript

Examples related to json

Examples related to node.js