¿No es posible stringificar un error usando JSON.stringify?

Reproduciendo el problema

Me encuentro con un problema al intentar pasar mensajes de error usando los sockets web. Puedo replicar el problema que estoy usando JSON.stringifypara atender a un público más amplio:

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

El problema es que termino con un objeto vacío.

Lo que he intentado

Navegadores

Primero intenté dejar node.js y ejecutarlo en varios navegadores. La versión 28 de Chrome me da el mismo resultado y, curiosamente, Firefox por lo menos hace un intento pero dejó el mensaje:

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

Función de reemplazo

Luego miré el prototipo Error.prototype . Muestra que el prototipo contiene métodos como toString y toSource . Sabiendo que las funciones no pueden ser encadenadas, incluí una función de reemplazo al llamar a JSON.stringify para eliminar todas las funciones, pero luego me di cuenta de que también tenía un comportamiento extraño:

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

No parece recorrer el objeto como lo haría normalmente, y por lo tanto no puedo verificar si la tecla es una función e ignorarla.

La pregunta

¿Hay alguna forma de stringificar mensajes de error nativos con JSON.stringify? Si no, ¿por qué ocurre este comportamiento?

Métodos para evitar esto

• Quédese con mensajes de error simples basados ​​en cadenas, o cree objetos de error personales y no confíe en el objeto de error nativo.
• Propiedades de extracción: JSON.stringify({ message: error.message, stack: error.stack })

Actualizaciones

@ Ray Toal Sugerido en un comentario que eche un vistazo a los descriptores de propiedades . Ahora está claro por qué no funciona:

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

Salida:

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 }

Clave: enumerable: false.

La respuesta aceptada proporciona una solución para este problema.

Puede definir un Error.prototype.toJSONpara recuperar un plano que Objectrepresenta el 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"}

Usar Object.defineProperty()agrega toJSONsin que sea una enumerablepropiedad en sí misma.

Con respecto a la modificación Error.prototype, aunque toJSON()puede no estar definido Errorespecíficamente para s, el método todavía está estandarizado para los objetos en general (ref: paso 3). Por lo tanto, el riesgo de colisiones o conflictos es mínimo.

Sin embargo, todavía a evitarlo por completo, JSON.stringify()'s replacerparámetro se puede utilizar en su lugar:

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

parece funcionar

[ de un comentario de / u / ub3rgeek en / r / javascript ] y el comentario de felixfbecker a continuación

Como nadie está hablando de la parte del porqué , la responderé.

¿Por qué esto JSON.stringifydevuelve un objeto vacío?

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

Responder

Del documento de JSON.stringify () ,

Para todas las demás instancias de Object (incluidos Map, Set, WeakMap y WeakSet), solo se serializarán sus propiedades enumerables.

y el Errorobjeto no tiene sus propiedades enumerables, es por eso que imprime un objeto vacío.

Modificando la gran respuesta de Jonathan para evitar parches de monos:

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

Hay un gran paquete Node.js para que: serialize-error.

Maneja bien incluso los objetos de error anidados, lo que realmente necesitaba mucho en mi proyecto.

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

También puede redefinir esas propiedades no enumerables para que sean enumerables.

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

y quizás stackpropiedad también.

Necesitábamos serializar una jerarquía de objetos arbitraria, donde la raíz o cualquiera de las propiedades anidadas en la jerarquía podrían ser instancias de Error.

Nuestra solución fue usar el replacerparámetro de JSON.stringify(), por ejemplo:

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

Ninguna de las respuestas anteriores parece serializar correctamente las propiedades que están en el prototipo de Error (porque getOwnPropertyNames()no incluye las propiedades heredadas). Tampoco pude redefinir las propiedades como una de las respuestas sugeridas.

Esta es la solución que se me ocurrió: utiliza lodash, pero podría reemplazarlo con versiones genéricas de esas funciones.

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

Aquí está la prueba que hice en 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}}}  

Estaba trabajando en un formato JSON para agregadores de registro y terminé aquí tratando de resolver un problema similar. Después de un tiempo, me di cuenta de que podía hacer que Node hiciera el trabajo:

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