JSON.stringifyを使用してエラーを文字列化することはできませんか？

問題を再現する

Webソケットを使用してエラーメッセージを渡そうとすると、問題が発生します。私が直面しJSON.stringifyている問題を再現して、より幅広い聴衆に対応することができます。

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

問題は、オブジェクトが空になることです。

私が試したこと

ブラウザー

最初にnode.jsを終了し、さまざまなブラウザーで実行してみました。Chromeバージョン28でも同じ結果が得られますが、興味深いことに、Firefoxは少なくとも試みを行っていますが、メッセージは省略しています。

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

交換機能

次に、Error.prototypeを調べました。これは、プロトタイプにtoStringやtoSourceなどのメソッドが含まれていることを示しています。関数は文字列化できないことを知っているので、JSON.stringifyを呼び出してすべての関数を削除するときに置換関数を含めましたが、それでも奇妙な動作があることに気付きました。

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

通常のようにオブジェクトをループするようには見えないため、キーが関数であるかどうかを確認して無視することはできません。

質問

ネイティブエラーメッセージを文字列化する方法はありますJSON.stringifyか？そうでない場合、なぜこの動作が発生するのですか？

これを回避する方法

• 単純な文字列ベースのエラーメッセージを使用するか、個人的なエラーオブジェクトを作成し、ネイティブのErrorオブジェクトに依存しないでください。
• プルプロパティ： JSON.stringify({ message: error.message, stack: error.stack })

アップデート

@Ray Toal私はプロパティ記述子を見るコメントで提案されました。それが機能しない理由は今では明らかです：

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

出力：

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 }

キー：enumerable: false。

受け入れられた回答は、この問題の回避策を提供します。

を定義して、Error.prototype.toJSONをObject表すプレーンを取得できます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"}

プロパティそのものでObject.defineProperty()はtoJSONなく、adds を使用しますenumerable。

修飾についてError.prototype、しばらくはtoJSON()のために定義されない場合がありError、具体的に、複数の方法がまだ標準化されて（ステップ3：REF）一般に、オブジェクトに対して。したがって、衝突や衝突のリスクは最小限です。

ただし、完全に回避するには、代わりにJSON.stringify()のreplacerパラメータを使用できます。

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

うまくいくようです

[ / r / javascriptの/ u / ub3rgeekによるコメントから ]とfelixfbeckerのコメント

なぜその部分については誰も話していないので、私はそれに答えます。

なぜこれJSON.stringifyが空のオブジェクトを返すのですか？

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

回答

JSON.stringify（）のドキュメントから、

他のすべてのObjectインスタンス（Map、Set、WeakMap、WeakSetを含む）では、列挙可能なプロパティのみがシリアル化されます。

そしてErrorオブジェクトは空のオブジェクトを出力します理由です、その列挙可能な特性を持っていません。

モンキーパッチを回避するためにジョナサンの素晴らしい答えを変更します：

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

そのための優れたNode.jsパッケージがありますserialize-error。

ネストされたErrorオブジェクトも処理します。プロジェクトで実際に必要なものです。

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

また、列挙不可能なプロパティを列挙可能に再定義することもできます。

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

そしておそらくstack財産も。

ルートまたは階層内のネストされたプロパティのいずれかがエラーのインスタンスである可能性がある任意のオブジェクト階層をシリアル化する必要がありました。

私たちの解決策はのreplacerパラメータを使用することでしたJSON.stringify()、例えば：

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

上記の回答のいずれも、エラーのプロトタイプにあるプロパティを適切にシリアル化getOwnPropertyNames()していないようです（継承されたプロパティが含まれていないため）。また、提案された回答の1つとして、プロパティを再定義することもできませんでした。

これは私が思いついたソリューションです。lodashを使用しますが、lodashをこれらの関数の汎用バージョンに置き換えることができます。

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

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

私はログアペンダーのJSON形式に取り組んでおり、同様の問題を解決しようとしてここにたどり着きました。しばらくして、Nodeに機能させるだけでよいことに気づきました。

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