可以在JSON中使用注释吗？

你不能。至少这是我快速浏览 json.org 的经验。

JSON 的语法在该页面上可视化。没有任何关于评论的注释。

不。

JSON 是纯数据的。如果包含注释，则它也必须是数据。

你可以有一个指定的数据元素，称为（或其他名称），使用 JSON 数据的应用应忽略该元素。"_comment"

在生成/接收 JSON 的进程中加入注释可能会更好，因为他们应该提前知道 JSON 数据是什么，或者至少知道它的结构。

但是，如果您决定：

{
   "_comment": "comment text goes here...",
   "glossary": {
      "title": "example glossary",
      "GlossDiv": {
         "title": "S",
         "GlossList": {
            "GlossEntry": {
               "ID": "SGML",
               "SortAs": "SGML",
               "GlossTerm": "Standard Generalized Markup Language",
               "Acronym": "SGML",
               "Abbrev": "ISO 8879:1986",
               "GlossDef": {
                  "para": "A meta-markup language, used to create markup languages such as DocBook.",
                  "GlossSeeAlso": ["GML", "XML"]
               },
               "GlossSee": "markup"
            }
         }
      }
   }
}

JSON 背后的理念是在应用程序之间提供简单的数据交换。这些通常是基于 Web 的，语言是 JavaScript。

它实际上并不允许这样的注释，但是，将注释作为数据中的名称/值对之一传递肯定会起作用，尽管该数据显然需要被解析代码忽略或专门处理。

综上所述，这并不是说JSON文件应该包含传统意义上的注释。它应该只是数据。

有关更多详细信息，请查看 JSON 网站。

如果您的文本文件（JSON 字符串）将被某个程序读取，那么在使用之前去除 C 或 C++ 样式的注释有多困难？

答：这将是一行。如果这样做，则可以将 JSON 文件用作配置文件。

如果您愿意，请添加评论;在解析或传输之前，用缩小器将它们剥离。

我刚刚发布了 JSON.minify（），它从 JSON 块中去除注释和空格，并使其成为可以解析的有效 JSON。因此，您可以像这样使用它：

JSON.parse(JSON.minify(my_str));

当我发布它时，我遭到了人们的强烈反对，甚至不同意它的想法，所以我决定写一篇全面的博客文章，说明为什么评论在JSON中是有意义的。它包括来自 JSON 创建者的这条值得注意的评论：

假设您正在使用 JSON 来保存要注释的配置文件。继续并插入您喜欢的所有评论。然后通过 JSMin 管道传输它，然后再将其传递给 JSON 解析器。- 道格拉斯·克罗克福德，2012

希望这对那些不同意为什么 JSON.minify（） 有用的人有所帮助。

您应该改为编写 JSON 架构。JSON 模式目前是 Internet 规范草案的提议。除了文档之外，架构还可用于验证 JSON 数据。

例：

{
  "description": "A person",
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "age": {
      "type": "integer",
      "maximum": 125
    }
  }
}

您可以使用 description 架构属性提供文档。

不可以，不允许在 JSON 中使用表单或注释。这个答案是基于：//…/*…*/

• https://www.json.org
• RFC 4627： JavaScript 对象表示法 （JSON） 的媒体类型application/json
• RFC 8259JavaScript 对象表示法 （JSON） 数据交换格式（取代 RFC 4627、7158、7159）

Dojo Toolkit JavaScript 工具包（至少从 1.4 版开始）允许您在 JSON 中包含注释。注释可以采用格式。Dojo Toolkit 通过调用使用 JSON。/* */dojo.xhrGet()

其他 JavaScript 工具包可能以类似的方式工作。

在选择最终选项之前尝试替代数据结构（甚至数据列表）时，这会很有帮助。

我只是在配置文件中遇到这种情况。我不想使用XML（冗长，图形，丑陋，难以阅读）或“ini”格式（没有层次结构，没有真正的标准等）或Java“属性”格式（如.ini）。

JSON可以做他们能做的所有事情，但它不那么冗长，更易于人类阅读 - 而且解析器在许多语言中都很简单且无处不在。它只是一棵数据树。但是，带外注释通常是必要的，用于记录“默认”配置等。配置从来都不是“完整文档”，而是保存的数据树，在需要时可以由人类读取。

我想可以将 ，用于“有效”JSON。"#": "comment"

请考虑使用 YAML。它几乎是 JSON 的超集（几乎所有有效的 JSON 都是有效的 YAML），并且允许注释。

注释不是官方标准，尽管某些解析器支持 C++ 样式的注释。我使用的一种是 JsonCpp。在示例中，有这个：

// Configuration options
{
    // Default encoding for text
    "encoding" : "UTF-8",

    // Plug-ins loaded at start-up
    "plug-ins" : [
        "python",
        "c++",
        "ruby"
        ],

    // Tab indent size
    "indent" : { "length" : 3, "use_space": true }
}

jsonlint 不会验证这一点。因此，注释是特定于解析器的扩展，而不是标准。

另一个解析器是 JSON5。

JSON TOML 的替代方案。

另一种选择是 jsonc。

最新版本的 nlohmann/json 可选支持忽略解析时的注释。

注释是设计从JSON中删除的。

我从 JSON 中删除了注释，因为我看到人们使用它们来保存解析指令，这种做法会破坏互操作性。我知道缺乏评论会让一些人感到难过，但不应该。

假设您正在使用 JSON 来保存要注释的配置文件。继续并插入您喜欢的所有评论。然后通过 JSMin 管道传输它，然后再将其传递给 JSON 解析器。

资料来源：道格拉斯·克罗克福德（Douglas Crockford）在G+上的公开声明

这取决于您的 JSON 库。Json.NET 支持 JavaScript 样式的注释、./* commment */

请参阅另一个 Stack Overflow 问题。

JSON 对于配置文件和其他本地用法很有意义，因为它无处不在，而且比 XML 简单得多。

如果人们在交流数据时有充分的理由反对在JSON中使用注释（无论是否有效），那么JSON可以分为两部分：

• JSON-COM：JSON 在线，或通信 JSON 数据时应用的规则。
• JSON-DOC：JSON 文档，或文件中或本地的 JSON。定义有效 JSON 文档的规则。

JSON-DOC 将允许注释，并且可能存在其他细微的差异，例如处理空格。解析器可以轻松地从一个规范转换为另一个规范。

关于道格拉斯·克罗克福德（Douglas Crockford）就此问题发表的评论（由@Artur Czajka引用）

假设您正在使用 JSON 来保存要注释的配置文件。继续并插入您喜欢的所有评论。然后通过 JSMin 管道传输它，然后再将其传递给 JSON 解析器。

我们正在谈论一个通用的配置文件问题（跨语言/平台），他正在用一个特定于 JS 的实用程序来回答！

当然，特定于 JSON 的缩小可以在任何语言中实现， 但是要对此进行标准化，使其在所有语言和平台的解析器中无处不在，这样人们就不会浪费时间缺少该功能，因为他们有很好的用例，在在线论坛中查找问题，并让人们告诉他们这是一个坏主意，或者建议很容易实现从文本文件中剥离注释。

另一个问题是互操作性。假设您有一个库或 API 或任何类型的子系统，其中包含一些与之关联的配置或数据文件。这个子系统是 可以从不同的语言访问。然后你去告诉人们：顺便说一句 在将注释传递给解析器之前，不要忘记从 JSON 文件中删除注释！

其他答案指出 JSON 不支持注释，但这部分是不正确的：规范作者 Douglas Crokford 澄清说，JSON 解码器可以接受注释，只要它们被丢弃。

因此，制作自己的 JSON 解码器或至少是接受注释的预处理器，然后将它们剥离（只要您忽略注释并且不使用它们来指导应用程序应如何处理 JSON 数据），这是完全可以的，并且是一个公认的用例）。例如，这适用于存储在 JSON 中的配置文件，如下面的注释@toolbear所示。显然，由于 JSON 主要是一种数据传输格式，因此尽可能稀疏，因此如果您传输带有注释的 JSON 文件，最好先去除注释以节省网络带宽。

源：

JSON 没有注释。JSON 编码器不得输出注释。 JSON 解码器可以接受和忽略注释。

评论绝不应用于传递任何有意义的内容。那是 JSON 的用途。

2005 年，JSON 规范的作者 Douglas Crockford 在论坛帖子中发帖。

免责声明：您的保修无效

如前所述，此黑客利用了规范的实现。并非所有 JSON 解析器都能理解这种 JSON。尤其是流式解析器会窒息。

这是一个有趣的好奇心，但你真的不应该用它来做任何事情。以下是原始答案。

我发现了一个小技巧，它允许您在JSON文件中放置注释，而不会影响解析，也不会以任何方式更改所表示的数据。

似乎在声明对象文本时，您可以使用相同的键指定两个值，最后一个值优先。信不信由你，事实证明 JSON 解析器的工作方式相同。因此，我们可以使用它在源 JSON 中创建注释，这些注释不会出现在解析的对象表示中。

({a: 1, a: 2});
// => Object {a: 2}
Object.keys(JSON.parse('{"a": 1, "a": 2}')).length; 
// => 1

如果我们应用此技术，则注释的 JSON 文件可能如下所示：

{
  "api_host" : "The hostname of your API server. You may also specify the port.",
  "api_host" : "hodorhodor.com",

  "retry_interval" : "The interval in seconds between retrying failed API calls",
  "retry_interval" : 10,

  "auth_token" : "The authentication token. It is available in your developer dashboard under 'Settings'",
  "auth_token" : "5ad0eb93697215bc0d48a7b69aa6fb8b",

  "favorite_numbers": "An array containing my all-time favorite numbers",
  "favorite_numbers": [19, 13, 53]
}

上面的代码是有效的 JSON。如果你解析它，你会得到一个这样的对象：

{
    "api_host": "hodorhodor.com",
    "retry_interval": 10,
    "auth_token": "5ad0eb93697215bc0d48a7b69aa6fb8b",
    "favorite_numbers": [19,13,53]
}

这意味着评论没有痕迹，也不会有奇怪的副作用。

祝您黑客愉快！

您可以在 JSONP 中添加注释，但不能在纯 JSON 中使用注释。我刚刚花了一个小时试图让我的程序与 Highcharts 中的这个示例一起工作。

如果您点击链接，您将看到

?(/* AAPL historical OHLC data from the Google Finance API */
[
/* May 2006 */
[1147651200000,67.79],
[1147737600000,64.98],
...
[1368057600000,456.77],
[1368144000000,452.97]
]);

由于我的本地文件夹中有一个类似的文件，因此同源策略没有问题，所以我决定使用纯 JSON...当然，由于这些评论，它默默地失败了。$.getJSON

最终，我只是向上面的地址发送了一个手动 HTTP 请求，并意识到内容类型是因为 JSONP 返回纯 JavaScript。在这种情况下，允许评论。但是我的应用程序返回了 content-type ，所以我不得不删除注释。text/javascriptapplication/json

为了将 JSON 项目切成多个部分，我添加了“虚拟注释”行：

{

"#############################" : "Part1",

"data1"             : "value1",
"data2"             : "value2",

"#############################" : "Part2",

"data4"             : "value3",
"data3"             : "value4"

}

叹息。为什么不直接添加字段，例如

{
    "note1" : "This demonstrates the provision of annotations within a JSON file",
    "field1" : 12,
    "field2" : "some text",

    "note2" : "Add more annotations as necessary"
}

只要确保您的“notex”名称不与任何实际字段冲突即可。

JSON的作者希望我们在JSON中包含注释，但在解析它们之前将它们剥离（参见Michael Burr提供的链接）。如果JSON应该有注释，为什么不对它们进行标准化，让JSON解析器来完成这项工作呢？我不同意那里的逻辑，但是，唉，这就是标准。按照其他人的建议使用 YAML 解决方案是很好的，但它需要库依赖项。

如果你想去掉注释，但又不想有库依赖，这里有一个两行解决方案，它适用于 C++ 风格的注释，但可以适应其他注释：

var comments = new RegExp("//.*", 'mg');
data = JSON.parse(fs.readFileSync(sample_file, 'utf8').replace(comments, ''));

请注意，此解决方案只能在可以确定 JSON 数据不包含注释发起方的情况下使用，例如 （'//'）。

实现 JSON 解析、去除注释且无需额外库的另一种方法是在 JavaScript 解释器中评估 JSON。当然，这种方法需要注意的是，您只想评估未受污染的数据（没有不受信任的用户输入）。下面是 Node.js 中这种方法的示例——另一个警告，以下示例只会读取一次数据，然后它将被缓存：

data = require(fs.realpathSync(doctree_fp));

有一个很好的解决方案（hack），它是有效的 JSON，但它并非在所有情况下都有效（请参阅下面的评论）。 只需将同一密钥制作两次（或更多次）。例如：

{
  "param" : "This is the comment place",
  "param" : "This is value place",
}

因此，JSON 会将其理解为：

{
  "param" : "This is value place",
}

如果您使用 Jackson 作为 JSON 解析器，那么这就是您启用它以允许评论的方式：

ObjectMapper mapper = new ObjectMapper().configure(Feature.ALLOW_COMMENTS, true);

然后你可以有这样的评论：

{
  key: "value" // Comment
}

您还可以通过设置以下设置来发表评论：#

mapper.configure(Feature.ALLOW_YAML_COMMENTS, true);

但总的来说（如前所述），规范不允许注释。

JSON 不支持注释。它也从未打算用于需要注释的配置文件。

Hjson 是人类的配置文件格式。宽松的语法，更少的错误，更多的注释。

请参阅 JavaScript、Java、Python、PHP、Rust、Go、Ruby、C++ 和 C# 库的 hjson.github.io。

这是一个“你能”的问题。这是一个“是”的答案。

不可以，不应使用重复的对象成员将侧信道数据填充到 JSON 编码中。（请参阅 RFC 中的“对象中的名称应该是唯一的”）。

是的，你可以在 JSON 周围插入注释，你可以解析掉这些注释。

但是，如果您想要一种将任意侧信道数据插入和提取到有效 JSON 的方法，这里有一个答案。我们利用 JSON 编码中数据的非唯一表示形式。在RFC的第二节中，在“六个结构字符中的任何一个之前或之后允许空格”下，这是允许的^*。

^*RFC 仅声明“在六个结构字符中的任何一个之前或之后都允许使用空格”，没有明确提及字符串、数字、“false”、“true”和“null”。在所有实现中都会忽略此遗漏。

首先，通过缩小 JSON 来规范化它：

$jsonMin = json_encode(json_decode($json));

然后以二进制形式对注释进行编码：

$hex = unpack('H*', $comment);
$commentBinary = base_convert($hex[1], 16, 2);

然后隐藏你的二进制文件：

$steg = str_replace('0', ' ', $commentBinary);
$steg = str_replace('1', "\t", $steg);

这是您的输出：

$jsonWithComment = $steg . $jsonMin;

我刚刚找到了“grunt-strip-json-comments”。

“从 JSON 中剥离注释。它允许您在 JSON 文件中使用注释！

{
    // Rainbows
    "unicorn": /* ❤ */ "cake"
}

是的，你可以，但你的解析可能会失败（没有标准）。

要解析它，您应该删除这些注释，或者手动删除，或者使用正则表达式：

它替换任何注释，例如：

/****
 * Hey
 */

/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/

它替换任何注释，例如：

// Hey

/\/\/.*/

在 JavaScript 中，你可以做这样的事情：

jsonString = jsonString.replace(/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/, "").replace(/\/\/.*/,"")
var object = JSON.parse(jsonString);

如果您的上下文是 Node.js 配置，您可以考虑将 JavaScript via 作为 JSON 的替代方案：module.exports

module.exports = {
    "key": "value",

    // And with comments!
    "key2": "value2"
};

语法仍将相同。作为 JavaScript，文件扩展名应为 .require.js

如果将 Newtonsoft.Json 库与 ASP.NET 一起使用来读取/反序列化，则可以在 JSON 内容中使用注释：

“名称”： “字符串”

“id”：整数

或

/* 这是一个

评论示例 */

附言：只有 6+ 版本的 Newtonsoft Json 支持单行注释。

对于无法跳出框框思考的人的附加说明：我在我制作的 ASP.NET Web 应用程序中使用 JSON 格式进行基本设置。我读取了文件，将其转换为带有 Newtonsoft 库的设置对象，并在必要时使用它。

我更喜欢在 JSON 文件本身中写下关于每个单独设置的注释，我真的不关心 JSON 格式的完整性，只要我使用的库可以接受它。

我认为这是一种“更易于使用/理解”的方式，而不是创建单独的“设置”。README“文件并解释其中的设置。

如果您对这种使用有疑问;对不起，精灵不在灯里了。人们会发现 JSON 格式的其他用法，而您对此无能为力。

我们正在为我们的项目使用 strip-json-comments。它支持如下内容：

/*
 * Description 
*/
{
    // rainbows
    "unicorn": /* ❤ */ "cake"
}

只需像以下方式一样安装和使用它：npm install --save strip-json-comments

var strip_json_comments = require('strip-json-comments')
var json = '{/*rainbows*/"unicorn":"cake"}';
JSON.parse(strip_json_comments(json));
//=> {unicorn: 'cake'}

还有其他与 JSON 兼容的库，它们支持注释。

一个值得注意的例子是“Hashcorp 语言”（HCL）”。它是由制作流浪者、包装工、领事和保险库的同一个人编写的。

JSON 不是框架协议。它是一种无语言的格式。因此，没有为 JSON 定义注释的格式。

正如许多人所建议的那样，有一些技巧，例如，您可以使用重复的密钥或特定密钥。这取决于你。_comment

正如许多答案已经指出的那样，JSON本身没有注释。当然，有时你还是想要它们。对于 Python，有两种方法可以做到这一点，即使用 commentjson（仅适用于 Python 2）或 json_tricks（或用于 Python 2 和 Python 3），它还有其他几个功能。免责声明：我做了.#//#//json_tricks

如果使用 JSON5，则可以包含注释。

JSON5 是 JSON 的拟议扩展，旨在使人类更容易手动编写和维护。它通过直接从 ECMAScript 5 添加一些最小的语法功能来实现这一点。

不。JSON曾经支持注释，但它们被滥用并从标准中删除。

来自 JSON 的创建者：

我从 JSON 中删除了注释，因为我看到人们使用它们来保存解析指令，这种做法会破坏互操作性。我知道缺乏评论会让一些人感到难过，但不应该。- 道格拉斯·克罗克福德，2012

官方 JSON 站点位于 JSON.org。JSON被ECMA国际定义为标准。总有一个请愿程序来修改标准。由于多种原因，不太可能将注释添加到 JSON 标准中。

JSON的设计是XML的一种易于逆向工程（人工解析）的替代方案。它被简化到不需要注释的地步。它甚至不是一种标记语言。目标是稳定性和互操作性。

任何了解面向对象的“has-a”关系的人都可以理解任何JSON结构 - 这就是重点。它只是一个带有节点标签（键/值对）的有向无环图 （DAG），这是一种近乎通用的数据结构。

唯一需要的注解可能是“//这些是 DAG 标签”。键名称可以根据需要提供信息，允许任意语义。

任何平台都可以通过几行代码解析 JSON。XML 需要复杂的 OO 库，这些库在许多平台上都不可行。

注解只会降低 JSON 的互操作性。除非您真正需要的是标记语言 （XML），并且不在乎您的持久化数据是否易于解析，否则无需添加任何其他内容。

但是，正如 JSON 的创建者所观察到的那样，JS 管道一直支持注释：

继续并插入您喜欢的所有评论。 然后通过 JSMin 管道传输它，然后再将其传递给 JSON 解析器。- 道格拉斯·克罗克福德，2012

如果将 JSON 加载为文本文件，则可以使用带有注释的 JSON，然后删除注释。

例如，您可以使用 decomment 库。下面是一个完整的示例。

输入 JSON（文件 input.js）：

/*
* multi-line comments
**/
{
    "value": 123 // one-line comment
}

测试应用：

var decomment = require('decomment');
var fs = require('fs');

fs.readFile('input.js', 'utf8', function (err, data) {
    if (err) {
        console.log(err);
    } else {
        var text = decomment(data); // removing comments
        var json = JSON.parse(text); // parsing JSON
        console.log(json);
    }
});

输出：

{ value: 123 }

参见：gulp-decomment、grunt-decomment

您可以使用 JSON-LD 和 schema.org 注释类型来正确编写注释：

{
    "https://schema.org/comment": "this is a comment"
}

如果你使用的是 PHP，你可以使用这个函数在将 JSON 字符串解析为对象/数组之前，从 JSON 字符串中搜索和删除 // /* 类型注释：

function json_clean_decode($json, $assoc = true, $depth = 512, $options = 0) {
       // search and remove comments like /* */ and //
       $json = preg_replace("#(/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/)|([\s\t]//.*)|(^//.*)#", '', $json);

       if(version_compare(phpversion(), '5.4.0', '>=')) {
           $json = json_decode($json, $assoc, $depth, $options);
       }
       elseif(version_compare(phpversion(), '5.3.0', '>=')) {
           $json = json_decode($json, $assoc, $depth);
       }
       else {
           $json = json_decode($json, $assoc);
       }

       return $json;
   }

希望这有帮助！

就我而言，我需要在 JSON 输出之前使用注释进行调试。所以我把调试信息放在HTTP头中，以避免破坏客户端：

header("My-Json-Comment: Yes, I know it's a workaround ;-) ");

是的，您可以发表评论。但我不会推荐上面提到的任何原因。

我做了一些调查，我发现所有JSON要求方法都使用该方法。因此，我想出了一个解决方案：我们可以覆盖或围绕 JSON.parse 进行猴子修补。JSON.parse

注意：仅在 Node.js 上测试;-）

var oldParse = JSON.parse;
JSON.parse = parse;
function parse(json){
    json = json.replace(/\/\*.+\*\//, function(comment){
        console.log("comment:", comment);
        return "";
    });
    return oldParse(json)
}

JSON 文件：

{
  "test": 1
  /* Hello, babe */
}

您可以通过正则表达式使用简单的预处理。例如，以下函数将在 PHP 中解码注释的 JSON：

function json_decode_commented ($data, $objectsAsArrays = false, $maxDepth = 512, $opts = 0) {
  $data = preg_replace('~
    (" (?:[^"\\\\] | \\\\\\\\ | \\\\")*+ ") | \# [^\v]*+ | // [^\v]*+ | /\* .*? \*/
  ~xs', '$1', $data);

  return json_decode($data, $objectsAsArrays, $maxDepth, $opts);
}

它支持所有 PHP 样式的注释：/*、#、//。字符串文本按原样保留。

以下是我在 Google Firebase 文档中找到的内容，它允许您在 JSON 中添加注释：

{
  "//": "Some browsers will use this to enable push notifications.",
  "//": "It is the same for all projects, this is not your project's sender ID",
  "gcm_sender_id": "1234567890"
}

JSON本身不允许注释。这种推理是完全愚蠢的，因为您可以使用 JSON 本身来创建注释，这完全消除了推理，并且毫无理由地加载解析器数据空间，以获得完全相同的结果和潜在问题，例如：带有注释的 JSON 文件。

如果你尝试在里面放注释（例如，使用 // 或 /* */ 或 #），那么一些解析器会失败，因为严格来说，这不是 在 JSON 规范中。所以你永远不应该那样做。

例如，在这里，我的图像处理系统保存了图像符号和与之相关的一些基本格式化（注释）信息（在底部）：

{
    "Notations": [
        {
            "anchorX": 333,
            "anchorY": 265,
            "areaMode": "Ellipse",
            "extentX": 356,
            "extentY": 294,
            "opacity": 0.5,
            "text": "Elliptical area on top",
            "textX": 333,
            "textY": 265,
            "title": "Notation 1"
        },
        {
            "anchorX": 87,
            "anchorY": 385,
            "areaMode": "Rectangle",
            "extentX": 109,
            "extentY": 412,
            "opacity": 0.5,
            "text": "Rect area\non bottom",
            "textX": 98,
            "textY": 385,
            "title": "Notation 2"
        },
        {
            "anchorX": 69,
            "anchorY": 104,
            "areaMode": "Polygon",
            "extentX": 102,
            "extentY": 136,
            "opacity": 0.5,
            "pointList": [
                {
                    "i": 0,
                    "x": 83,
                    "y": 104
                },
                {
                    "i": 1,
                    "x": 69,
                    "y": 136
                },
                {
                    "i": 2,
                    "x": 102,
                    "y": 132
                },
                {
                    "i": 3,
                    "x": 83,
                    "y": 104
                }
            ],
            "text": "Simple polygon",
            "textX": 85,
            "textY": 104,
            "title": "Notation 3"
        }
    ],
    "imageXW": 512,
    "imageYW": 512,
    "imageName": "lena_std.ato",
    "tinyDocs": {
        "c01": "JSON image notation data:",
        "c02": "-------------------------",
        "c03": "",
        "c04": "This data contains image notations and related area",
        "c05": "selection information that provides a means for an",
        "c06": "image gallery to display notations with elliptical,",
        "c07": "rectangular, polygonal or freehand area indications",
        "c08": "over an image displayed to a gallery visitor.",
        "c09": "",
        "c10": "X and Y positions are all in image space. The image",
        "c11": "resolution is given as imageXW and imageYW, which",
        "c12": "you use to scale the notation areas to their proper",
        "c13": "locations and sizes for your display of the image,",
        "c14": "regardless of scale.",
        "c15": "",
        "c16": "For Ellipses, anchor is the  center of the ellipse,",
        "c17": "and the extents are the X and Y radii respectively.",
        "c18": "",
        "c19": "For Rectangles, the anchor is the top left and the",
        "c20": "extents are the bottom right.",
        "c21": "",
        "c22": "For Freehand and Polygon area modes, the pointList",
        "c23": "contains a series of numbered XY points. If the area",
        "c24": "is closed, the last point will be the same as the",
        "c25": "first, so all you have to be concerned with is drawing",
        "c26": "lines between the points in the list. Anchor and extent",
        "c27": "are set to the top left and bottom right of the indicated",
        "c28": "region, and can be used as a simplistic rectangular",
        "c29": "detect for the mouse hover position over these types",
        "c30": "of areas.",
        "c31": "",
        "c32": "The textx and texty positions provide basic positioning",
        "c33": "information to help you locate the text information",
        "c34": "in a reasonable location associated with the area",
        "c35": "indication.",
        "c36": "",
        "c37": "Opacity is a value between 0 and 1, where .5 represents",
        "c38": "a 50% opaque backdrop and 1.0 represents a fully opaque",
        "c39": "backdrop. Recommendation is that regions be drawn",
        "c40": "only if the user hovers the pointer over the image,",
        "c41": "and that the text associated with the regions be drawn",
        "c42": "only if the user hovers the pointer over the indicated",
        "c43": "region."
    }
}

*.json 文件通常用作配置文件或静态数据，因此需要注释→某些编辑器（如 NetBeans）接受 *.json 中的注释。

问题在于将内容解析为对象。解决方案是始终应用清理功能（服务器或客户端）。

###PHP

 $rgx_arr = ["/\/\/[^\n]*/sim", "/\/\*.*?\*\//sim", "/[\n\r\t]/sim"];
 $valid_json_str = \preg_replace($rgx_arr, '', file_get_contents(path . 'a_file.json'));

###JavaScript

valid_json_str = json_str.replace(/\/\/[^\n]*/gim,'').replace(/\/\*.*?\*\//gim,'')

2019 年 Visual Studio Code 用户的实际答案是使用“jsonc”扩展。

这是实用的，因为这是 Visual Studio Code 识别的扩展，用于指示“带注释的 JSON”。请在下面的评论中让我知道其他编辑器/IDE。

如果 Visual Studio Code 和其他编辑器也添加对 JSON5 的本机支持，那就太好了，但目前 Visual Studio Code 仅包含对“jsonc”的支持。

（在发布此内容之前，我搜索了所有答案，但没有提到“jsonc”。

当然，您可以注释 JSON。要从 JavaScript 中读取带注释的 JSON 文件，您可以在解析之前去除注释（请参阅下面的代码）。我相信这段代码可以改进，但对于那些使用正则表达式的人来说很容易理解。

我使用带注释的 JSON 文件为我的合成反射系统指定神经元形状。我还使用带注释的 JSON 来存储正在运行的神经元系统的中间状态。发表评论非常方便。不要听那些告诉你他们是个坏主意的说教者。

fetch(filename).then(function(response) {
    return response.text();
}).then(function(commented) {
    return commented.
        replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '$1').
        replace(/\r/,"\n").
        replace(/\n[\n]+/,"\n");
}).then(function(clean) {
    return JSON.parse(clean);
}).then(function(json) {
    // Do what you want with the JSON object.
});

我在当前的项目中遇到了这个问题，因为我有相当多的 JSON 需要一些注释才能使事情易于记住。

我使用这个简单的 Python 函数来替换注释并用于将其转换为：json.loadsdict

import json, re

def parse_json(data_string):
  result = []
  for line in data_string.split("\n"):
    line = line.strip()
    if len(line) < 1 or line[0:2] == "//":
      continue
    if line[-1] not in "\,\"\'":
      line = re.sub("\/\/.*?$", "", line)
    result.append(line)
  return json.loads("\n".join(result))

print(parse_json("""
{
  // This is a comment
  "name": "value" // so is this
  // "name": "value"
  // the above line gets removed
}
"""))

免责声明：这很傻

实际上有一种方法可以添加注释，并保持在规范范围内（不需要额外的解析器）。不过，如果不进行任何形式的解析，它不会产生人类可读的评论。

您可以滥用以下内容：

在任何标记之前或之后都允许使用无关紧要的空格。 空格是以下一个或多个代码的任意序列 点数：字符制表 （U+0009）、换行符 （U+000A）、回车 return （U+000D） 和空格 （U+0020）。

以一种诡计多端的方式，你可以滥用它来添加评论。例如：用制表符开始和结束您的评论。在 base3 中对注释进行编码，并使用其他空格字符来表示它们。例如。

010212 010202 011000 011000 011010 001012 010122 010121 011021 010202 001012 011022 010212 011020 010202 010202

(hello base three在 ASCII 中），但不是 0 使用空格，而是 1 使用换行符，2 使用回车符。

这只会给您留下很多不可读的空白（除非您制作一个 IDE 插件来动态编码/解码它）。

出于显而易见的原因，我什至从未尝试过，你也不应该这样做。

JSON 规范不支持注释、样式。// or /* */

但是一些 JSON 解析库和 IDE 支持它们。

喜欢：

1. JSON5的
2. Visual Studio 代码
3. 评论json

是的。您可以将注释放在 JSON 文件中。

{
    "": "Location to post to",
    "postUrl": "https://example.com/upload/",

    "": "Username for basic auth",
    "username": "joebloggs",

    "": "Password for basic auth (note this is in clear, be sure to use HTTPS!",
    "password": "bloejoggs"
}

注释只是一段描述代码块或配置用途的文本。而且，由于您可以在 JSON 中多次指定键，因此可以像这样执行此操作。它在语法上是正确的，唯一的权衡是你的字典中会有一个空键，里面有一些垃圾值（你可以修剪......

我多年前就看到了这个问题，但我只是在我正在做的一个项目中看到过这样的工作，我认为这是一种非常干净的方式。享受！

我真的很喜欢@eli的方法，有 30 多个答案，但没有人提到列表（数组）。因此，使用 @eli 的方法，我们可以做这样的事情：

"part_of_speech": {
  "__comment": [
    "@param {String} type - the following types can be used: ",
      "NOUN, VERB, ADVERB, ADJECTIVE, PRONOUN, PREPOSITION",
      "CONJUNCTION, INTERJECTION, NUMERAL, PARTICLE, PHRASE",
    "@param {String} type_free_form - is optional, can be empty string",
    "@param {String} description - is optional, can be empty string",
    "@param {String} source - is optional, can be empty string"
  ],
  "type": "NOUN",
  "type_free_form": "noun",
  "description": "",
  "source": "https://google.com",
  "noun_class": {
    "__comment": [
      "@param {String} noun_class - the following types can be used: ",
        "1_class, 2_class, 3_class, 4_class, 5_class, 6_class"
    ],
    "noun_class": "4_class"
  }
}

是的，新标准 JSON5 允许 C++ 样式注释，以及许多其他扩展：

// A single line comment.

/* A multi-
   line comment. */

JSON5 数据交换格式 （JSON5） 是 JSON 的超集，旨在减轻 JSON 的一些限制。它完全向后兼容，使用它可能比编写自定义非标准解析器、为现有解析器打开非标准功能或使用各种技巧（如字符串字段）进行注释要好。或者，如果使用的解析器支持，只需同意我们使用的是 JSON 5 子集，即 JSON 和 C++ 样式的注释。这比我们按照我们认为合适的方式调整JSON标准要好得多。

已经有 npm 包、Python 包、Java 包和 C 库可用。它是向后兼容的。我认为没有理由坚持“官方”JSON限制。

我认为从 JSON 中删除注释的原因与删除 Java 中的运算符重载的原因相同：可以以错误的方式使用，但一些明显合法的用例被忽略了。对于算子重载，它是矩阵代数和复数。对于 JSON 注释，它是配置文件和其他文档，可以由人类编写、编辑或读取，而不仅仅是由解析器编写、编辑或读取。

JSON 中需要注释，并且至少在 .NET Core JSON 和 Newtonsoft Json 中提供注释。完美工作。

{
  // this is a comment for those who is ok with being different
  "regular-json": "stuff"...
}

正如JSON的发明者所说：

JSON 没有注释。JSON 编码器不得输出注释。JSON 解码器可以接受和忽略注释。

实用程序 jq 包含一个解码器，该解码器允许“#”样式的注释，因此 jq 是可以与带有注释的 JSON 文件结合使用的几种工具之一，只要这些文件被视为“jq 程序”，而不是 JSON 文件。例如：

$ jq -ncf <(echo $'[1, # one\n2 ] # two') 
[1,2]

更重要的是，jq 可以将非常大的带有注释的 JSON 文件作为程序处理;这可以使用一个众所周知的 JSON 文件来说明：

$ ls -l JEOPARDY_QUESTIONS1.json
-rw-r--r--  2 xyzzy  staff  55554625 May 12  2016 JEOPARDY_QUESTIONS1.json

$ jq -nf JEOPARDY_QUESTIONS1.json | jq length
216930

纯粹的答案是否定的。

但是一些编辑器和平台使用变通方法向 JSON 添加注释。

1. 如今，大多数编辑器都有内置选项和扩展来向 JSON 文档添加注释。（例如：- VS Code 也有一个带有注释的 JSON / VS Code 也有很好的扩展）(jsonc) mode

在 VsCode 中激活 jsonc 模式的链接

2. 部分平台提供内置添加注释的方式（不纯json）。 （例如：- 在 firebase 中，我可以毫无问题地评论一段时间。firebase.json

    {
    "hosting": {
        "headers": [
            /*{
              "source": "*.html",
              "headers": [
                {
                  "key": "Content-Security-Policy",
                  "value": "default-src 'self' ..."
                }
              ]
            },*/
        ]
      }
    }

3. 在您自己的 JSON 解析方法中，您可以将预定义的键名设置为注释。

例如：-

     {
        "comment" : "This is a comment",
        "//" :  "This also comment",
        "name" : "This is a real value"
     }

好吧，在撰写本文时，appsettings.json支持评论。

例如（示例由 Microsoft 提供）

{
  "Logging": {
    "LogLevel": { // All providers, LogLevel applies to all the enabled providers.
      "Default": "Error", // Default logging, Error and higher.
      "Microsoft": "Warning" // All Microsoft* categories, Warning and higher.
    },
    "Debug": { // Debug provider.
      "LogLevel": {
        "Default": "Information", // Overrides preceding LogLevel:Default setting.
        "Microsoft.Hosting": "Trace" // Debug:Microsoft.Hosting category.
      }
    },
    "EventSource": { // EventSource provider
      "LogLevel": {
        "Default": "Warning" // All categories of EventSource provider.
      }
    }
  }
}

虽然 JSON 不支持注释，但 JSONC 支持。

使用扩展名为“.jsonc”的文件，并使用 jsonc 解析器。
对不起，如果这个答案为时已晚。

jsonWithComments.jsonc

例：

{
    // This is a comment!
    "something": "idk"

}

如果不清楚，我认为机器人很奇怪。 在将此问题投票为无帮助之前，请尝试。

json specs 不支持注释，但您可以通过将注释编写为键来解决问题，如下所示

{
  "// my own comment goes here":"",
  "key1":"value 1",

  "// another comment goes here":"",
  "key 2": "value 2 here"
}

这样，我们使用注释文本作为键，确保（几乎）它们是唯一的，并且它们不会破坏任何解析器。如果您的某些评论不是唯一的，只需在末尾添加随机数即可。

如果您需要解析注释以执行任何处理（例如剥离它们），则可以使用指示它是注释的文本填充注释值，如下所示：

   {
  "// my own comment goes here" : "_comment",
  "key1":"value 1",

  "// another comment goes here" : "_comment",
  "key 2": "value 2 here"
} 
  

这样，解析器可以找到所有注释并对其进行处理。

我搜索了所有页面的答案，没有一个提到 GitHub 或 Stack Overflow 上的 JSON 语法突出显示，尽管这个答案很接近。

一些 JSON 解析器接受 C++ 样式的注释。例如，要在 GitHub 或 Stack Overflow 上编写 markdown 时触发它们，您可以将语法突出显示类型指定为 .例：jsonc

这：

```jsonc
// C++-style comment here
{
    "*.md": {
        "softwrap": true
    },
    "colorcolumn": 80,
    "savecursor": true,
    "scrollbar": true,
    "scrollspeed": 5,
    "softwrap": true,
    "wordwrap": true
}
```

产生这个：

// C++-style comment here
{
    "*.md": {
        "softwrap": true
    },
    "colorcolumn": 80,
    "savecursor": true,
    "scrollbar": true,
    "scrollspeed": 5,
    "softwrap": true,
    "wordwrap": true
}

正如我上面提到的答案，您可以使用令人惊叹的 nlohmann json C++ 库解析具有 C（） 和 C++ （） 样式注释的 JSON。/* *///

它在这里：https://github.com/nlohmann/json

您需要的单个头文件如下：https://github.com/nlohmann/json/blob/develop/include/nlohmann/json.hpp

该库是这样说的： https://github.com/nlohmann/json#comments-in-json：

JSON 中的注释

默认情况下，此库不支持注释。这样做有三个原因：

1. 注释不是 JSON 规范的一部分。你可能会争辩说，在 JavaScript 中是允许的，但 JSON 不是 JavaScript。///* */
2. 这不是一个疏忽：道格拉斯·克罗克福德（Douglas Crockford）在2012年5月写道：

我从 JSON 中删除了注释，因为我看到人们使用它们来保存解析指令，这种做法会破坏互操作性。我知道缺乏评论会让一些人感到难过，但不应该。

假设您正在使用 JSON 来保存要注释的配置文件。继续并插入您喜欢的所有评论。然后通过 JSMin 管道传输它，然后再将其传递给 JSON 解析器。

3. 如果某些库会添加注释支持，而其他库则不添加注释支持，那么互操作性将是危险的。请查看鲁棒性原则的有害后果。

但是，您可以在函数中将 set 参数传递给 true 以忽略或注释。然后，注释将被视为空格。ignore_commentsparse///* */

ignore_comments是 和 是传递给函数的最后一个参数。看这里： https://json.nlohmann.me/api/basic_json/parse/boolnlohmann::json::parse()

引用：

1. https://gist.github.com/DamianEdwards/31d2457737304ca73556?permalink_comment_id=3574928#gistcomment-3574928

“JSON 没有任何注释文档”

但是你可以试试这个方法添加注释，

通过添加带有注释和描述的键值对：

{
"key": "some value",
"comments":"this is a comment"
"description":"this is some description of the comment defined above"
}

原因：为什么JSON文件不允许注释（默认）？

因为注释通常被添加到源代码中以描述代码行。JSON纯粹是关于要发送的数据格式，因此在Json中添加注释是不可行的。

希望它有所帮助。

我认为没有这样的方法。IDE也这么说。它只是不受支持

我从 JSON 中删除了注释，因为我看到人们使用它们来保存解析指令，这种做法会破坏互操作性。

——道格拉斯·克罗克福德

我从依赖项中删除了 JSON，因为我看到 Douglas Crockford 让它变得不可注释，这种做法破坏了互操作性。

--我

结论：使用 YAML