JSON.parse 和 JSON.stringify 不是幂等的，这很糟糕

Question

这个问题是多部分的-

(1a) JSON 是 JavaScript 的基础，那为什么没有 JSON 类型呢？ JSON 类型将是格式化为 JSON 的字符串。在数据被更改之前，它将被标记为已解析/字符串化。一旦数据被更改，它就不会被标记为 JSON，并且需要重新解析/重新字符串化。

(1b) 在某些软件系统中，是否可能（意外地）尝试通过网络发送纯 JS 对象而不是序列化 JS 对象？为什么不尝试避免这种情况呢？

(1c) 为什么我们不能在不先对 JavaScript 对象进行字符串化的情况下直接调用 JSON.parse？

    var json = {   //JS object in properJSON format
        "baz":{
            "1":1,
            "2":true,
            "3":{}
        }
    };

    var json0 = JSON.parse(json); //will throw a parse error...bad...it should not throw an error if json var is actually proper JSON.

所以我们别无选择，只能这样做：

 var json0= JSON.parse(JSON.stringify(json));

但是，也有一些不一致的地方，例如：

JSON.parse(true); //works
JSON.parse(null); //works
JSON.parse({}); //throws error

(2) 如果我们一直在同一个对象上调用JSON.parse，最终它会抛出一个错误。例如：

var json = {   //same object as above
    "baz":{
        "1":1,
        "2":true,
        "3":{}
    }
};

var json1 = JSON.parse(JSON.stringify(json));
var json2 = JSON.parse(json1); //throws an error...why

(3) 为什么JSON.stringify 会在输入中无限添加越来越多的斜线？不仅很难读取调试结果，而且实际上会使您处于危险状态，因为一次 JSON.parse 调用不会给您返回一个普通的 JS 对象，您必须多次调用 JSON.parse 才能取回普通的 JS 对象。这很糟糕，意味着在给定的 JS 对象上多次调用 JSON.stringify 是非常危险的。

   var json = {
        "baz":{
            "1":1,
            "2":true,
            "3":{}
        }
    };

    var json2 = JSON.stringify(json);
    console.log(json2);

    var json3 = JSON.stringify(json2);
    console.log(json3);

    var json4 = JSON.stringify(json3);
    console.log(json4);

    var json5 = JSON.stringify(json4);
    console.log(json5); 

(4) 我们应该能够在不改变结果的情况下一遍又一遍地调用的函数的名称是什么（IMO JSON.parse 和 JSON.stringify 应该如何表现）？正如您在 cmets 中看到的那样，最好的术语似乎是“幂等”。

(5) 考虑到 JSON 是一种可用于网络对象的序列化格式，你不能调用 JSON.parse 或 JSON.stringify 两次甚至一次，这似乎是完全疯狂的情况下不会产生一些问题。为什么会这样？

如果您正在为 Java、JavaScript 或任何语言发明下一个序列化格式，请考虑这个问题。

IMO 给定对象应该有两种状态。序列化状态和反序列化状态。在具有更强类型系统的软件语言中，这通常不是问题。但是对于 JavaScript 中的 JSON，如果在同一个对象上调用 JSON.parse 两次，我们会遇到致命的异常。同样，如果我们在同一个对象上调用 JSON.stringify 两次，我们可能会进入不可恢复的状态。就像我说的应该有两种状态，只有两种状态，普通 JS 对象和序列化 JS 对象。

Answer 1

1) JSON.parse 需要一个字符串，你给它一个 Javascript 对象。

2) 与第一个类似的问题。您将字符串提供给需要对象的函数。

3) Stringfy 实际上需要一个字符串，但你给它的是一个 String 对象。因此，它采用与第一个字符串相同的措施来转义引号和斜杠。以便语言可以理解字符串中的引号、其他特殊字符。

4) 您可以为此编写自己的函数。

5) 因为您试图进行非法转换。这与第一个和第二个问题有关。只要提供了正确的对象类型，您就可以根据需要多次调用它。唯一的问题是多余的斜线，但它实际上是标准的。

Answer 2

我们将从您创作的噩梦开始：字符串输入和整数输出。
IJSON.parse(IJSON.stringify("5")); //=> 5

内置的 JSON 函数不会以这种方式让我们失望：string 输入和 string 输出。
JSON.parse(JSON.stringify("5")); //=> "5"

JSON 必须保留您的原始数据类型

将JSON.stringify 视为将数据包装在一个盒子中的函数，将JSON.parse 视为将数据从盒子中取出的函数。

考虑以下几点：

var a = JSON.stringify;
var b = JSON.parse;

var data = "whatever";

b(a(data)) === data; // true

b(b(a(a(data)))) === data; // true

b(b(b(a(a(a(data)))))) === data; // true

也就是说，如果我们把数据放在 3 个盒子里，我们就得把它从 3 个盒子里拿出来。对吧？

如果我将数据放入 2 个框中并从 1 个中取出，我还没有持有我的数据，我持有的是一个包含我的数据的框。对吧？

b(a(a(data))) === data; // false

对我来说似乎很理智......

---

1. JSON.parse 将您的数据拆箱。如果没有装箱，则无法拆箱。 JSON.parse 需要一个字符串输入并且你给它一个 JavaScript 对象字面量

2. 对JSON.parse 的第一次有效调用将返回一个对象。在此对象输出上再次调用 JSON.parse 将导致与 #1 相同的失败

3. 重复调用JSON.stringify 将多次“装箱”我们的数据。因此，您当然必须重复调用JSON.parse，然后才能将数据从每个“盒子”中取出

4. Idempotence

5. 不，这是完全理智的。您不能在双重邮票上加三重邮票。

   你不会犯这样的错误吧？

   var json = IJSON.stringify("hi");
   IJSON.parse(json);
   //=> "hi"
   

   好的，这是幂等的，但是呢

   var json = IJSON.stringify("5");
   IJSON.parse(json);
   //=> 5
   

   呃哦！我们每次都给它一个字符串，但第二个示例返回一个整数。输入数据类型已丢失！

   JSON 函数会不会在这里让我们失望？

   var json = JSON.stringify("hi");
   JSON.parse(json);
   //=> "hi"
   

   一切都好。那么"5" 呢？

   var json = JSON.stringify("5");
   JSON.parse(json));
   //=> "5"
   

   是的，类型已被保留！JSON 有效，IJSON 无效。

---

也许是一个更真实的例子：

好的，所以你有一个繁忙的应用程序，有很多开发人员在开发它。它使 对基础数据类型的鲁莽假设。假设它是一个聊天应用程序，当消息从一个点移动到另一个点时，它会对消息进行多次转换。

一路走来：

1. IJSON.stringify
2. 数据在网络中移动
3. IJSON.parse
4. 另一个IJSON.parse 因为谁在乎？它是幂等的，对吗？
5. String.prototype.toUpperCase — 因为这是一种格式选择

让我们看看消息

bob: 'hi'
// 1) '"hi"', 2) <network>, 3) "hi", 4) "hi", 5) "HI"

Bob 的消息看起来不错。让我们看看爱丽丝的。

alice: '5'
// 1) '5'
// 2) <network>
// 3) 5
// 4) 5
// 5) Uncaught TypeError: message.toUpperCase is not a function

哦不！服务器刚刚崩溃。你会注意到这里甚至不是重复调用IJSON.parse 失败。即使你调用一次它也会失败。

似乎你从一开始就注定要失败......该死的鲁莽的开发人员和他们粗心的数据处理！

如果 Alice 使用任何碰巧也是有效 JSON 的输入，它将失败

alice: '{"lol":"pwnd"}'
// 1) '{"lol":"pwnd"}'
// 2) <network>
// 3) {lol:"pwnd"}
// 4) {lol:"pwnd"}
// 5) Uncaught TypeError: message.toUpperCase is not a function

---

好吧，也许是不公平的例子，对吧？你在想，“我没那么鲁莽，我 不会在这样的用户输入上调用IJSON.stringify 或IJSON.parse！” 没关系。您从根本上破坏了 JSON，因为原始 无法再提取类型。

如果我使用IJSON 将一个字符串装箱，然后将其拆箱，谁知道我会得到什么？当然不是你，当然也不是使用你鲁莽功能的开发者。

• “我会得到一个字符串类型吗？”
• “我会得到一个整数吗？”
• “也许我会得到一个对象？”
• “也许我会得到蛋糕。我希望是蛋糕”

无法判断！

您处于一个全新的痛苦世界，因为您从一开始就对数据类型不小心。您的类型很重要，因此请谨慎处理。

JSON.stringify 需要一个对象类型，JSON.parse 需要一个字符串类型。

现在你看到光了吗？

Answer 3

我将尝试为您提供一个原因，为什么不能在同一数据上多次调用 JSON.parse 而不会遇到问题。

您可能不知道，但 JSON 文档确实不是必须是一个对象。

这是一个有效的 JSON 文档：

"some text"

让我们将此文档的表示形式存储在 javascript 变量中：

var JSONDocumentAsString = '"some text"';

并继续努力：

var JSONdocument = JSON.parse(JSONDocumentAsString);
JSONdocument === 'some text';

这将导致错误，因为此字符串不是 JSON 文档的表示形式

JSON.parse(JSONdocument);
// SyntaxError: JSON.parse: unexpected character at line 1 column 1 of the JSON data

在这种情况下，JSON.parse 怎么会猜到 JSONdocument（作为一个字符串）是一个 JSON 文档并且应该原封不动地返回它？