Is it not possible to stringify an Error using JSO

问题:

Reproducing the problem

I\'m running into an issue when trying to pass error messages around using web sockets. I can replicate the issue I am facing using JSON.stringify to cater to a wider audience:

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

The problem is that I end up with an empty object.

What I\'ve tried

Browsers

I first tried leaving node.js and running it in various browsers. Chrome version 28 gives me the same result, and interestingly enough, Firefox at least makes an attempt but left out the message:

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

Replacer function

I then looked at the Error.prototype. It shows that the prototype contains methods such as toString and toSource. Knowing that functions can\'t be stringified, I included a replacer function when calling JSON.stringify to remove all functions, but then realized that it too had some weird behavior:

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

It doesn\'t seem to loop over the object as it normally would, and therefore I can\'t check if the key is a function and ignore it.

The Question

Is there any way to stringify native Error messages with JSON.stringify? If not, why does this behavior occur?

Methods of getting around this

• Stick with simple string-based error messages, or create personal error objects and don\'t rely on the native Error object.
• Pull properties: JSON.stringify({ message: error.message, stack: error.stack })

Updates

@Ray Toal Suggested in a comment that I take a look at the property descriptors. It is clear now why it does not work:

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

Output:

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 }

Key: enumerable: false.

Accepted answer provides a workaround for this problem.

回答1:

You can define a Error.prototype.toJSON to retrieve a plain Object representing the 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\"}

Using Object.defineProperty() adds toJSON without it being an enumerable property itself.

---

Regarding modifying Error.prototype, while toJSON() may not be defined for Errors specifically, the method is still standardized for objects in general (ref: step 3). So, the risk of collisions or conflicts is minimal.

Though, to still avoid it completely, JSON.stringify()\'s replacer parameter can be used instead:

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

回答2:

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

seems to work

[from a comment by /u/ub3rgeek on /r/javascript] and felixfbecker\'s comment below

回答3:

Modifying Jonathan\'s great answer to avoid monkey patching:

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

回答4:

You can also just redefine those non-enumerable properties to be enumerable.

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

and maybe stack property too.

回答5:

As no one is talking about the why part, I\'m gonna answer these

Q: Is there any way to stringify native Error messages with JSON.stringify?

No.

Q: If not, why does this behavior occur?

From the document of JSON.stringify(),

For all the other Object instances (including Map, Set, WeakMap and WeakSet), only their enumerable properties will be serialized.

and Error object doesn\'t have its enumerable properties, that\'s why it prints an empty object.

回答6:

There is a great Node.js package for that: serialize-error.

It handles well even nested Error objects, what I actually I needed much in my project.

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

回答7:

None of the answers above seemed to properly serialize properties which are on the prototype of Error (because getOwnPropertyNames() does not include inherited properties). I was also not able to redefine the properties like one of the answers suggested.

This is the solution I came up with - it uses lodash but you could replace lodash with generic versions of those functions.

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

Here\'s the test I did 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}}}  

回答8:

We needed to serialise an arbitrary object hierarchy, where the root or any of the nested properties in the hierarchy could be instances of Error.

Our solution was to use the replacer param of JSON.stringify(), e.g.:

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