blocks|key|2019687|text|它们是表示数据的两种不同方式，但它们非常不同。JSON和XML的维基百科页面给出了各自的例子，并且有一个comparison段落|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2019688|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/JSON|1|http://en.wikipedia.org/wiki/XML|2|http://en.wikipedia.org/wiki/JSON#XML^0|N|4|0|S|3|1|1G|A|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

They're two different ways of representing data, but they're pretty dissimilar. The wikipedia pages for <a href="http://en.wikipedia.org/wiki/JSON" rel="nofollow noreferrer">JSON</a> and <a href="http://en.wikipedia.org/wiki/XML" rel="nofollow noreferrer">XML</a> give some examples of each, and there's a <a href="http://en.wikipedia.org/wiki/JSON#XML" rel="nofollow noreferrer">comparison</a> paragraph

blocks|key|2019712|text|它们是信息表示的两种格式。JSON被设计得更紧凑，而XML被设计得更具可读性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2019713|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|$]]

They are two formats of representation of information. While JSON was designed to be more compact, XML was design to be more readable.

blocks|key|2019731|text|像<tag>item</tag>一样，XML使用标记结构来表示项目，因此XML文档是一组相互嵌套的标记。JSON语法看起来像是Javascript语言的一个结构，所有的东西都像列表和字典：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2019732|{
+'attrib'+:+'value',
+'array'+:+[1,+2,+3]
}|code-block|syntax|javascript|2019733|因此，如果您使用JSON，那么在许多脚本语言中使用JSON字符串非常简单，尤其是Javascript和Python。|2019734|entityMap^0|1|F|0|0|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|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

XML uses a tag structures for presenting items, like 
<code>&lt;tag&gt;item&lt;/tag&gt;</code>, 
so an XML document is a set of tags nested into each other.
And JSON syntax looks like a construction from Javascript language, with all stuff like lists and dictionaries:

<pre><code>{
 'attrib' : 'value',
 'array' : [1, 2, 3]
}
</code></pre>

So if you use JSON it's really simple to use a JSON strings in many script languages, especially Javascript and Python.

blocks|key|1806270|text|它们都是分层数据的数据格式，因此虽然语法有很大不同，但结构是相似的。示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1806271|JSON：|1806272|{
++"persons":+[
++++{
++++++"name":+"Ford+Prefect",
++++++"gender":+"male"
++++},
++++{
++++++"name":+"Arthur+Dent",
++++++"gender":+"male"
++++},
++++{
++++++"name":+"Tricia+McMillan",
++++++"gender":+"female"
++++}
++]
}|code-block|syntax|javascript|1806273|XML：|1806274|<persons>
++<person>
++++<name>Ford+Prefect</name>
++++<gender>male</gender>
++</person>
++<person>
++++<name>Arthur+Dent</name>
++++<gender>male</gender>
++</person>
++<person>
++++<name>Tricia+McMillan</name>
++++<gender>female</gender>
++</person>
</persons>|1806275|不过，XML格式比示例中显示的要高级得多。例如，您可以向每个元素添加属性，还可以使用名称空间对元素进行分区。还有一些标准用于定义XML文件的格式、查询XML数据的XPATH语言以及将XML转换为表示数据的XSLT。|1806276|XML格式已经出现了一段时间，因此有很多为其开发的软件。JSON格式非常新，因此对它的支持要少得多。|1806277|XML是作为一种独立的数据格式开发的，而JSON是专门为与Javascript和AJAX一起使用而开发的，因此该格式与Javascript文本对象完全相同(也就是说，它是Javascript代码的子集，例如，它不能包含用于确定值的表达式)。|1806278|entityMap^0|0|0|0|0|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|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

They are both data formats for hierarchical data, so while the syntax is quite different, the structure is similar. Example:
JSON:
<pre class="lang-json prettyprint-override"><code>{
 &quot;persons&quot;: [
 {
 &quot;name&quot;: &quot;Ford Prefect&quot;,
 &quot;gender&quot;: &quot;male&quot;
 },
 {
 &quot;name&quot;: &quot;Arthur Dent&quot;,
 &quot;gender&quot;: &quot;male&quot;
 },
 {
 &quot;name&quot;: &quot;Tricia McMillan&quot;,
 &quot;gender&quot;: &quot;female&quot;
 }
 ]
}
</code></pre>
XML:
<pre class="lang-xml prettyprint-override"><code>&lt;persons&gt;
 &lt;person&gt;
 &lt;name&gt;Ford Prefect&lt;/name&gt;
 &lt;gender&gt;male&lt;/gender&gt;
 &lt;/person&gt;
 &lt;person&gt;
 &lt;name&gt;Arthur Dent&lt;/name&gt;
 &lt;gender&gt;male&lt;/gender&gt;
 &lt;/person&gt;
 &lt;person&gt;
 &lt;name&gt;Tricia McMillan&lt;/name&gt;
 &lt;gender&gt;female&lt;/gender&gt;
 &lt;/person&gt;
&lt;/persons&gt;
</code></pre>
The XML format is more advanced than shown by the example, though. You can for example add attributes to each element, and you can use namespaces to partition elements. There are also standards for defining the format of an XML file, the XPATH language to query XML data, and XSLT for transforming XML into presentation data.
The XML format has been around for some time, so there is a lot of software developed for it. The JSON format is quite new, so there is a lot less support for it.
While XML was developed as an independent data format, JSON was developed specifically for use with Javascript and AJAX, so the format is exactly the same as a Javascript literal object (that is, it's a subset of the Javascript code, as it for example can't contain expressions to determine values).

blocks|key|2019940|text|根本的区别是XML是一种标记语言(就像它在名字中所说的那样)，而JSON是一种表示对象的方式(在它的名字中也提到了这一点)，这似乎没有其他答案提到过。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2019941|标记语言是向自由流动的纯文本添加额外信息的一种方式，例如|2019942|Here+is+some+text.|code-block|syntax|javascript|2019943|使用XML+(使用特定的元素词汇表)，您可以将：|2019944|<Document>
++++<Paragraph+Align="Center">
++++++++Here+<Bold>is</Bold>+some+text.
++++</Paragraph>
</Document>|2019945|这就是标记语言对表示文档如此有用的原因。|2019946|像JSON这样的对象表示法就没有那么灵活了。但这通常是一件好事。当你表示对象时，你根本不需要额外的灵活性。要用JSON表示上述示例，实际上必须手动解决XML为您解决的一些问题。|2019947|{
++++"Paragraphs":+[
++++++++{
++++++++++++"align":+"center",
++++++++++++"content":+[
++++++++++++++++"Here+",+{
++++++++++++++++++++"style"+:+"bold",
++++++++++++++++++++"content":+[+"is"+]
++++++++++++++++},
++++++++++++++++"+some+text."
++++++++++++]
++++++++}
++++]
}|2019948|它不像XML那么好，原因是我们试图用对象表示法来做标记。因此，我们必须发明一种方法来在我们的对象周围散布纯文本片段，使用"content“数组，可以保存字符串和嵌套对象的混合。|2019949|另一方面，如果您有典型的对象层次结构，并且希望在流中表示它们，则JSON比HTML更适合于此任务。|2019950|{
++++"firstName":+"Homer",
++++"lastName":+"Simpson",
++++"relatives":+[+"Grandpa",+"Marge",+"The+Boy",+"Lisa",+"I+think+that's+all+of+them"+]
}+|2019951|下面是逻辑上等价的XML：|2019952|<Person>
++++<FirstName>Homer</FirstName>
++++<LastName>Simpsons</LastName>
++++<Relatives>
++++++++<Relative>Grandpa</Relative>
++++++++<Relative>Marge</Relative>
++++++++<Relative>The+Boy</Relative>
++++++++<Relative>Lisa</Relative>
++++++++<Relative>I+think+that's+all+of+them</Relative>
++++</Relatives>
</Person>|2019953|JSON看起来更像我们在编程语言中声明的数据结构。此外，它还减少了多余的名称重复。|2019954|但最重要的是，它有一种定义的方法来区分“记录”(无序的项目，按名称标识)和“列表”(排序的项目，按位置标识)。如果没有这样的区别，对象表示法实际上是无用的。而XML没有这样的区别！在我的示例中，<Person>是一条记录，<Relatives>是一个列表，但是它们并不是通过语法来标识的。|offset|length|style|CODE|2019955|相反，XML具有“元素”和“属性”。这看起来是相同的区别，但事实并非如此，因为属性只能有字符串值。它们不能是嵌套对象。所以我不可能将这个想法应用于<Person>，因为我不应该将<Relatives>转换为单个字符串。|2019956|通过使用外部模式或额外的用户定义属性，可以在XML中正式化列表和记录之间的区别。JSON的优势在于它的低级语法内置了这种区别，因此它非常简洁和通用。这意味着JSON在默认情况下更加“自我描述”，这是两种格式的一个重要目标。|2019957|因此，JSON应该是对象表示法的首选，而XML的最佳位置是文档标记。|2019958|不幸的是，对于XML来说，我们已经将HTML作为世界上最好的富文本标记语言。有人试图用XML重新表述HTML，但这样做没有太大的好处。|2019959|所以(在我看来)+XML应该是一种非常有限的小众技术，如果您出于某种原因不想使用HTML，那么它最适合于发明您自己的富文本标记语言。问题是在1998年，仍然有很多关于Web的炒作，XML因为表面上与HTML相似而变得流行起来。尝试将其应用于分层数据是一种奇怪的设计选择，这种语法实际上是为方便标记而设计的。|2019960|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|2P|8|33|B|0|21|8|2H|B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1P|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1Q|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1R|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1S|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1T|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1U|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1V|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1W|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|1X|8|@]|9|@]|A|$]]|$1|10|3|11|5|F|7|1Y|8|@]|9|@]|A|$G|H]]|$1|12|3|13|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|20|8|@$16|21|17|22|18|19]|$16|23|17|24|18|19]]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|25|8|@$16|26|17|27|18|19]|$16|28|17|29|18|19]]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|2A|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2B|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2C|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|2D|8|@]|9|@]|A|$]]|$1|1K|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]]|1L|$]]

The fundamental difference, which no other answer seems to have mentioned, is that XML is a markup language (as it actually says in its name), whereas JSON is a way of representing objects (as also noted in its name).
A markup language is a way of adding extra information to free-flowing plain text, e.g
<pre><code>Here is some text.
</code></pre>
With XML (using a certain element vocabulary) you can put:
<pre class="lang-xml prettyprint-override"><code>&lt;Document&gt;
 &lt;Paragraph Align=&quot;Center&quot;&gt;
 Here &lt;Bold&gt;is&lt;/Bold&gt; some text.
 &lt;/Paragraph&gt;
&lt;/Document&gt;
</code></pre>
This is what makes markup languages so useful for representing documents.
An object notation like JSON is not as flexible. But this is usually a good thing. When you're representing objects, you simply don't need the extra flexibility. To represent the above example in JSON, you'd actually have to solve some problems manually that XML solves for you.
<pre class="lang-json prettyprint-override"><code>{
 &quot;Paragraphs&quot;: [
 {
 &quot;align&quot;: &quot;center&quot;,
 &quot;content&quot;: [
 &quot;Here &quot;, {
 &quot;style&quot; : &quot;bold&quot;,
 &quot;content&quot;: [ &quot;is&quot; ]
 },
 &quot; some text.&quot;
 ]
 }
 ]
}
</code></pre>
It's not as nice as the XML, and the reason is that we're trying to do markup with an object notation. So we have to invent a way to scatter snippets of plain text around our objects, using &quot;content&quot; arrays that can hold a mixture of strings and nested objects.
On the other hand, if you have typical a hierarchy of objects and you want to represent them in a stream, JSON is better suited to this task than HTML.
<pre class="lang-json prettyprint-override"><code>{
 &quot;firstName&quot;: &quot;Homer&quot;,
 &quot;lastName&quot;: &quot;Simpson&quot;,
 &quot;relatives&quot;: [ &quot;Grandpa&quot;, &quot;Marge&quot;, &quot;The Boy&quot;, &quot;Lisa&quot;, &quot;I think that's all of them&quot; ]
} 
</code></pre>
Here's the logically equivalent XML:
<pre class="lang-xml prettyprint-override"><code>&lt;Person&gt;
 &lt;FirstName&gt;Homer&lt;/FirstName&gt;
 &lt;LastName&gt;Simpsons&lt;/LastName&gt;
 &lt;Relatives&gt;
 &lt;Relative&gt;Grandpa&lt;/Relative&gt;
 &lt;Relative&gt;Marge&lt;/Relative&gt;
 &lt;Relative&gt;The Boy&lt;/Relative&gt;
 &lt;Relative&gt;Lisa&lt;/Relative&gt;
 &lt;Relative&gt;I think that's all of them&lt;/Relative&gt;
 &lt;/Relatives&gt;
&lt;/Person&gt;
</code></pre>
JSON looks more like the data structures we declare in programming languages. Also it has less redundant repetition of names.
But most importantly of all, it has a defined way of distinguishing between a &quot;record&quot; (items unordered, identified by names) and a &quot;list&quot; (items ordered, identified by position). An object notation is practically useless without such a distinction. And XML has no such distinction! In my XML example <code>&lt;Person&gt;</code> is a record and <code>&lt;Relatives&gt;</code> is a list, but they are not identified as such by the syntax.
Instead, XML has &quot;elements&quot; versus &quot;attributes&quot;. This looks like the same kind of distinction, but it's not, because attributes can only have string values. They cannot be nested objects. So I couldn't have applied this idea to <code>&lt;Person&gt;</code>, because I shouldn't have to turn <code>&lt;Relatives&gt;</code> into a single string.
By using an external schema, or extra user-defined attributes, you can formalise a distinction between lists and records in XML. The advantage of JSON is that the low-level syntax has that distinction built into it, so it's very succinct and universal. This means that JSON is more &quot;self describing&quot; by default, which is an important goal of both formats.
So JSON should be the first choice for object notation, where XML's sweet spot is document markup.
Unfortunately for XML, we already have HTML as the world's number one rich text markup language. An attempt was made to reformulate HTML in terms of XML, but there isn't much advantage in this.
So XML should (in my opinion) have been a pretty limited niche technology, best suited only for inventing your own rich text markup languages if you don't want to use HTML for some reason. The problem was that in 1998 there was still a lot of hype about the Web, and XML became popular due to its superficial resemblance to HTML. It was a strange design choice to try to apply to hierarchical data a syntax actually designed for convenient markup.

blocks|key|1806456|text|XML和JSON之间的区别在于XML是一种元语言/标记语言，而JSON是一种轻量级的数据交换。也就是说，XML语法被专门设计为没有固有的语义。在特定的处理应用程序以特定的方式处理它们之前，特定的元素名称没有任何意义。相比之下，JSON语法在{}之间是一个对象，在[]之间是一个数组，等等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1806457|因此，JSON解析器确切地知道每个JSON文档的含义。XML解析器只知道如何将标记与数据分开。要处理XML文档的含义，必须编写额外的代码。|1806458|为了说明这一点，让我借用Guffa的例子：|1806459|{+++"persons":+[
++{
++++"name":+"Ford+Prefect",
++++"gender":+"male"
+},
+{
+++"name":+"Arthur+Dent",
+++"gender":+"male"
++},
++{
++++"name":+"Tricia+McMillan",
++++"gender":+"female"
++}+++
+]+
}|code-block|syntax|javascript|1806460|他给出的XML等效物实际上不是同一件事，因为虽然JSON示例在语义上是完整的，但XML需要以特定的方式进行解释才能达到相同的效果。实际上，JSON是一个使用已建立的标记语言的示例，其语义是已知的，而XML示例创建了一个全新的标记语言，而没有任何预定义的语义。|1806461|更好的XML等价物是定义一种(虚构的)+XJSON语言，它具有与JSON相同的语义，但使用XML语法。它可能看起来像这样：|1806462|<xjson>+++
++<object>
++++<name>persons</name>
++++<value>
++++++<array>
+++++++++<object>
++++++++++++<value>Ford+Prefect</value>
++++++++++++<gender>male</gender>
+++++++++</object>
+++++++++<object>
++++++++++++<value>Arthur+Dent</value>
++++++++++++<gender>male</gender>
+++++++++</object>
+++++++++<object>
++++++++++++<value>Tricia+McMillan</value>
++++++++++++<gender>female</gender>
+++++++++</object>
++++++</array>
++++</value>+++
++</object>+
+</xjson>|1806463|一旦编写了XJSON处理器，它就可以做JSON处理器所做的事情，处理JSON可以表示的所有类型的数据，并且您可以在JSON和XJSON之间无损地转换数据。|1806464|因此，抱怨XML没有与JSON相同的语义是没有切中要害的。XML语法被设计成无语义的。重点是提供一种底层语法，可用于创建具有任何语义的标记语言。这使得XML非常适合构造即席数据和文档格式，因为您不必为它们构建解析器，只需为它们编写一个处理器即可。|1806465|但是XML的缺点是语法冗长。对于您想要创建的任何给定标记语言，您可以想出一种更简洁的语法来表达特定语言的特定语义。因此，JSON语法比我上面假设的XJSON要紧凑得多。|1806466|如上所述，对于真正广泛使用的数据格式，创建唯一语法并为该语法编写解析器所需的额外时间被定制标记语言的更简洁和更直观的语法所抵消。它还表明，使用JSON及其已建立的语义通常比使用大量XML标记语言更有意义，因为您需要为这些标记语言实现语义。|1806467|它还表明，在XML中构建特定类型的语言和协议的原型是有意义的，但是，一旦语言或协议得到普遍使用，就需要考虑创建更紧凑和更具表现力的自定义语法。|1806468|有趣的是，作为附注，SGML认识到了这一点，并提供了一种为SGML文档指定简化标记的机制。因此，您实际上可以为JSON语法编写SGML+DTD，从而允许SGML解析器读取JSON文档。XML删除了这一功能，这意味着，如果您想为特定的标记语言提供更紧凑的语法，就必须抛弃XML，就像JSON所做的那样。|1806469|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|1A|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1F|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1G|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|13|$]]

The difference between XML and JSON is that XML is a meta-language/markup language and JSON is a lightweight data-interchange. That is, XML syntax is designed specifically to have no inherent semantics. Particular element names don't mean anything until a particular processing application processes them in a particular way. By contrast, JSON syntax has specific semantics built in stuff between {} is an object, stuff between [] is an array, etc.
A JSON parser, therefore, knows exactly what every JSON document means. An XML parser only knows how to separate markup from data. To deal with the meaning of an XML document, you have to write additional code.
To illustrate the point, let me borrow Guffa's example:
<pre class="lang-json prettyprint-override"><code>{ &quot;persons&quot;: [
 {
 &quot;name&quot;: &quot;Ford Prefect&quot;,
 &quot;gender&quot;: &quot;male&quot;
 },
 {
 &quot;name&quot;: &quot;Arthur Dent&quot;,
 &quot;gender&quot;: &quot;male&quot;
 },
 {
 &quot;name&quot;: &quot;Tricia McMillan&quot;,
 &quot;gender&quot;: &quot;female&quot;
 } 
 ] 
}
</code></pre>
The XML equivalent he gives is not really the same thing since while the JSON example is semantically complete, the XML would require to be interpreted in a particular way to have the same effect. In effect, the JSON is an example uses an established markup language of which the semantics are already known, whereas the XML example creates a brand new markup language without any predefined semantics.
A better XML equivalent would be to define a (fictitious) XJSON language with the same semantics as JSON, but using XML syntax. It might look something like this:
<pre class="lang-xml prettyprint-override"><code>&lt;xjson&gt; 
 &lt;object&gt;
 &lt;name&gt;persons&lt;/name&gt;
 &lt;value&gt;
 &lt;array&gt;
 &lt;object&gt;
 &lt;value&gt;Ford Prefect&lt;/value&gt;
 &lt;gender&gt;male&lt;/gender&gt;
 &lt;/object&gt;
 &lt;object&gt;
 &lt;value&gt;Arthur Dent&lt;/value&gt;
 &lt;gender&gt;male&lt;/gender&gt;
 &lt;/object&gt;
 &lt;object&gt;
 &lt;value&gt;Tricia McMillan&lt;/value&gt;
 &lt;gender&gt;female&lt;/gender&gt;
 &lt;/object&gt;
 &lt;/array&gt;
 &lt;/value&gt; 
 &lt;/object&gt; 
 &lt;/xjson&gt;
</code></pre>
Once you wrote an XJSON processor, it could do exactly what JSON processor does, for all the types of data that JSON can represent, and you could translate data losslessly between JSON and XJSON.
So, to complain that XML does not have the same semantics as JSON is to miss the point. XML syntax is semantics-free by design. The point is to provide an underlying syntax that can be used to create markup languages with any semantics you want. This makes XML great for making up ad-hoc data and document formats, because you don't have to build parsers for them, you just have to write a processor for them.
But the downside of XML is that the syntax is verbose. For any given markup language you want to create, you can come up with a much more succinct syntax that expresses the particular semantics of your particular language. Thus JSON syntax is much more compact than my hypothetical XJSON above.
If follows that for really widely used data formats, the extra time required to create a unique syntax and write a parser for that syntax is offset by the greater succinctness and more intuitive syntax of the custom markup language. It also follows that it often makes more sense to use JSON, with its established semantics, than to make up lots of XML markup languages for which you then need to implement semantics.
It also follows that it makes sense to prototype certain types of languages and protocols in XML, but, once the language or protocol comes into common use, to think about creating a more compact and expressive custom syntax.
It is interesting, as a side note, that SGML recognized this and provided a mechanism for specifying reduced markup for an SGML document. Thus you could actually write an SGML DTD for JSON syntax that would allow a JSON document to be read by an SGML parser. XML removed this capability, which means that, today, if you want a more compact syntax for a specific markup language, you have to leave XML behind, as JSON does.

What is the difference between JSON and XML?

what is the difference between json and xml

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

问json和xml之间的区别是什么
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问json和xml之间的区别是什么EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问json和xml之间的区别是什么
EN