Ist es nicht möglich, einen Fehler mit JSON.stringify zu stringifizieren?

Das Problem reproduzieren

Beim Versuch, Fehlermeldungen mithilfe von Web-Sockets weiterzugeben, tritt ein Problem auf. Ich kann das Problem, mit dem ich konfrontiert bin JSON.stringify, wiederholen, um ein breiteres Publikum anzusprechen:

// node v0.10.15
> var error = new Error('simple error message');
    undefined

> error
    [Error: simple error message]

> Object.getOwnPropertyNames(error);
    [ 'stack', 'arguments', 'type', 'message' ]

> JSON.stringify(error);
    '{}'

Das Problem ist, dass ich am Ende ein leeres Objekt habe.

Was ich versucht habe

Browser

Ich habe zuerst versucht, node.js zu verlassen und es in verschiedenen Browsern auszuführen. Die Chrome-Version 28 liefert das gleiche Ergebnis, und interessanterweise unternimmt Firefox zumindest einen Versuch, lässt jedoch die folgende Meldung aus:

>>> JSON.stringify(error); // Firebug, Firefox 23
{"fileName":"debug eval code","lineNumber":1,"stack":"@debug eval code:1\n"}

Ersatzfunktion

Ich habe mir dann den Error.prototype angesehen . Es zeigt, dass der Prototyp Methoden wie toString und toSource enthält . Da ich wusste, dass Funktionen nicht stringifiziert werden können, habe ich beim Aufrufen von JSON.stringify eine Ersetzungsfunktion eingefügt, um alle Funktionen zu entfernen, aber dann festgestellt, dass auch diese ein seltsames Verhalten aufweist:

var error = new Error('simple error message');
JSON.stringify(error, function(key, value) {
    console.log(key === ''); // true (?)
    console.log(value === error); // true (?)
});

Es scheint das Objekt nicht wie gewohnt zu durchlaufen, und daher kann ich nicht überprüfen, ob die Taste eine Funktion ist, und sie ignorieren.

Die Frage

Gibt es eine Möglichkeit, native Fehlermeldungen mit zu kennzeichnen JSON.stringify? Wenn nicht, warum tritt dieses Verhalten auf?

Methoden, um dies zu umgehen

• Halten Sie sich an einfache stringbasierte Fehlermeldungen oder erstellen Sie persönliche Fehlerobjekte und verlassen Sie sich nicht auf das native Fehlerobjekt.
• Pull-Eigenschaften: JSON.stringify({ message: error.message, stack: error.stack })

Aktualisierung

@ Ray Toal In einem Kommentar vorgeschlagen, dass ich mir die Eigenschaftsbeschreibungen anschaue . Es ist jetzt klar, warum es nicht funktioniert:

var error = new Error('simple error message');
var propertyNames = Object.getOwnPropertyNames(error);
var descriptor;
for (var property, i = 0, len = propertyNames.length; i < len; ++i) {
    property = propertyNames[i];
    descriptor = Object.getOwnPropertyDescriptor(error, property);
    console.log(property, descriptor);
}

Ausgabe:

stack { get: [Function],
  set: [Function],
  enumerable: false,
  configurable: true }
arguments { value: undefined,
  writable: true,
  enumerable: false,
  configurable: true }
type { value: undefined,
  writable: true,
  enumerable: false,
  configurable: true }
message { value: 'simple error message',
  writable: true,
  enumerable: false,
  configurable: true }

Schlüssel : enumerable: false.

Die akzeptierte Antwort bietet eine Problemumgehung für dieses Problem.

Sie können a definieren Error.prototype.toJSON, um eine Ebene abzurufen, die Folgendes Objectdarstellt Error:

if (!('toJSON' in Error.prototype))
Object.defineProperty(Error.prototype, 'toJSON', {
    value: function () {
        var alt = {};

        Object.getOwnPropertyNames(this).forEach(function (key) {
            alt[key] = this[key];
        }, this);

        return alt;
    },
    configurable: true,
    writable: true
});

var error = new Error('testing');
error.detail = 'foo bar';

console.log(JSON.stringify(error));
// {"message":"testing","detail":"foo bar"}

Verwenden von Object.defineProperty()Adds, toJSONohne dass es sich um eine enumerableEigenschaft handelt.

In Bezug auf das Modifizieren Error.prototypeist die Methode , obwohl sie toJSON()möglicherweise nicht Errorspeziell für s definiert ist, für Objekte im Allgemeinen standardisiert (siehe Schritt 3). Das Risiko von Kollisionen oder Konflikten ist also minimal.

Obwohl, noch sie vollständig zu vermeiden, JSON.stringify()‚s - replacerParameter können stattdessen verwendet werden:

function replaceErrors(key, value) {
    if (value instanceof Error) {
        var error = {};

        Object.getOwnPropertyNames(value).forEach(function (key) {
            error[key] = value[key];
        });

        return error;
    }

    return value;
}

var error = new Error('testing');
error.detail = 'foo bar';

console.log(JSON.stringify(error, replaceErrors));

JSON.stringify(err, Object.getOwnPropertyNames(err))

scheint zu funktionieren

[ aus einem Kommentar von / u / ub3rgeek zu / r / javascript ] und dem Kommentar von felixfbecker unten

Da niemand über das Warum spricht , werde ich darauf antworten.

Warum gibt dies JSON.stringifyein leeres Objekt zurück?

> JSON.stringify(error);
'{}'

Antworten

Aus dem Dokument von JSON.stringify () ,

Für alle anderen Objektinstanzen (einschließlich Map, Set, WeakMap und WeakSet) werden nur ihre aufzählbaren Eigenschaften serialisiert.

und ErrorObjekt hat nicht seine aufzählbaren Eigenschaften, deshalb druckt es ein leeres Objekt.

Ändern Sie Jonathans großartige Antwort, um das Patchen von Affen zu vermeiden:

var stringifyError = function(err, filter, space) {
  var plainObject = {};
  Object.getOwnPropertyNames(err).forEach(function(key) {
    plainObject[key] = err[key];
  });
  return JSON.stringify(plainObject, filter, space);
};

var error = new Error('testing');
error.detail = 'foo bar';

console.log(stringifyError(error, null, '\t'));

Dafür gibt es ein großartiges Node.js-Paket : serialize-error.

Es verarbeitet auch verschachtelte Fehlerobjekte gut, was ich eigentlich in meinem Projekt sehr gebraucht habe.

https://www.npmjs.com/package/serialize-error

Sie können diese nicht aufzählbaren Eigenschaften auch einfach neu definieren, damit sie aufzählbar sind.

Object.defineProperty(Error.prototype, 'message', {
    configurable: true,
    enumerable: true
});

und vielleicht auch stackEigentum.

Wir mussten eine beliebige Objekthierarchie serialisieren, wobei die Wurzel oder eine der verschachtelten Eigenschaften in der Hierarchie Fehlerinstanzen sein könnten.

Unsere Lösung bestand darin, den replacerParameter zu verwenden JSON.stringify(), z.

function jsonFriendlyErrorReplacer(key, value) {
  if (value instanceof Error) {
    return {
      // Pull all enumerable properties, supporting properties on custom Errors
      ...value,
      // Explicitly pull Error's non-enumerable properties
      name: value.name,
      message: value.message,
      stack: value.stack,
    }
  }

  return value
}

let obj = {
    error: new Error('nested error message')
}

console.log('Result WITHOUT custom replacer:', JSON.stringify(obj))
console.log('Result WITH custom replacer:', JSON.stringify(obj, jsonFriendlyErrorReplacer))

Keine der obigen Antworten schien Eigenschaften, die sich auf dem Prototyp des Fehlers befinden, ordnungsgemäß zu serialisieren (da getOwnPropertyNames()ererbte Eigenschaften nicht enthält). Ich war auch nicht in der Lage, die Eigenschaften wie in einer der vorgeschlagenen Antworten neu zu definieren.

Dies ist die Lösung, die ich mir ausgedacht habe - sie verwendet lodash, aber Sie könnten lodash durch generische Versionen dieser Funktionen ersetzen.

 function recursivePropertyFinder(obj){
    if( obj === Object.prototype){
        return {};
    }else{
        return _.reduce(Object.getOwnPropertyNames(obj), 
            function copy(result, value, key) {
                if( !_.isFunction(obj[value])){
                    if( _.isObject(obj[value])){
                        result[value] = recursivePropertyFinder(obj[value]);
                    }else{
                        result[value] = obj[value];
                    }
                }
                return result;
            }, recursivePropertyFinder(Object.getPrototypeOf(obj)));
    }
}


Error.prototype.toJSON = function(){
    return recursivePropertyFinder(this);
}

Hier ist der Test, den ich in Chrome durchgeführt habe:

var myError = Error('hello');
myError.causedBy = Error('error2');
myError.causedBy.causedBy = Error('error3');
myError.causedBy.causedBy.displayed = true;
JSON.stringify(myError);

{"name":"Error","message":"hello","stack":"Error: hello\n    at <anonymous>:66:15","causedBy":{"name":"Error","message":"error2","stack":"Error: error2\n    at <anonymous>:67:20","causedBy":{"name":"Error","message":"error3","stack":"Error: error3\n    at <anonymous>:68:29","displayed":true}}}  

Ich habe an einem JSON-Format für Protokoll-Appender gearbeitet und bin hier gelandet, um ein ähnliches Problem zu lösen. Nach einer Weile wurde mir klar, dass ich Node einfach dazu bringen konnte, die Arbeit zu erledigen:

const util = require("util");
...
return JSON.stringify(obj, (name, value) => {
    if (value instanceof Error) {
        return util.format(value);
    } else {
        return value;
    }
}