Não é possível restringir um erro usando JSON.stringify?

Reproduzindo o problema

Estou com um problema ao tentar passar mensagens de erro usando soquetes da web. Posso replicar o problema que estou enfrentando JSON.stringifypara atender a um público mais amplo:

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

O problema é que eu acabo com um objeto vazio.

O que eu tentei

Navegadores

Tentei sair do node.js e executá-lo em vários navegadores. A versão 28 do Chrome me dá o mesmo resultado e, curiosamente, o Firefox pelo menos tenta, mas deixa de fora a mensagem:

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

Função substituidora

Então olhei para o erro.protótipo . Isso mostra que o protótipo contém métodos como toString e toSource . Sabendo que as funções não podem ser restringidas, incluí uma função substituta ao chamar JSON.stringify para remover todas as funções, mas depois percebi que ela também tinha um comportamento estranho:

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

Parece não fazer um loop sobre o objeto como faria normalmente e, portanto, não posso verificar se a chave é uma função e ignorá-la.

A questão

Existe alguma maneira de restringir mensagens de erro nativas com JSON.stringify? Caso contrário, por que esse comportamento ocorre?

Métodos para contornar isso

• Atenha-se a mensagens de erro simples baseadas em string ou crie objetos de erro pessoais e não confie no objeto Error nativo.
• Propriedades de extração: JSON.stringify({ message: error.message, stack: error.stack })

Atualizações

@Ray Toal Sugerido em um comentário que dê uma olhada nos descritores de propriedades . Agora está claro por que não 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);
}

Resultado:

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.

A resposta aceita fornece uma solução alternativa para esse problema.

Você pode definir a Error.prototype.toJSONpara recuperar uma planície Objectrepresentando 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"}

O uso de Object.defineProperty()adiciona toJSONsem que seja uma enumerablepropriedade em si.

Em relação à modificação Error.prototype, embora toJSON()não possa ser definido Errorespecificamente para s, o método ainda é padronizado para objetos em geral (ref: etapa 3). Portanto, o risco de colisões ou conflitos é mínimo.

Porém, para evitá-lo completamente, JSON.stringify()o replacerparâmetro pode ser usado:

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 um comentário de / u / ub3rgeek em / r / javascript ] e o comentário de felixfbecker abaixo

Como ninguém está falando sobre a parte do porquê , eu vou responder.

Por que isso JSON.stringifyretorna um objeto vazio?

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

Responda

No documento JSON.stringify () ,

Para todas as outras instâncias de objeto (incluindo Map, Set, WeakMap e WeakSet), apenas suas propriedades enumeráveis ​​serão serializadas.

e o Errorobjeto não tem suas propriedades enumeráveis, é por isso que imprime um objeto vazio.

Modificando a ótima resposta de Jonathan para evitar o patch de macacos:

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

Há um grande pacote Node.js para que: serialize-error.

Ele lida com objetos de erro bem aninhados, o que eu realmente precisava de muito no meu projeto.

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

Você também pode redefinir as propriedades não enumeráveis ​​para serem enumeráveis.

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

e talvez stackpropriedade também.

Precisávamos serializar uma hierarquia arbitrária de objetos, onde a raiz ou qualquer uma das propriedades aninhadas na hierarquia poderia ser instâncias de Error.

Nossa solução foi usar os replacerparâmetros de JSON.stringify(), por exemplo:

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

Nenhuma das respostas acima parecia serializar corretamente as propriedades que estão no protótipo de Erro (porque getOwnPropertyNames()não inclui propriedades herdadas). Também não consegui redefinir as propriedades como uma das respostas sugeridas.

Esta é a solução que eu encontrei - ele usa o lodash, mas você pode substituí-lo por versões genéricas dessas funções.

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

Aqui está o teste que fiz no 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}}}  

Eu estava trabalhando em um formato JSON para anexadores de log e acabei aqui tentando resolver um problema semelhante. Depois de um tempo, percebi que podia fazer o Node fazer o trabalho:

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