Có thể xâu chuỗi một Lỗi bằng cách sử dụng JSON.opesify không?

Tái tạo vấn đề

Tôi đang gặp vấn đề khi cố gắng truyền thông báo lỗi xung quanh bằng cách sử dụng ổ cắm web. Tôi có thể sao chép vấn đề tôi đang gặp phải JSON.stringifyđể sử dụng cho đối tượng rộng hơn:

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

Vấn đề là tôi kết thúc với một đối tượng trống rỗng.

Những gì tôi đã thử

Trình duyệt

Trước tiên tôi đã thử rời node.js và chạy nó trong các trình duyệt khác nhau. Chrome phiên bản 28 cho tôi kết quả tương tự, và thật thú vị, Firefox ít nhất cũng cố gắng nhưng bỏ qua thông báo:

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

Chức năng thay thế

Sau đó tôi nhìn vào Error.prototype . Nó cho thấy nguyên mẫu chứa các phương thức như toString và toSource . Biết rằng các hàm không thể được xâu chuỗi, tôi đã bao gồm một hàm thay thế khi gọi JSON.opesify để xóa tất cả các hàm, nhưng sau đó nhận ra rằng nó cũng có một số hành vi kỳ lạ:

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

Nó dường như không lặp lại đối tượng như bình thường, và do đó tôi không thể kiểm tra xem khóa có phải là hàm không và bỏ qua nó.

Câu hỏi

Có cách nào để xâu chuỗi các thông báo Lỗi gốc JSON.stringifykhông? Nếu không, tại sao hành vi này xảy ra?

Phương pháp khắc phục điều này

• Gắn bó với các thông báo lỗi dựa trên chuỗi đơn giản hoặc tạo các đối tượng lỗi cá nhân và không dựa vào đối tượng Lỗi gốc.
• Kéo thuộc tính: JSON.stringify({ message: error.message, stack: error.stack })

Cập nhật

@Ray Toal Đề xuất trong một nhận xét rằng tôi hãy xem các mô tả tài sản . Bây giờ rõ ràng tại sao nó không hoạt động:

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

Đầu ra:

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 }

Phím : enumerable: false.

Câu trả lời được chấp nhận cung cấp một cách giải quyết cho vấn đề này.

Bạn có thể xác định một Error.prototype.toJSONđể lấy một đồng bằng Objectđại diện cho 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"}

Sử dụng Object.defineProperty()thêm toJSONmà không có nó là một enumerabletài sản chính nó.

Về sửa đổi Error.prototype, trong khi toJSON()có thể không được xác định Errorcụ thể cho s, phương thức vẫn được chuẩn hóa cho các đối tượng nói chung (ref: bước 3). Vì vậy, nguy cơ va chạm hoặc xung đột là tối thiểu.

Mặc dù vậy, vẫn còn tránh nó hoàn toàn, JSON.stringify()của replacertham số có thể được sử dụng thay vì:

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

dường như làm việc

[ từ một nhận xét của / u / ub3rgeek trên / r / javascript ] và bình luận của felixfbeck bên dưới

Vì không ai nói về lý do tại sao , tôi sẽ trả lời nó.

Tại sao điều này JSON.stringifytrả về một đối tượng trống?

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

Câu trả lời

Từ tài liệu của JSON.opesify () ,

Đối với tất cả các phiên bản Đối tượng khác (bao gồm Map, Set, WeakMap và Weakset), chỉ các thuộc tính có thể đếm được của chúng sẽ được tuần tự hóa.

và Errorđối tượng không có thuộc tính vô số, đó là lý do tại sao nó in một đối tượng trống.

Sửa đổi câu trả lời tuyệt vời của Jonathan để tránh vá khỉ:

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

Có một gói Node.js tuyệt vời cho điều đó : serialize-error.

Nó xử lý tốt các đối tượng Error thậm chí lồng nhau, điều mà tôi thực sự cần nhiều trong dự án của mình.

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

Bạn cũng có thể xác định lại các thuộc tính không thể đếm được thành vô số.

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

và có thể stacktài sản quá.

Chúng ta cần tuần tự hóa một hệ thống phân cấp đối tượng tùy ý, trong đó gốc hoặc bất kỳ thuộc tính lồng nhau nào trong cấu trúc phân cấp có thể là các trường hợp Lỗi.

Giải pháp của chúng tôi là sử dụng replacerparam của JSON.stringify(), ví dụ:

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

Không có câu trả lời nào ở trên dường như tuần tự hóa các thuộc tính đúng trên nguyên mẫu Lỗi (vì getOwnPropertyNames()không bao gồm các thuộc tính được kế thừa). Tôi cũng không thể xác định lại các thuộc tính như một trong những câu trả lời được đề xuất.

Đây là giải pháp tôi đã đưa ra - nó sử dụng lodash nhưng bạn có thể thay thế lodash bằng các phiên bản chung của các chức năng đó.

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

Đây là thử nghiệm tôi đã làm trong 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}}}  

Tôi đã làm việc trên một định dạng JSON cho các ứng dụng đăng nhập và kết thúc ở đây để cố gắng giải quyết một vấn đề tương tự. Sau một thời gian, tôi nhận ra rằng tôi có thể khiến Node thực hiện công việc:

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