Chrome Sendrequest-fout: TypeError: het omzetten van de cirkelvormige structuur naar JSON

function cleanStringify(object) {
    if (object && typeof object === 'object') {
        object = copyWithoutCircularReferences([object], object);
    }
    return JSON.stringify(object);
    function copyWithoutCircularReferences(references, object) {
        var cleanObject = {};
        Object.keys(object).forEach(function(key) {
            var value = object[key];
            if (value && typeof value === 'object') {
                if (references.indexOf(value) < 0) {
                    references.push(value);
                    cleanObject[key] = copyWithoutCircularReferences(references, value);
                    references.pop();
                } else {
                    cleanObject[key] = '###_Circular_###';
                }
            } else if (typeof value !== 'function') {
                cleanObject[key] = value;
            }
        });
        return cleanObject;
    }
}
// Example
var a = {
    name: "a"
};
var b = {
    name: "b"
};
b.a = a;
a.b = b;
console.log(cleanStringify(a));
console.log(cleanStringify(b));

Antwoord 6

Dit is misschien geen gerelateerd antwoord, maar deze link Cirkelverwijzingen detecteren en corrigeren in JavaScriptkan nuttig zijn om objectente detecteren die circulaire afhankelijkheid veroorzaken.

Antwoord 7

Ik los dit probleem op NodeJS als volgt op:

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

Antwoord 8

Voor mijn geval kreeg ik die foutmelding toen ik de functie asyncop mijn server gebruikte om documenten op te halen met mangoest. Het bleek dat de reden was dat ik vergat awaitin te voeren voordat ik de methode find({})aanroep. Het toevoegen van dat onderdeel loste mijn probleem op.

Antwoord 9

Ik heb dezelfde fout ondervonden toen ik het onderstaande bericht probeerde op te bouwen met jQuery. De kringverwijzing vindt plaats wanneer reviewerNameper ongeluk werd toegewezen aan msg.detail.reviewerName. JQuery’s .val() loste het probleem op, zie laatste regel.

var reviewerName = $('reviewerName'); // <input type="text" id="taskName" />;
var msg = {"type":"A", "detail":{"managerReview":true} };
msg.detail.reviewerName = reviewerName; // Error
msg.detail.reviewerName = reviewerName.val(); // Fixed

Antwoord 10

Dit werkt en vertelt u welke eigenschappen circulair zijn. Het maakt het ook mogelijk om het object te reconstrueren met de referenties

 JSON.stringifyWithCircularRefs = (function() {
    const refs = new Map();
    const parents = [];
    const path = ["this"];
    function clear() {
      refs.clear();
      parents.length = 0;
      path.length = 1;
    }
    function updateParents(key, value) {
      var idx = parents.length - 1;
      var prev = parents[idx];
      if (prev[key] === value || idx === 0) {
        path.push(key);
        parents.push(value);
      } else {
        while (idx-- >= 0) {
          prev = parents[idx];
          if (prev[key] === value) {
            idx += 2;
            parents.length = idx;
            path.length = idx;
            --idx;
            parents[idx] = value;
            path[idx] = key;
            break;
          }
        }
      }
    }
    function checkCircular(key, value) {
      if (value != null) {
        if (typeof value === "object") {
          if (key) { updateParents(key, value); }
          let other = refs.get(value);
          if (other) {
            return '[Circular Reference]' + other;
          } else {
            refs.set(value, path.join('.'));
          }
        }
      }
      return value;
    }
    return function stringifyWithCircularRefs(obj, space) {
      try {
        parents.push(obj);
        return JSON.stringify(obj, checkCircular, space);
      } finally {
        clear();
      }
    }
  })();

Voorbeeld waarbij veel van de ruis is verwijderd:

{
    "requestStartTime": "2020-05-22...",
    "ws": {
        "_events": {},
        "readyState": 2,
        "_closeTimer": {
            "_idleTimeout": 30000,
            "_idlePrev": {
                "_idleNext": "[Circular Reference]this.ws._closeTimer",
                "_idlePrev": "[Circular Reference]this.ws._closeTimer",
                "expiry": 33764,
                "id": -9007199254740987,
                "msecs": 30000,
                "priorityQueuePosition": 2
            },
            "_idleNext": "[Circular Reference]this.ws._closeTimer._idlePrev",
            "_idleStart": 3764,
            "_destroyed": false
        },
        "_closeCode": 1006,
        "_extensions": {},
        "_receiver": {
            "_binaryType": "nodebuffer",
            "_extensions": "[Circular Reference]this.ws._extensions",
        },
        "_sender": {
            "_extensions": "[Circular Reference]this.ws._extensions",
            "_socket": {
                "_tlsOptions": {
                    "pipe": false,
                    "secureContext": {
                        "context": {},
                        "singleUse": true
                    },
                },
                "ssl": {
                    "_parent": {
                        "reading": true
                    },
                    "_secureContext": "[Circular Reference]this.ws._sender._socket._tlsOptions.secureContext",
                    "reading": true
                }
            },
            "_firstFragment": true,
            "_compress": false,
            "_bufferedBytes": 0,
            "_deflating": false,
            "_queue": []
        },
        "_socket": "[Circular Reference]this.ws._sender._socket"
    }
}

Om te reconstrueren roept u JSON.parse() aan en doorloopt u de eigenschappen op zoek naar de tag [Circular Reference]. Hak dat dan af en… evalueer… het met thisingesteld op het root-object.

Evalueer niets dat kan worden gehackt. Het is beter om string.split('.')te doen en vervolgens de eigenschappen op naam op te zoeken om de referentie in te stellen.

Antwoord 11

In mijn geval ben ik gewoon vergeten om async/wait te gebruiken tijdens het bouwen van de route:

app.get('/products', async (req, res) => {
    const products = await Product.find();
    res.send(products );
});

Antwoord 12

Ik kreeg dezelfde fout met jQuery formvaliadator, maar toen ik een console.log binnen success: function verwijderde, werkte het.

Antwoord 13

Node.js v10.22.1 (de versie die draait op onze GitLab CI-server) heeft, wat ik beschouw, een foutieve kringverwijzingsdetector. De lokaal draaiende versie (v12.8.0) is slim genoeg om te weten dat het geen echte kringverwijzing is.

Ik voeg dit antwoord toe voor het geval iemand anders hetzelfde probleem heeft en hun object eigenlijk geen kringverwijzing is.

Dit was het oorspronkelijke antwoordobject:

var res = {
    "status":"OK",
    "message":"Success",
    "errCode":":",
    "data":"",
    "appCfg":{
        "acp_age":"2yy",
        "acp_us":"yes",
        "mode":"admin",
        "version":"v1.21.07.1"
    },
    "reqID":59833,
    "email":{
        "status":"OK",
        "message":"Success"
    },
    "emailStatus":"sent"
}

Het dacht dat res.email.statushetzelfde was als res.status. Het is slechts een tekstelement, dus niet cirkelvormig, maar de naam en waarde struikelde kennelijk de JSON.Strationify Parser op.

Ik heb de res.emailsub-object verwijderen en alles is prima. Ik probeerde onafhankelijke statussen te verzamelen en gedetailleerde berichten van alle unieke acties die werden uitgevoerd tijdens de serveroproep. Ik heb het naar het element ingeschakeld res.emailStatusdie ook in het bovenstaande voorbeeld is opgenomen.

Antwoord 14

In mijn geval gebruik ik reageer native en probeerde

te debuggen

console.log(JSON.stringify(object))

en kreeg de fout:

TypeError: Converting circular structure to JSON

Het lijkt erop dat ik het object aan de console aan de console kan krijgen door gewoon gewoon te gebruiken:

console.log(object)