N'est-il pas possible de stringifier une erreur en utilisant JSON.stringify?

Reproduire le problème

Je rencontre un problème lorsque j'essaie de transmettre des messages d'erreur concernant l'utilisation des sockets Web. Je peux reproduire le problème auquel je fais face JSON.stringifypour répondre à un public plus large:

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

Le problème est que je me retrouve avec un objet vide.

Ce que j'ai essayé

Navigateurs

J'ai d'abord essayé de quitter node.js et de l'exécuter dans divers navigateurs. La version 28 de Chrome me donne le même résultat et, chose intéressante, Firefox fait au moins une tentative mais laisse de côté le message:

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

Fonction de remplacement

J'ai ensuite regardé le prototype Error.prototype . Il montre que le prototype contient des méthodes telles que toString et toSource . Sachant que les fonctions ne peuvent pas être stringifiées, j'ai inclus une fonction de remplacement lors de l'appel de JSON.stringify pour supprimer toutes les fonctions, mais ensuite réalisé qu'elle avait également un comportement étrange:

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

Il ne semble pas boucler sur l'objet comme il le ferait normalement, et donc je ne peux pas vérifier si la clé est une fonction et l'ignorer.

La question

Existe-t-il un moyen de filtrer les messages d'erreur natifs avec JSON.stringify ? Sinon, pourquoi ce problème se produit-il?

Méthodes pour contourner ce problème

• Restez avec des messages d'erreur simples basés sur des chaînes ou créez des objets d'erreur personnels et ne vous fiez pas à l'objet d'erreur natif.
• Propriétés de traction: JSON.stringify({ message: error.message, stack: error.stack })

Mises à jour

@Ray Toal Suggéré dans un commentaire que je regarde les descripteurs de propriété . Il est maintenant clair pourquoi cela ne fonctionne pas:

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

Production:

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.

La réponse acceptée fournit une solution de contournement à ce problème.

Vous pouvez définir un Error.prototype.toJSONpour récupérer une plaine Objectreprésentant 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"}

Utiliser Object.defineProperty()ajoute toJSONsans que ce soit une enumerablepropriété elle-même.

En ce qui concerne la modification Error.prototype, même si elle toJSON()ne peut pas être définie Errorspécifiquement pour s, la méthode est toujours normalisée pour les objets en général (réf: étape 3). Ainsi, le risque de collisions ou de conflits est minime.

Cependant, pour l'éviter complètement, JSON.stringify()le replacerparamètre de peut être utilisé à la place:

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

semble fonctionner

[ extrait d'un commentaire de / u / ub3rgeek sur / r / javascript ] et du commentaire de felixfbecker ci-dessous

Comme personne ne parle de la partie pourquoi , je vais y répondre.

Pourquoi cela JSON.stringifyrenvoie un objet vide?

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

Répondre

Du document de JSON.stringify () ,

Pour toutes les autres instances d'objet (y compris Map, Set, WeakMap et WeakSet), seules leurs propriétés énumérables seront sérialisées.

et l' Errorobjet n'a pas ses propriétés énumérables, c'est pourquoi il imprime un objet vide.

Modification de la bonne réponse de Jonathan pour éviter les correctifs de singe:

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

Il existe un excellent package Node.js pour cela: serialize-error .

Il gère bien même les objets Error imbriqués, ce dont j'avais réellement besoin dans mon projet.

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

Vous pouvez également simplement redéfinir ces propriétés non énumérables pour qu'elles soient énumérables.

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

et peut-être stackaussi la propriété.

Nous avions besoin de sérialiser une hiérarchie d'objets arbitraires, où la racine ou l'une des propriétés imbriquées dans la hiérarchie pourrait être des instances d'Erreur.

Notre solution a été d'utiliser les replacerparamètres de JSON.stringify(), par exemple:

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

Aucune des réponses ci-dessus ne semble sérialiser correctement les propriétés qui se trouvent sur le prototype de l'erreur (car getOwnPropertyNames() n'inclut pas les propriétés héritées). Je n'ai pas non plus été en mesure de redéfinir les propriétés comme l'une des réponses suggérées.

C'est la solution que j'ai trouvée - elle utilise lodash mais vous pouvez remplacer lodash par des versions génériques de ces fonctions.

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

Voici le test que j'ai fait dans 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}}}  

Je travaillais sur un format JSON pour les ajouts de journaux et j'ai fini par essayer de résoudre un problème similaire. Après un certain temps, j'ai réalisé que je pouvais simplement faire faire le travail à Node:

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