Sự kỳ lạ của mảng JSON.stringify () với Prototype.js

Tôi đang cố gắng tìm ra vấn đề xảy ra với việc tuần tự hóa json của mình, có phiên bản ứng dụng hiện tại và phiên bản cũ và tôi đang tìm thấy một số khác biệt đáng ngạc nhiên trong cách JSON.stringify () hoạt động (Sử dụng thư viện JSON từ json.org ).

Trong phiên bản cũ của ứng dụng của tôi:

 JSON.stringify({"a":[1,2]})

cho tôi cái này;

"{\"a\":[1,2]}"

trong phiên bản mới,

 JSON.stringify({"a":[1,2]})

cho tôi cái này;

"{\"a\":\"[1, 2]\"}"

bất kỳ ý tưởng nào có thể đã thay đổi để làm cho cùng một thư viện đặt dấu ngoặc nhọn xung quanh dấu ngoặc mảng trong phiên bản mới?

Vì JSON.stringify gần đây đã được vận chuyển với một số trình duyệt, tôi khuyên bạn nên sử dụng nó thay vì toJSON của Prototype. Sau đó, bạn sẽ kiểm tra window.JSON && window.JSON.stringify và chỉ bao gồm thư viện json.org nếu không (thông qua document.createElement('script')…). Để giải quyết sự không tương thích, hãy sử dụng:

if(window.Prototype) {
    delete Object.prototype.toJSON;
    delete Array.prototype.toJSON;
    delete Hash.prototype.toJSON;
    delete String.prototype.toJSON;
}

Hàm JSON.stringify () được định nghĩa trong ECMAScript 5 trở lên (Trang 201 - Đối tượng JSON, mã giả Trang 205) , sử dụng hàm toJSON () khi có sẵn trên các đối tượng.

Vì Prototype.js (hoặc một thư viện khác mà bạn đang sử dụng) định nghĩa một hàm Array.prototype.toJSON (), các mảng trước tiên được chuyển đổi thành chuỗi bằng cách sử dụng Array.prototype.toJSON () sau đó chuỗi được trích dẫn bởi JSON.stringify (), do đó dấu ngoặc kép không chính xác xung quanh các mảng.

Do đó, giải pháp dễ hiểu và đơn giản (đây là phiên bản đơn giản hóa câu trả lời của Raphael Schweikert):

delete Array.prototype.toJSON

Tất nhiên, điều này tạo ra các hiệu ứng phụ trên các thư viện dựa vào thuộc tính hàm toJSON () cho các mảng. Nhưng tôi thấy đây là một sự bất tiện nhỏ do tính không tương thích với ECMAScript 5.

Cần lưu ý rằng Đối tượng JSON được định nghĩa trong ECMAScript 5 được triển khai hiệu quả trong các trình duyệt hiện đại và do đó giải pháp tốt nhất là tuân thủ tiêu chuẩn và sửa đổi các thư viện hiện có.

Một giải pháp khả thi sẽ không ảnh hưởng đến các phụ thuộc Prototype khác sẽ là:

var _json_stringify = JSON.stringify;
JSON.stringify = function(value) {
    var _array_tojson = Array.prototype.toJSON;
    delete Array.prototype.toJSON;
    var r=_json_stringify(value);
    Array.prototype.toJSON = _array_tojson;
    return r;
};

Điều này xử lý sự không tương thích của Array toJSON với JSON.stringify và cũng giữ lại chức năng của toJSON vì các thư viện Prototype khác có thể phụ thuộc vào nó.

Chỉnh sửa để chính xác hơn một chút:

Chốt mã vấn đề nằm trong thư viện JSON từ JSON.org (và các triển khai khác của đối tượng JSON của ECMAScript 5):

if (value && typeof value === 'object' &&
  typeof value.toJSON === 'function') {
  value = value.toJSON(key);
}

Vấn đề là thư viện Prototype mở rộng Array để bao gồm một phương thức toJSON, mà đối tượng JSON sẽ gọi trong đoạn mã trên. Khi đối tượng JSON chạm vào giá trị mảng, nó gọi tớiJSON trên mảng được xác định trong Nguyên mẫu và phương thức đó trả về phiên bản chuỗi của mảng. Do đó, dấu ngoặc kép xung quanh dấu ngoặc mảng.

Nếu bạn xóa toJSON khỏi đối tượng Mảng, thư viện JSON sẽ hoạt động bình thường. Hoặc, chỉ cần sử dụng thư viện JSON.

Tôi nghĩ rằng một giải pháp tốt hơn sẽ là bao gồm điều này ngay sau khi nguyên mẫu đã được tải

JSON = JSON || {};

JSON.stringify = function(value) { return value.toJSON(); };

JSON.parse = JSON.parse || function(jsonsring) { return jsonsring.evalJSON(true); };

Điều này làm cho hàm nguyên mẫu có sẵn dưới dạng JSON.stringify () và JSON.parse () tiêu chuẩn, nhưng vẫn giữ nguyên JSON.parse () nếu có sẵn, vì vậy điều này làm cho mọi thứ tương thích hơn với các trình duyệt cũ hơn.

Tôi không thông thạo lắm với Prototype, nhưng tôi đã thấy điều này trong tài liệu của nó :

Object.toJSON({"a":[1,2]})

Tuy nhiên, tôi không chắc liệu điều này có gặp phải vấn đề tương tự như mã hóa hiện tại hay không.

Ngoài ra còn có một hướng dẫn dài hơn về cách sử dụng JSON với Prototype.

Đây là mã tôi đã sử dụng cho cùng một vấn đề:

function stringify(object){
      var Prototype = window.Prototype
      if (Prototype && Prototype.Version < '1.7' &&
          Array.prototype.toJSON && Object.toJSON){
              return Object.toJSON(object)
      }
      return JSON.stringify(object)
}

Bạn kiểm tra xem Prototype có tồn tại hay không, sau đó bạn kiểm tra phiên bản. Nếu phiên bản cũ sử dụng Object.toJSON (nếu được định nghĩa) trong tất cả các trường hợp khác thì dự phòng cho JSON.stringify ()

Đây là cách tôi đối phó với nó.

var methodCallString =  Object.toJSON? Object.toJSON(options.jsonMethodCall) :  JSON.stringify(options.jsonMethodCall);

Giải pháp khoan dung của tôi sẽ kiểm tra xem Array.prototype.toJSON có gây hại cho JSON stringify hay không và giữ nó khi có thể để mã xung quanh hoạt động như mong đợi:

var dummy = { data: [{hello: 'world'}] }, test = {};

if(Array.prototype.toJSON) {
    try {
        test = JSON.parse(JSON.stringify(dummy));
        if(!test || dummy.data !== test.data) {
            delete Array.prototype.toJSON;
        }
    } catch(e) {
        // there only hope
    }
}

Như mọi người đã chỉ ra, điều này là do Prototype.js - cụ thể là các phiên bản trước 1.7. Tôi đã gặp trường hợp tương tự nhưng phải có mã hoạt động cho dù Prototype.js có ở đó hay không; điều này có nghĩa là tôi không thể xóa Array.prototype.toJSON vì tôi không chắc cái gì dựa vào nó. Đối với tình huống đó, đây là giải pháp tốt nhất mà tôi đã đưa ra:

function safeToJSON(item){ 
    if ([1,2,3] === JSON.parse(JSON.stringify([1,2,3]))){
        return JSON.stringify(item); //sane behavior
    } else { 
        return item.toJSON(); // Prototype.js nonsense
    }
}

Hy vọng rằng nó sẽ giúp một ai đó.

Nếu bạn không muốn giết mọi thứ và có một mã có thể sử dụng được trên hầu hết các trình duyệt, bạn có thể thực hiện theo cách này:

(function (undefined) { // This is just to limit _json_stringify to this scope and to redefine undefined in case it was
  if (true ||typeof (Prototype) !== 'undefined') {
    // First, ensure we can access the prototype of an object.
    // See http://stackoverflow.com/questions/7662147/how-to-access-object-prototype-in-javascript
    if(typeof (Object.getPrototypeOf) === 'undefined') {
      if(({}).__proto__ === Object.prototype && ([]).__proto__ === Array.prototype) {
        Object.getPrototypeOf = function getPrototypeOf (object) {
          return object.__proto__;
        };
      } else {
        Object.getPrototypeOf = function getPrototypeOf (object) {
          // May break if the constructor has been changed or removed
          return object.constructor ? object.constructor.prototype : undefined;
        }
      }
    }

    var _json_stringify = JSON.stringify; // We save the actual JSON.stringify
    JSON.stringify = function stringify (obj) {
      var obj_prototype = Object.getPrototypeOf(obj),
          old_json = obj_prototype.toJSON, // We save the toJSON of the object
          res = null;
      if (old_json) { // If toJSON exists on the object
        obj_prototype.toJSON = undefined;
      }
      res = _json_stringify.apply(this, arguments);
      if (old_json)
        obj_prototype.toJSON = old_json;
      return res;
    };
  }
}.call(this));

Điều này có vẻ phức tạp, nhưng điều này chỉ phức tạp để xử lý hầu hết các trường hợp sử dụng. Ý tưởng chính là ghi đè JSON.stringifyđể xóa toJSONkhỏi đối tượng được truyền dưới dạng đối số, sau đó gọi đối tượng cũ JSON.stringify, và cuối cùng khôi phục nó.