Non è possibile crittografare un errore utilizzando JSON.stringify?

Riproduzione del problema

Sto riscontrando un problema quando provo a trasmettere messaggi di errore utilizzando i socket Web. Posso replicare il problema che sto affrontando utilizzando JSON.stringifyper soddisfare un pubblico più ampio:

// 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);
    '{}'

Il problema è che finisco con un oggetto vuoto.

Quello che ho provato

browser

Per prima cosa ho provato a lasciare node.js ed eseguirlo in vari browser. La versione 28 di Chrome mi dà lo stesso risultato e, cosa abbastanza interessante, almeno un tentativo di Firefox ha lasciato fuori il messaggio:

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

Funzione di sostituzione

Ho quindi esaminato il Error.prototype . Mostra che il prototipo contiene metodi come toString e toSource . Sapendo che non è possibile restringere le funzioni, ho incluso una funzione di sostituzione quando ho chiamato JSON.stringify per rimuovere tutte le funzioni, ma poi ho capito che anche questo aveva un comportamento strano:

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

Non sembra passare sopra l'oggetto come farebbe normalmente, e quindi non posso controllare se il tasto è una funzione e ignorarlo.

La domanda

Esiste un modo per stringere i messaggi di errore nativi con JSON.stringify? In caso contrario, perché si verifica questo comportamento?

Metodi per aggirare questo

• Attenersi a semplici messaggi di errore basati su stringhe o creare oggetti di errore personali e non fare affidamento sull'oggetto Error nativo.
• Proprietà pull: JSON.stringify({ message: error.message, stack: error.stack })

aggiornamenti

@Ray Toal Suggerito in un commento che do un'occhiata ai descrittori di proprietà . Ora è chiaro perché non funziona:

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

Produzione:

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 }

Legenda: enumerable: false.

La risposta accettata fornisce una soluzione alternativa per questo problema.

È possibile definire a Error.prototype.toJSONper recuperare una pianura che Objectrappresenta 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"}

L'utilizzo Object.defineProperty()aggiunge toJSONsenza che sia una enumerableproprietà stessa.

Per quanto riguarda la modifica Error.prototype, anche se toJSON()potrebbe non essere definito per Errors in modo specifico, il metodo è ancora standardizzato per gli oggetti in generale (rif: passaggio 3). Pertanto, il rischio di collisioni o conflitti è minimo.

Tuttavia, per evitarlo ancora completamente, JSON.stringify()èreplacer possibile utilizzare invece il parametro :

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

sembra funzionare

[ da un commento di / u / ub3rgeek su / r / javascript ] e il commento di felixfbecker qui sotto

Poiché nessuno sta parlando della parte del perché , risponderò.

Perché questo JSON.stringifyrestituisce un oggetto vuoto?

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

Risposta

Dal documento di JSON.stringify () ,

Per tutte le altre istanze di oggetti (inclusi Map, Set, WeakMap e WeakSet), verranno serializzate solo le loro proprietà enumerabili.

e l' Erroroggetto non ha le sue proprietà enumerabili, ecco perché stampa un oggetto vuoto.

Modifica dell'ottima risposta di Jonathan per evitare di rattoppare le scimmie:

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

V'è un grande pacchetto Node.js per questo: serialize-error.

Gestisce bene anche gli oggetti Error nidificati, ciò di cui in realtà avevo molto bisogno nel mio progetto.

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

È inoltre possibile ridefinire le proprietà non enumerabili per essere enumerabili.

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

e forse stackanche proprietà.

Avevamo bisogno di serializzare una gerarchia di oggetti arbitraria, in cui la radice o una delle proprietà nidificate nella gerarchia potrebbero essere istanze di errore.

La nostra soluzione era usare il replacerparametro di JSON.stringify(), ad esempio:

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

Nessuna delle risposte sopra sembrava serializzare correttamente le proprietà che si trovano sul prototipo di Error (perché getOwnPropertyNames()non include le proprietà ereditate). Inoltre non sono stato in grado di ridefinire le proprietà come una delle risposte suggerite.

Questa è la soluzione che mi è venuta in mente: utilizza lodash ma è possibile sostituire lodash con versioni generiche di tali funzioni.

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

Ecco il test che ho fatto in Chrome:

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

Stavo lavorando su un formato JSON per gli appendici di log e sono finito qui cercando di risolvere un problema simile. Dopo un po ', mi sono reso conto che avrei potuto semplicemente fare in modo che Node facesse il lavoro:

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