blocks|key|1704530|text|不是的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1704531|JSON仅是数据，如果包含注释，那么它也将是数据。|1704532|您可以有一个名为"_comment"+(或其他)的指定数据元素，使用该数据的应用程序应该忽略该数据元素。|offset|length|style|CODE|1704533|在生成/接收JSON的过程中使用注释可能会更好，因为它们应该预先知道JSON数据是什么，或者至少知道它的结构。|1704534|但如果你决定这样做：|1704535|{
+++"_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"
++++++++++++}
+++++++++}
++++++}
+++}
}|code-block|syntax|javascript|1704536|entityMap^0|0|0|8|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@$F|X|G|Y|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|Z|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|10|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|11|8|@]|9|@]|A|$Q|R]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

No.
The JSON is data only, and if you include a comment, then it will be data too.
You could have a designated data element called <code>&quot;_comment&quot;</code> (or something) that should be ignored by apps that use the JSON data.
You would probably be better having the comment in the processes that generates/receives the JSON, as they are supposed to know what the JSON data will be in advance, or at least the structure of it.
But if you decided to:
<pre><code>{
 &quot;_comment&quot;: &quot;comment text goes here...&quot;,
 &quot;glossary&quot;: {
 &quot;title&quot;: &quot;example glossary&quot;,
 &quot;GlossDiv&quot;: {
 &quot;title&quot;: &quot;S&quot;,
 &quot;GlossList&quot;: {
 &quot;GlossEntry&quot;: {
 &quot;ID&quot;: &quot;SGML&quot;,
 &quot;SortAs&quot;: &quot;SGML&quot;,
 &quot;GlossTerm&quot;: &quot;Standard Generalized Markup Language&quot;,
 &quot;Acronym&quot;: &quot;SGML&quot;,
 &quot;Abbrev&quot;: &quot;ISO 8879:1986&quot;,
 &quot;GlossDef&quot;: {
 &quot;para&quot;: &quot;A meta-markup language, used to create markup languages such as DocBook.&quot;,
 &quot;GlossSeeAlso&quot;: [&quot;GML&quot;, &quot;XML&quot;]
 },
 &quot;GlossSee&quot;: &quot;markup&quot;
 }
 }
 }
 }
}
</code></pre>

blocks|key|1705421|text|JSON不支持注释。它也不打算用于需要注释的配置文件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1705422|Hjson是一种用于人类的配置文件格式。轻松的语法，更少的错误，更多的评论。|1705423|​|1705424|📷|atomic|offset|length|1705425|1705426|参见hjson.github.io中的JavaScript、Java、Python、PHP、Rust、Go、Ruby、C%2B%2B和C#库。|1705427|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/e5904dbd0b25bfff697d0a684402b012.gif|imageAlt|1|LINK|MUTABLE|url|https://hjson.github.io/^0|0|0|0|0|1|0|0|0|2|F|1|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|14|8|@]|9|@$I|15|J|16|1|17]]|A|$]]|$1|K|3|E|5|6|7|18|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|19|8|@]|9|@$I|1A|J|1B|1|1C]]|A|$]]|$1|N|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U|V|-4]]|W|$5|X|R|Y|A|$Z|10]]]]

JSON does not support comments. It was also never intended to be used for configuration files where comments would be needed.
Hjson is a configuration file format for humans. Relaxed syntax, fewer mistakes, more comments.
<a href="https://i.stack.imgur.com/u2E8q.gif" rel="noreferrer"><img src="https://i.stack.imgur.com/u2E8q.gif" alt="Hjson intro" /></a>
See <a href="https://hjson.github.io/" rel="noreferrer">hjson.github.io</a> for JavaScript, Java, Python, PHP, Rust, Go, Ruby, C++ and C# libraries.

blocks|key|1489775|text|考虑使用YAML。它几乎是JSON的超集(实际上所有有效的JSON都是有效的YAML)，并且允许注释。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1489776|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Consider using YAML. It's nearly a superset of JSON (virtually all valid JSON is valid YAML) and it allows comments.

blocks|key|1489395|text|你不能，至少这是我快速浏览json.org的经验。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1489396|JSON在该页面上可视化了它的语法。没有任何关于评论的注释。|1489397|entityMap|0|LINK|mutability|MUTABLE|url|http://json.org/^0|D|8|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

You can't. At least that's my experience from a quick glance at <a href="http://json.org" rel="noreferrer">json.org</a>.

JSON has its syntax visualized on that page. There isn't any note about comments.

blocks|key|1704846|text|注释不是官方标准，尽管有些解析器支持C%2B%2B样式的注释。我使用的一个是JsonCpp。在示例中有这样一个示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1704847|//+Configuration+options
{
++++//+Default+encoding+for+text
++++"encoding"+:+"UTF-8",

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

++++//+Tab+indent+size
++++"indent"+:+{+"length"+:+3,+"use_space":+true+}
}|code-block|syntax|javascript|1704848|jsonlint不会验证这一点。所以注释是解析器特定的扩展，而不是标准的。|1704849|另一个解析器是JSON5。|1704850|JSON+TOML的替代方案。|1704851|另一种选择是jsonc。|1704852|最新版本的nlohmann/json对忽略解析时的注释有可选的支持。|1704853|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/open-source-parsers/jsoncpp|1|http://www.jsonlint.com/|2|https://json5.org/|3|https://github.com/toml-lang/toml|4|https://www.npmjs.com/package/jsonc|5|https://github.com/nlohmann/json#comments-in-json^0|Y|7|0|0|0|0|8|1|0|7|5|2|0|5|4|3|0|6|5|4|0|5|D|5|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@$A|1G|B|1H|1|1I]]|C|$]]|$1|K|3|L|5|6|7|1J|8|@]|9|@$A|1K|B|1L|1|1M]]|C|$]]|$1|M|3|N|5|6|7|1N|8|@]|9|@$A|1O|B|1P|1|1Q]]|C|$]]|$1|O|3|P|5|6|7|1R|8|@]|9|@$A|1S|B|1T|1|1U]]|C|$]]|$1|Q|3|R|5|6|7|1V|8|@]|9|@$A|1W|B|1X|1|1Y]]|C|$]]|$1|S|3|-4|5|6|7|1Z|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]|12|$5|V|W|X|C|$Y|13]]|14|$5|V|W|X|C|$Y|15]]|16|$5|V|W|X|C|$Y|17]]|18|$5|V|W|X|C|$Y|19]]]]

Comments are not an official standard, although some parsers support C++-style comments. One that I use is <a href="https://github.com/open-source-parsers/jsoncpp" rel="noreferrer">JsonCpp</a>. In the examples there is this one:
<pre><code>// Configuration options
{
 // Default encoding for text
 &quot;encoding&quot; : &quot;UTF-8&quot;,

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

 // Tab indent size
 &quot;indent&quot; : { &quot;length&quot; : 3, &quot;use_space&quot;: true }
}
</code></pre>
<a href="http://www.jsonlint.com" rel="noreferrer">jsonlint</a> does not validate this. So comments are a parser specific extension and not standard.
Another parser is <a href="https://json5.org/" rel="noreferrer">JSON5</a>.
An alternative to JSON <a href="https://github.com/toml-lang/toml" rel="noreferrer">TOML</a>.
A further alternative is <a href="https://www.npmjs.com/package/jsonc" rel="noreferrer">jsonc</a>.
The latest version of <a href="https://github.com/nlohmann/json#comments-in-json" rel="noreferrer">nlohmann/json</a> has optional support for ignoring comments on parsing.

blocks|key|1705197|text|如果您使用Jackson作为您的JSON解析器，那么您可以通过以下方式启用它以允许注释：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1705198|ObjectMapper+mapper+=+new+ObjectMapper().configure(Feature.ALLOW_COMMENTS,+true);|code-block|syntax|javascript|1705199|然后你可以有这样的评论：|1705200|{
++key:+"value"+//+Comment
}|1705201|您还可以通过设置以下内容来获得以#开头的注释：|style|CODE|1705202|mapper.configure(Feature.ALLOW_YAML_COMMENTS,+true);|1705203|但一般而言(正如前面所回答的)，规范不允许注释。|1705204|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/FasterXML/jackson^0|5|7|0|0|0|0|0|G|1|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|19|8|@$A|1A|B|1B|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|F|7|1C|8|@]|9|@]|C|$G|H]]|$1|S|3|T|5|6|7|1D|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1E|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

If you are using <a href="https://github.com/FasterXML/jackson" rel="noreferrer">Jackson</a> as your JSON parser then this is how you enable it to allow comments:

<pre><code>ObjectMapper mapper = new ObjectMapper().configure(Feature.ALLOW_COMMENTS, true);
</code></pre>

Then you can have comments like this:

<pre><code>{
 key: "value" // Comment
}
</code></pre>

And you can also have comments starting with <code>#</code> by setting:

<pre><code>mapper.configure(Feature.ALLOW_YAML_COMMENTS, true);
</code></pre>

But in general (as answered before) the specification does not allow comments.

blocks|key|1490746|text|下面是我在Google+Firebase+documentation中找到的内容，它允许您在JSON中添加注释：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1490747|{
++"//":+"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"
}|code-block|syntax|javascript|1490748|entityMap|0|LINK|mutability|MUTABLE|url|https://firebase.google.com/docs/cloud-messaging/js/client#configure_the_browser_to_receive_messages^0|5|T|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Here is what I found in the <a href="https://firebase.google.com/docs/cloud-messaging/js/client#configure_the_browser_to_receive_messages" rel="noreferrer">Google Firebase documentation</a> that allows you to put comments in JSON:
<pre class="lang-json prettyprint-override"><code>{
 &quot;//&quot;: &quot;Some browsers will use this to enable push notifications.&quot;,
 &quot;//&quot;: &quot;It is the same for all projects, this is not your project's sender ID&quot;,
 &quot;gcm_sender_id&quot;: &quot;1234567890&quot;
}
</code></pre>

blocks|key|1489596|text|JSON背后的思想是在应用程序之间提供简单的数据交换。它们通常是基于web的，语言是JavaScript。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1489597|它实际上不允许注释，但是，将注释作为数据中的名称/值对之一传递肯定会起作用，尽管该数据显然需要被解析代码忽略或专门处理。|1489598|尽管如此，JSON文件并不应该包含传统意义上的注释。它应该仅仅是数据。|1489599|有关更多详细信息，请查看JSON+website。|offset|length|1489600|entityMap|0|LINK|mutability|MUTABLE|url|http://www.json.org/^0|0|0|0|C|C|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@$H|V|I|W|1|X]]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

The idea behind JSON is to provide simple data exchange between applications. These are typically web based and the language is JavaScript.

It doesn't really allow for comments as such, however, passing a comment as one of the name/value pairs in the data would certainly work, although that data would obviously need to be ignored or handled specifically by the parsing code.

All that said, it's not the intention that the JSON file should contain comments in the traditional sense. It should just be the data.

Have a look at the <a href="http://www.json.org/" rel="noreferrer">JSON website</a> for more detail.

blocks|key|1704886|text|这取决于您的JSON库。Json.NET支持JavaScript风格的注释/*+commment+*/。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1704887|参见another+Stack Overflow+question。|1704888|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/JamesNK/Newtonsoft.Json|1|https://stackoverflow.com/a/10325432/166286^0|11|E|C|8|0|0|2|V|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|H|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

It depends on your JSON library. <a href="https://github.com/JamesNK/Newtonsoft.Json" rel="noreferrer">Json.NET</a> supports JavaScript-style comments, <code>/* commment */</code>.

See <a href="https://stackoverflow.com/a/10325432/166286">another Stack&nbsp;Overflow question</a>.

blocks|key|1489715|text|Dojo+Toolkit+JavaScript工具包(至少是1.4版)允许您在JSON中包含注释。注释可以是/*+*/格式。Dojo+Toolkit通过dojo.xhrGet()调用使用JSON。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1489716|其他JavaScript工具包也可以类似地工作。|1489717|在选择最终选项之前尝试备用数据结构(甚至是数据列表)时，这会很有帮助。|1489718|entityMap^0|1I|5|24|D|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

The Dojo Toolkit JavaScript toolkit (at least as of version 1.4), allows you to include comments in your JSON. The comments can be of <code>/* */</code> format. Dojo Toolkit consumes the JSON via the <code>dojo.xhrGet()</code> call.

Other JavaScript toolkits may work similarly.

This can be helpful when experimenting with alternate data structures (or even data lists) before choosing a final option.

blocks|key|1705558|text|我们正在为我们的项目使用strip-json-comments。它支持如下内容：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1705559|/*
+*+Description+
*/
{
++++//+rainbows
++++"unicorn":+/*+❤+*/+"cake"
}|code-block|syntax|javascript|1705560|只需npm+install+--save+strip-json-comments即可安装和使用它，如下所示：|1705561|var+strip_json_comments+=+require('strip-json-comments')
var+json+=+'{/*rainbows*/"unicorn":"cake"}';
JSON.parse(strip_json_comments(json));
//=>+{unicorn:+'cake'}|1705562|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/sindresorhus/strip-json-comments^0|C|J|C|J|0|0|0|2|12|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

We are using <a href="https://github.com/sindresorhus/strip-json-comments"><code>strip-json-comments</code></a> for our project. It supports something like:

<pre><code>/*
 * Description 
*/
{
 // rainbows
 "unicorn": /* ❤ */ "cake"
}
</code></pre>

Simply <code>npm install --save strip-json-comments</code> to install and use it like:

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

blocks|key|1489935|text|为了将JSON条目分成几个部分，我添加了“虚拟注释”行：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1489936|{

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

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

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

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

}|code-block|syntax|javascript|1489937|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

To cut a JSON item into parts I add "dummy comment" lines:

<pre><code>{

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

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

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

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

}
</code></pre>

blocks|key|1705084|text|JSON的作者希望我们在JSON中包含注释，但在解析它们之前将它们去掉(请参阅Michael+Burr提供的link+)。如果JSON应该有注释，为什么不标准化它们，让JSON解析器来完成这项工作呢？我不同意那里的逻辑，但是，唉，这就是标准。按照其他人的建议使用YAML解决方案很好，但它需要依赖于库。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1705085|如果你想去掉注释，但又不想有库依赖，这里有一个两行的解决方案，它适用于C%2B%2B风格的注释，但也可以适用于其他类型的注释：|1705086|var+comments+=+new+RegExp("//.*",+'mg');
data+=+JSON.parse(fs.readFileSync(sample_file,+'utf8').replace(comments,+''));|code-block|syntax|javascript|1705087|请注意，此解决方案只能在您可以确定JSON数据不包含注释发起者的情况下使用，例如('//')。|1705088|另一种实现JSON解析、剥离注释且不需要额外库的方法是在JavaScript解释器中评估JSON。当然，这种方法的警告是，您只需要评估未受污染的数据(没有不受信任的用户输入)。下面是Node.js中这种方法的一个示例--另一个警告，下面的示例将只读取数据一次，然后数据将被缓存：|1705089|data+=+require(fs.realpathSync(doctree_fp));|1705090|entityMap|0|LINK|mutability|MUTABLE|url|https://plus.google.com/118095276221607585885/posts/RK8qyGVaGSr^0|1I|4|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|H|7|16|8|@]|9|@]|C|$I|J]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

The author of JSON wants us to include comments in the JSON, but strip them out before parsing them (see <a href="https://plus.google.com/118095276221607585885/posts/RK8qyGVaGSr" rel="noreferrer">link</a> provided by Michael Burr). If JSON should have comments, why not standardize them, and let the JSON parser do the job? I don't agree with the logic there, but, alas, that's the standard. Using a YAML solution as suggested by others is good, but it requires a library dependency.

If you want to strip out comments, but don't want to have a library dependency, here is a two-line solution, which works for C++-style comments, but can be adapted to others:

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

Note that this solution can only be used in cases where you can be sure that the JSON data does not contain the comment initiator, e.g. ('//').

Another way to achieve JSON parsing, stripping of comments, and no extra library, is to evaluate the JSON in a JavaScript interpreter. The caveat with that approach, of course, is that you would only want to evaluate untainted data (no untrusted user-input). Here is an example of this approach in Node.js -- another caveat, the following example will only read the data once and then it will be cached:

<pre><code>data = require(fs.realpathSync(doctree_fp));
</code></pre>

blocks|key|1491048|text|不能，JSON不能直接有注释。但是，作为suggested+by+this，您可以通过执行以下操作来实现类似的效果|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1491049|{
++++"//name":+"Name+comment+here",
++++"name":+"Jack",

++++"//age":+"Age+comment+here",
++++"age":+"25"
}|code-block|syntax|javascript|1491050|大多数JSON解析器将忽略未映射的属性。|1491051|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/MoOx/5271067#gistcomment-2786317^0|K|H|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

No, JSON cannot have comments directly. However, as <a href="https://gist.github.com/MoOx/5271067#gistcomment-2786317" rel="noreferrer">suggested by this</a>, you can achieve a similar effect by doing something like
<pre><code>{
 &quot;//name&quot;: &quot;Name comment here&quot;,
 &quot;name&quot;: &quot;Jack&quot;,

 &quot;//age&quot;: &quot;Age comment here&quot;,
 &quot;age&quot;: &quot;25&quot;
}
</code></pre>
Most JSON parsers will ignore properties that are not mapped.

blocks|key|1489961|text|叹一口气。为什么不直接添加字段，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1489962|{
++++"note1"+:+"This+demonstrates+the+provision+of+annotations+within+a+JSON+file",
++++"field1"+:+12,
++++"field2"+:+"some+text",

++++"note2"+:+"Add+more+annotations+as+necessary"
}|code-block|syntax|javascript|1489963|只需确保您的"notex“名称不与任何实际字段冲突即可。|1489964|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Sigh. Why not just add fields, e.g.

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

 "note2" : "Add more annotations as necessary"
}
</code></pre>

Just make sure your "notex" names don't conflict with any real fields.

blocks|key|1705967|text|对于2019年的Visual+Studio+Code用户来说，实用的答案是使用'jsonc‘扩展。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1705968|它很实用，因为这是Visual+Studio代码识别的扩展，用于指示“带注释的JSON”。请在下面的评论中告诉我关于其他编辑器/IDE的信息。|1705969|如果Visual+Studio+Code和其他编辑器也能添加对JSON5的原生支持，那就太好了，但目前Visual+Studio+Code只支持'jsonc‘。|1705970|(在发布这篇文章之前，我搜索了所有的答案，没有一个提到‘jsonc’。)|1705971|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Visual_Studio_Code^0|8|I|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

The practical answer for <a href="https://en.wikipedia.org/wiki/Visual_Studio_Code" rel="nofollow noreferrer">Visual Studio Code</a> users in 2019 is to use the 'jsonc' extension.
It is practical, because that is the extension recognized by Visual Studio Code to indicate &quot;JSON with comments&quot;. Please let me know about other editors/IDEs in the comments below.
It would be nice if Visual Studio Code and other editors would add native support for JSON5 as well, but for now Visual Studio Code only includes support for 'jsonc'.
(I searched through all the answers before posting this and none mention 'jsonc'.)

blocks|key|1490470|text|如果您的上下文是Node.js配置，则可以考虑将通过module.exports的JavaScript作为JSON的替代方案：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1490471|module.exports+=+{
++++"key":+"value",

++++//+And+with+comments!
++++"key2":+"value2"
};|code-block|syntax|javascript|1490472|require语法仍然是相同的。如果为JavaScript，则文件扩展名应为.js。|1490473|entityMap^0|Q|E|0|0|0|7|12|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

If your context is Node.js configuration, you might consider JavaScript via <code>module.exports</code> as an alternative to JSON:

<pre><code>module.exports = {
 "key": "value",

 // And with comments!
 "key2": "value2"
};
</code></pre>

The <code>require</code> syntax will still be the same. Being JavaScript, the file extension should be <code>.js</code>.

blocks|key|1705774|text|您可以通过正则表达式使用简单的预处理。例如，以下函数将在PHP中解码注释的JSON：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1705775|function+json_decode_commented+($data,+$objectsAsArrays+=+false,+$maxDepth+=+512,+$opts+=+0)+{
++$data+=+preg_replace('~
++++("+(?:[%5E"\\\\]+%7C+\\\\\\\\+%7C+\\\\")*%2B+")+%7C+\#+[%5E\v]*%2B+%7C+//+[%5E\v]*%2B+%7C+/\*+.*?+\*/
++~xs',+'$1',+$data);

++return+json_decode($data,+$objectsAsArrays,+$maxDepth,+$opts);
}|code-block|syntax|javascript|1705776|它支持所有PHP风格的注释:+/*，#，//。字符串文字将按原样保留。|1705777|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can use simple preprocessing via regular expressions. For instance, the following function will decode commented JSON in PHP:

<pre><code>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);
}
</code></pre>

It supports all PHP-style comments: /*, #, //. String literals are preserved as is.

blocks|key|1490896|text|*.json文件通常用作配置文件或静态数据，因此一些编辑器，如NetBeans，需要在*.json中接受注释→注释。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1490897|问题在于将内容解析为对象。解决方案是始终应用清理功能(服务器或客户端)。|1490898|###PHP|1490899|+$rgx_arr+=+["/\/\/[%5E\n]*/sim",+"/\/\*.*?\*\//sim",+"/[\n\r\t]/sim"];
+$valid_json_str+=+\preg_replace($rgx_arr,+'',+file_get_contents(path+.+'a_file.json'));|code-block|syntax|javascript|1490900|###JavaScript|1490901|valid_json_str+=+json_str.replace(/\/\/[%5E\n]*/gim,'').replace(/\/\*.*?\*\//gim,'')|1490902|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

*.json files are generally used as configuration files or static data, thus the need of comments → some editors like NetBeans accept comments in *.json.
The problem is parsing content to an object. The solution is to always apply a cleaning function (server or client).
###PHP
<pre><code> $rgx_arr = [&quot;/\/\/[^\n]*/sim&quot;, &quot;/\/\*.*?\*\//sim&quot;, &quot;/[\n\r\t]/sim&quot;];
 $valid_json_str = \preg_replace($rgx_arr, '', file_get_contents(path . 'a_file.json'));
</code></pre>
###JavaScript
<pre><code>valid_json_str = json_str.replace(/\/\/[^\n]*/gim,'').replace(/\/\*.*?\*\//gim,'')
</code></pre>

blocks|key|1490957|text|当然，您可以对JSON进行注释。要从JavaScript中读取带注释的JSON文件，可以在解析它之前去掉注释(参见下面的代码)。我相信这段代码是可以改进的，但是对于那些使用正则表达式的人来说，它很容易理解。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1490958|我使用带注释的JSON文件为我的合成反射系统指定神经元形状。我还使用带注释的JSON来存储正在运行的神经元系统的中间状态。有评论是非常方便的。不要听信那些告诉你他们是个坏主意的人。|1490959|fetch(filename).then(function(response)+{
++++return+response.text();
}).then(function(commented)+{
++++return+commented.
++++++++replace(/\/\*[\s\S]*?\*\/%7C([%5E\\:]%7C%5E)\/\/.*$/gm,+'$1').
++++++++replace(/\r/,"\n").
++++++++replace(/\n[\n]%2B/,"\n");
}).then(function(clean)+{
++++return+JSON.parse(clean);
}).then(function(json)+{
++++//+Do+what+you+want+with+the+JSON+object.
});|code-block|syntax|javascript|1490960|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Sure you can comment JSON. To read a commented JSON file from JavaScript you can strip comments before parsing it (see the code below). I'm sure this code can be improved, but it is easy to understand for those who use regular expressions.
I use commented JSON files to specify neuron shapes for my synthetic reflex systems. I also use commented JSON to store intermediate states for a running neuron system. It is very convenient to have comments. Don't listen to didacts who tell you they are a bad idea.
<pre><code>fetch(filename).then(function(response) {
 return response.text();
}).then(function(commented) {
 return commented.
 replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '$1').
 replace(/\r/,&quot;\n&quot;).
 replace(/\n[\n]+/,&quot;\n&quot;);
}).then(function(clean) {
 return JSON.parse(clean);
}).then(function(json) {
 // Do what you want with the JSON object.
});
</code></pre>

blocks|key|1705732|text|如果您正在使用PHP，则可以使用此函数在将JSON字符串解析为对象/数组之前，从/*字符串中搜索并删除//+JSON类型的注释：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1705733|function+json_clean_decode($json,+$assoc+=+true,+$depth+=+512,+$options+=+0)+{
+++++++//+search+and+remove+comments+like+/*+*/+and+//
+++++++$json+=+preg_replace("#(/\*([%5E*]%7C[\r\n]%7C(\*%2B([%5E*/]%7C[\r\n])))*\*%2B/)%7C([\s\t]//.*)%7C(%5E//.*)#",+'',+$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;
+++}|code-block|syntax|javascript|1705734|希望这能有所帮助！|1705735|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you are using PHP, you can use this function to search for and remove // /* type comments from the JSON string before parsing it into an object/array:

<pre><code>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', '&gt;=')) {
 $json = json_decode($json, $assoc, $depth, $options);
 }
 elseif(version_compare(phpversion(), '5.3.0', '&gt;=')) {
 $json = json_decode($json, $assoc, $depth);
 }
 else {
 $json = json_decode($json, $assoc);
 }

 return $json;
 }
</code></pre>

Hope this helps!

blocks|key|1490619|text|您可以使用JSON-LD和schema.org+comment类型来正确编写注释：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1490620|{
++++"https://schema.org/comment":+"this+is+a+comment"
}|code-block|syntax|javascript|1490621|entityMap|0|LINK|mutability|MUTABLE|url|https://www.w3.org/TR/json-ld/|1|https://schema.org/comment^0|5|7|0|D|I|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

You can use <a href="https://www.w3.org/TR/json-ld/" rel="nofollow">JSON-LD</a> and the <a href="https://schema.org/comment" rel="nofollow">schema.org comment</a> type to properly write comments: 

<pre><code>{
 "https://schema.org/comment": "this is a comment"
}
</code></pre>

blocks|key|1705618|text|还有其他兼容JSON的库，它们支持注释。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1705619|一个值得注意的例子是"Hashcorp+Language"+(HCL)"。它是由制作流浪者，包装者，领事和保险库的人写的。|offset|length|1705620|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/hashicorp/hcl^0|0|A|Q|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

There are other libraries that are JSON compatible, which support comments.

One notable example is the <a href="https://github.com/hashicorp/hcl" rel="nofollow noreferrer">"Hashcorp Language" (HCL)"</a>. It is written by the same people who made Vagrant, packer, consul, and vault.

blocks|key|1490991|text|我在我目前的项目中遇到了这个问题，因为我有相当多的JSON需要一些注释来保持易记。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1490992|我已经使用这个简单的Python函数替换注释，并使用json.loads将其转换为dict|offset|length|style|CODE|1490993|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
}
"""))|code-block|syntax|javascript|1490994|entityMap^0|0|Q|A|15|4|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

I came across this problem in my current project as I have quite a bit of JSON that requires some commenting to keep things easy to remember.
I've used this simple Python function to replace comments &amp; use <code>json.loads</code> to convert it into a <code>dict</code>:
<pre><code>import json, re

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

print(parse_json(&quot;&quot;&quot;
{
 // This is a comment
 &quot;name&quot;: &quot;value&quot; // so is this
 // &quot;name&quot;: &quot;value&quot;
 // the above line gets removed
}
&quot;&quot;&quot;))
</code></pre>

blocks|key|1706253|text|是。您可以将注释放在JSON文件中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1706254|{
++++"":+"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"
}|code-block|syntax|javascript|1706255|注释只是描述一段代码或配置的目的的一段文本。因为您可以在JSON中多次指定键，所以可以这样做。它在语法上是正确的，唯一的权衡是你的字典中会有一个空键和一些无用的值(你可以裁剪……)|1706256|我在很多年前就看到过这个问题，但我只是在我正在做的一个项目中才看到这样做，我认为这是一种非常干净的方式。享受吧！|1706257|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Yes. You can put comments in a JSON file.

<pre><code>{
 "": "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"
}
</code></pre>

A comment is simply a piece of text describing the purpose of a block of code or configuration. And because you can specify keys multiple times in JSON, you can do it like this. It's syntactically correct and the only tradeoff is you'll have an empty key with some garbage value in your dictionary (which you could trim...)

I saw this question years and years ago but I only just saw this done like this in a project I'm working on and I thought this was a really clean way to do it. Enjoy!

blocks|key|1706319|text|JSON不支持注释，但YAML支持内联注释(没有块注释)。由于它们都是数据文件，并且具有相似的功能，因此这可能是可行的方法。此外，还有像json2yaml.com这样的在线资源可以很容易地将JSON转换为YAML。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1706320|entityMap|0|LINK|mutability|MUTABLE|url|https://www.json2yaml.com/^0|1W|D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

JSON does not support comments, but YAML does support inline comments (no block comments though). Since they are both data files and have similar features, this might be the way to go. In addition, there are resources online like <a href="https://www.json2yaml.com/" rel="nofollow noreferrer">json2yaml.com</a> that can convert JSON to YAML easily

blocks|key|1491210|text|我真的很喜欢@eli的方法，有超过30个答案，但没有人提到列表(数组)。所以使用@eli的方法，我们可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1491211|"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"
++}
}|code-block|syntax|javascript|1491212|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I really like @eli 's approach, there are over 30 answers but no one has mentioned lists (array). So using @eli 's approach we could do something like:
<pre><code>&quot;part_of_speech&quot;: {
 &quot;__comment&quot;: [
 &quot;@param {String} type - the following types can be used: &quot;,
 &quot;NOUN, VERB, ADVERB, ADJECTIVE, PRONOUN, PREPOSITION&quot;,
 &quot;CONJUNCTION, INTERJECTION, NUMERAL, PARTICLE, PHRASE&quot;,
 &quot;@param {String} type_free_form - is optional, can be empty string&quot;,
 &quot;@param {String} description - is optional, can be empty string&quot;,
 &quot;@param {String} source - is optional, can be empty string&quot;
 ],
 &quot;type&quot;: &quot;NOUN&quot;,
 &quot;type_free_form&quot;: &quot;noun&quot;,
 &quot;description&quot;: &quot;&quot;,
 &quot;source&quot;: &quot;https://google.com&quot;,
 &quot;noun_class&quot;: {
 &quot;__comment&quot;: [
 &quot;@param {String} noun_class - the following types can be used: &quot;,
 &quot;1_class, 2_class, 3_class, 4_class, 5_class, 6_class&quot;
 ],
 &quot;noun_class&quot;: &quot;4_class&quot;
 }
}
</code></pre>

blocks|key|1491290|text|json规范不支持注释，但您可以通过将注释编写为键来解决此问题，如下所示|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1491291|{
++"//+my+own+comment+goes+here":"",
++"key1":"value+1",

++"//+another+comment+goes+here":"",
++"key+2":+"value+2+here"
}|code-block|syntax|javascript|1491292|通过这种方式，我们使用注释文本作为键，确保它们(几乎)是唯一的，并且它们不会破坏任何解析器。如果你的一些评论不是唯一的，只需在末尾添加随机数字即可。|1491293|如果您需要解析注释以执行任何处理，如剥离它们，您可以使用文本填充注释值，以指示它是注释，如下所示：|1491294|+++{
++"//+my+own+comment+goes+here"+:+"_comment",
++"key1":"value+1",

++"//+another+comment+goes+here"+:+"_comment",
++"key+2":+"value+2+here"
}+|1491295|这样，解析器就可以找到所有注释并对其进行处理。|1491296|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

json specs doesn't support comments BUT you can work around the problem by writing your comment as keys, like this
<pre><code>{
 &quot;// my own comment goes here&quot;:&quot;&quot;,
 &quot;key1&quot;:&quot;value 1&quot;,

 &quot;// another comment goes here&quot;:&quot;&quot;,
 &quot;key 2&quot;: &quot;value 2 here&quot;
}
</code></pre>
this way we are using the comment texts as keys ensuring (almost) that they are unique and they will not break any parsers. if some of your comments are not unique just add random numbers at the end.
if you need to parse comments to do any processing like stripping them you can fill the comment values with text indicating that it is a comment , like so:
<pre><code> {
 &quot;// my own comment goes here&quot; : &quot;_comment&quot;,
 &quot;key1&quot;:&quot;value 1&quot;,

 &quot;// another comment goes here&quot; : &quot;_comment&quot;,
 &quot;key 2&quot;: &quot;value 2 here&quot;
} 
 
</code></pre>
this way a parser can find all comments and process them.

blocks|key|1491114|text|严格来说不是。但您可以按如下方式解决此问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1491115|{
++"json":+"actual+data+goes+here,+comments+below",
++"comment1":+"Lorem+ipsum+dolor+sit+amet",
++"comment2":+"consectetur+adipiscing+elit"
}|code-block|syntax|javascript|1491116|只需在数据中添加注释即可。如果您对它们进行编号以使每个密钥路径唯一，则应该不会有任何问题。|1491117|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Not technically. But you can workaround as follows.

<pre><code>{
 "json": "actual data goes here, comments below",
 "comment1": "Lorem ipsum dolor sit amet",
 "comment2": "consectetur adipiscing elit"
}
</code></pre>

Just put the comments in the data. If you number them to make each key path unique, you should have no problems.

blocks|key|1490410|text|是的，你可以，但是你的解析可能会失败(没有标准)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1490411|要解析它，您应该删除这些注释，或者手动删除，或者使用正则表达式删除：|1490412|它会替换任何注释，例如：|1490413|/****
+*+Hey
+*/

/\/\*([%5E*]%7C[\r\n]%7C(\*%2B([%5E*/]%7C[\r\n])))*\*\/%2B/|code-block|syntax|javascript|1490414|1490415|//+Hey

/\/\/.*/|1490416|在JavaScript中，你可以这样做：|1490417|jsonString+=+jsonString.replace(/\/\*([%5E*]%7C[\r\n]%7C(\*%2B([%5E*/]%7C[\r\n])))*\*\/%2B/,+"").replace(/\/\/.*/,"")
var+object+=+JSON.parse(jsonString);|1490418|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|W|8|@]|9|@]|A|$I|J]]|$1|K|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|L|3|M|5|H|7|Y|8|@]|9|@]|A|$I|J]]|$1|N|3|O|5|6|7|Z|8|@]|9|@]|A|$]]|$1|P|3|Q|5|H|7|10|8|@]|9|@]|A|$I|J]]|$1|R|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|S|$]]

Yes, you can, but your parse will probably fail (there is no standard).

To parse it you should remove those comments, or by hand, or using a regular expression:

It replaces any comments, like:

<pre><code>/****
 * Hey
 */

/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/
</code></pre>

It replaces any comments, like:

<pre><code>// Hey

/\/\/.*/
</code></pre>

In JavaScript, you could do something like this:

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

Can I use comments inside a JSON file? If so, how?

Can comments be used in JSON?

Visual Studio

数据结构

服务器

解释器

Python

JSON

Java

我可以在JSON文件中使用注释吗？如果是这样的话，是怎么做的？

问注释可以在JSON中使用吗？
EN

回答 30

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问注释可以在JSON中使用吗？EN

回答 30

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问注释可以在JSON中使用吗？
EN