Is parsing JSON faster than parsing XML

Question

I'm creating a sophisticated JavaScript library for working with my company's server side framework.

The server side framework encodes its data to a simple XML format. There's no fancy namespacing or anything like that.

Ideally I'd like to parse all of the data in the browser as JSON. However, if I do this I need to rewrite some of the server side code to also spit out JSON. This is a pain because we have public APIs that I can't easily change.

What I'm really concerned about here is performance in the browser of parsing JSON versus XML. Is there really a big difference to be concerned about? Or should I exclusively go for JSON? Does anyone have any experience or benchmarks in the performance difference between the two?

I realize that most modern web developers would probably opt for JSON and I can see why. However, I really am just interested in performance. If there's a proven massive difference then I'm prepared to spend the extra effort in generating JSON server side for the client.

Solution 1

JSON should be faster since it's JS Object Notation, which means it can be recognized natively by JavaScript. In PHP on the GET side of things, I will often do something like this:

<script type="text/javascript">
    var data = <?php json_encode($data)?>;
</script>

For more information on this, see here:

Why is Everyone Choosing JSON Over XML for jQuery?

Also...what "extra effort" do you really have to put into "generating" JSON? Surely you can't be saying that you'll be manually building the JSON string? Almost every modern server-side language has libraries that convert native variables into JSON strings. For example, PHP's core json_encode function converts an associative array like this:

$data = array('test'=>'val', 'foo'=>'bar');

into

{"test": "val", "foo": "bar"}

Which is simply a JavaScript object (since there are no associative arrays (strictly speaking) in JS).

Solution 2

Firstly, I'd like to say thanks to everyone who's answered my question. I REALLY appreciate all of your responses.

In regards to this question, I've conducted some further research by running some benchmarks. The parsing happens in the browser. IE 8 is the only browser that doesn't have a native JSON parser. The XML is the same data as the JSON version.

Chrome (version 8.0.552.224), JSON: 92ms, XML: 90ms

Firefox (version 3.6.13), JSON: 65ms, XML: 129ms

IE (version 8.0.6001.18702), JSON: 172ms, XML: 125ms

Interestingly, Chrome seems to have almost the same speed. Please note, this is parsing a lot of data. With little snippets of data, this isn't probably such a big deal.

Solution 3

Benchmarks have been done. Here's one. The difference in some of the earlier browsers appeared to be an entire order of magnitude (on the order of 10s of milliseconds instead of 100s of ms), but not massive. Part of this is in server response time - XML is bulkier as a data format. Part of it is parsing time - JSON lets you send JavaScript objects, while XML requires parsing a document.

You could consider adding to your public API a method to return JSON instead of modifying existing functions if it becomes and issue, unless you don't want to expose the JSON.

See also the SO question When to prefer JSON over XML?

Solution 4

Performance isn't really a consideration, assuming that you're not talking about gigabytes of XML. Yes, it will take longer (XML is more verbose), but it's not going to be something that the user will notice.

The real issue, in my opinion, is support for XML within JavaScript. E4X is nice, but it isn't supported by Microsoft. So you'll need to use a third-party library (such as JQuery) to parse the XML.

Solution 5

If possible, it would make sense to just measure it. By 'if possible' I mean that tooling for javascript (esp. for performance analysis) may not be quite as good as for stand-alone programming languages.

Why measure? Because speculation based solely on properties of data formats is not very useful for performance analysis -- developers' intuitions are notoriously poor at predicting performance. In this case it just means that it all comes down to maturity of respective XML and JSON parser (and generators) in use. XML has the benefit of having been around longer; JSON is bit simpler to process. This based on having actually written libraries for processing both. In the end, if all things are equal (maturity and performance optimization of libraries), JSON can indeed be bit faster to process. But both can be very fast; or very slow with bad implementations.

However: I suspect that you should not worry all that much about performance, like many have already suggested. Both xml and json can be parsed efficiently, and with modern browsers, probably are. Chances are that if you have performance problems it is not with reading or writing of data but something else; and first step would be actually figuring out what the actual problem is.

View more solutions

Comments

[Chris Lawlor]

Also, (as pointed out in the linked question), JSON is generally more lightweight simply in terms of bytes, making it more efficient to transmit. Most likely, you'll get much more of a performance benefit from reducing your bandwidth requirements than any difference in parsing JSON vs. XML.

[Alexander]

All browsers (with proper JavaScript support) are able to parse well-formed JSON code just as well as XML.

[Alexander]

That difference is only with small amounts of data. If your parsing more than a couple dozen lines (or so), then there will definitely be a significant amount of time spent parsing the data.

[Alexander]

I believe json_encode/decode need to be enabled when PHP is compiled.

[treeface]

@Alexander: I've never had to do that before. It always just works.

[Alex Vidal]

@Alexander: For sure. I wasn't implying that they didn't, just that he stated that switching to JSON on the server-side is a non-trivial task due to API interfaces and such, so I recommended sticking with XML instead.

[Alexander]

Correction, by adding --disable-json when compiling, JSON can be disabled.

[StaxMan]

Minor nitpick, wrt "JSON lets you send JavaScript objects, while XML requires parsing a document" -- this is not quite true; both need to be written and read (serialize/deserialize, marshal/unmarshal), as all data is sent as byte stream. It is true however that data structure being built for JSON is more natural, compared to XML DOM trees.

[justkt]

@StaxMan - thanks for the correction. The technical answer I meant to imply was that JSON on the client side can be eval-ed to an object (with the usual caveats of eval applying), while the DOM tree for XML must be parsed.

[StaxMan]

Wasn't me, but one thing I would point out is that XML parsing can already be done by AJAX request; resulting xml can be accessed directly as DOM tree. Or perhaps you were thinking of data binding from DOM (which is tree built from parsed xml) to "real" Javascript objects?

[StaxMan]

@justkt Ah ok, yes, then it would be related to binding of data itself

[Alexander]

@Alex Vidal, While I would normally agree, if he / she is planning on writing for XML-based code, it might just be better to convert over to JSON now so more code doesn't need to be re-written.

[treeface]

@Alex: I don't think JSON encoding should be considered non-trivial. In fact, most languages (or libraries, if there is no native support) make it entirely trivial to convert native data types into JSON.

[Alexander]

@quertymk, They also have JavaScript support, and therefor, JSON parsers.

[Alex Vidal]

@treeface: I agree that the actual conversion is non-trivial in most cases, I was referring specifically to his/her scenario "However, if I do this I need to rewrite some of the server side code to also spit out JSON. This is a pain because we have public APIs that I can't easily change." If the output is already XML, and it's well-formed, and it's a pain to convert it to also output JSON, then XML is the best choice.

[treeface]

@Alex: You're right...I suppose it entirely depends on the data source. I'm just so used to working with output from databases that constructing XML out of native data types always seems much more of a chore than something like: die(json_encode($query->result_array()); (not that I would ever mix my controller and model actions ;-)

[Matthew Flaschen]

All the major browsers now have support for native JSON, which is more secure, and often faster, than eval

[Dave]

I would be very interested to see an update of this with Firefox 9+ and Chrome 16+

[Joseph Lust]

@justkt - note that the "bulkier" part is essentially nullified if you use mod_deflate (gzipping) your responses. Further, for a public RESTapi, use max-age cache headers and public caching headers and you don't even need to worry about server side time, since they'll be cached for common calls. :)

[AncientSwordRage]

I just ran the benchmark and JSON vs XML was even in the first, and JSON:XML speed was 3:2 in the second. I'm in IE 8. Reason?

[bartosz.r]

Strange results, from my own experience json was alwyas much, much faster in browsers. Maybe you have some specific data, where the xml overhead is not much compared to the data itself. But, if it works that way for you, then it must be true. You can never assume something, you should always test.

[Mr. Concolato]

@geme_hendrix I think well structured JSON is going to be faster in most cases. Great question though.

[scaryguy]

I don't think that these benchmarks are accurate. As @justkt shared at his answer; this link has a good comparison between them.

[Dušan]

In fact I think these benchmarks are good. I followed the link that @scaryguy shared and then I tested myself (navioo.com/ajax/examples/json/test.php). Both in Chrome and in IE there was minimal difference between JSON and XML.

[Admin]

This answer is probably wrong on a few counts. JS does have associative arrays, in fact both {} and [] are associative arrays TMK. Second, the fact that JSON is a notation similar to JS objects doesn't mean that a JS implementation of JSON parsing is faster than a Java implementation of JSON parsing, etc.

[BitTickler]

Is that even legal JSON? The outer braces say JSON objectbut the content looks like a JSON array.