ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/JSON-XS/XS.pm
(Generate patch)

Comparing JSON-XS/XS.pm (file contents):
Revision 1.17 by root, Sat Mar 24 19:42:14 2007 UTC vs.
Revision 1.21 by root, Sun Mar 25 02:32:40 2007 UTC

… …
8 8
9 # exported functions, croak on error 9 # exported functions, croak on error
10 10
11 $utf8_encoded_json_text = to_json $perl_hash_or_arrayref; 11 $utf8_encoded_json_text = to_json $perl_hash_or_arrayref;
12 $perl_hash_or_arrayref = from_json $utf8_encoded_json_text; 12 $perl_hash_or_arrayref = from_json $utf8_encoded_json_text;
13
14 # objToJson and jsonToObj are exported for JSON
15 # compatibility, but should not be used in new code.
13 16
14 # oo-interface 17 # oo-interface
15 18
16 $coder = JSON::XS->new->ascii->pretty->allow_nonref; 19 $coder = JSON::XS->new->ascii->pretty->allow_nonref;
17 $pretty_printed_unencoded = $coder->encode ($perl_scalar); 20 $pretty_printed_unencoded = $coder->encode ($perl_scalar);
… …
36 39
37=head2 FEATURES 40=head2 FEATURES
38 41
39=over 4 42=over 4
40 43
41=item * correct handling of unicode issues 44=item * correct unicode handling
42 45
43This module knows how to handle Unicode, and even documents how and when 46This module knows how to handle Unicode, and even documents how and when
44it does so. 47it does so.
45 48
46=item * round-trip integrity 49=item * round-trip integrity
47 50
48When you serialise a perl data structure using only datatypes supported 51When you serialise a perl data structure using only datatypes supported
49by JSON, the deserialised data structure is identical on the Perl level. 52by JSON, the deserialised data structure is identical on the Perl level.
50(e.g. the string "2.0" doesn't suddenly become "2"). 53(e.g. the string "2.0" doesn't suddenly become "2" just because it looks
54like a number).
51 55
52=item * strict checking of JSON correctness 56=item * strict checking of JSON correctness
53 57
54There is no guessing, no generating of illegal JSON texts by default, 58There is no guessing, no generating of illegal JSON texts by default,
55and only JSON is accepted as input by default (the latter is a security 59and only JSON is accepted as input by default (the latter is a security
… …
66interface. 70interface.
67 71
68=item * reasonably versatile output formats 72=item * reasonably versatile output formats
69 73
70You can choose between the most compact guarenteed single-line format 74You can choose between the most compact guarenteed single-line format
71possible (nice for simple line-based protocols), a pure-ascii format (for 75possible (nice for simple line-based protocols), a pure-ascii format
72when your transport is not 8-bit clean), or a pretty-printed format (for 76(for when your transport is not 8-bit clean, still supports the whole
73when you want to read that stuff). Or you can combine those features in 77unicode range), or a pretty-printed format (for when you want to read that
74whatever way you like. 78stuff). Or you can combine those features in whatever way you like.
75 79
76=back 80=back
77 81
78=cut 82=cut
79 83
80package JSON::XS; 84package JSON::XS;
81 85
86use strict;
87
82BEGIN { 88BEGIN {
83 $VERSION = '0.5'; 89 our $VERSION = '0.8';
84 @ISA = qw(Exporter); 90 our @ISA = qw(Exporter);
85 91
86 @EXPORT = qw(to_json from_json); 92 our @EXPORT = qw(to_json from_json objToJson jsonToObj);
87 require Exporter; 93 require Exporter;
88 94
89 require XSLoader; 95 require XSLoader;
90 XSLoader::load JSON::XS::, $VERSION; 96 XSLoader::load JSON::XS::, $VERSION;
91} 97}
… …
527tables. They have been generated with the help of the C<eg/bench> program 533tables. They have been generated with the help of the C<eg/bench> program
528in the JSON::XS distribution, to make it easy to compare on your own 534in the JSON::XS distribution, to make it easy to compare on your own
529system. 535system.
530 536
531First comes a comparison between various modules using a very short JSON 537First comes a comparison between various modules using a very short JSON
532string (83 bytes), showing the number of encodes/decodes per second 538string:
533(JSON::XS is the functional interface, while JSON::XS/2 is the OO 539
540 {"method": "handleMessage", "params": ["user1", "we were just talking"], "id": null}
541
542It shows the number of encodes/decodes per second (JSON::XS uses the
543functional interface, while JSON::XS/2 uses the OO interface with
534interface with pretty-printing and hashkey sorting enabled). Higher is 544pretty-printing and hashkey sorting enabled). Higher is better:
535better:
536 545
537 module | encode | decode | 546 module | encode | decode |
538 -----------|------------|------------| 547 -----------|------------|------------|
539 JSON | 14006 | 6820 | 548 JSON | 11488.516 | 7823.035 |
540 JSON::DWIW | 200937 | 120386 | 549 JSON::DWIW | 94708.054 | 129094.260 |
541 JSON::PC | 85065 | 129366 | 550 JSON::PC | 63884.157 | 128528.212 |
542 JSON::Syck | 59898 | 44232 | 551 JSON::Syck | 34898.677 | 42096.911 |
543 JSON::XS | 1171478 | 342435 | 552 JSON::XS | 654027.064 | 396423.669 |
544 JSON::XS/2 | 730760 | 328714 | 553 JSON::XS/2 | 371564.190 | 371725.613 |
545 -----------+------------+------------+ 554 -----------+------------+------------+
546 555
547That is, JSON::XS is 6 times faster than than JSON::DWIW and about 80 556That is, JSON::XS is more than six times faster than JSON::DWIW on
557encoding, more than three times faster on decoding, and about thirty times
548times faster than JSON, even with pretty-printing and key sorting. 558faster than JSON, even with pretty-printing and key sorting.
549 559
550Using a longer test string (roughly 18KB, generated from Yahoo! Locals 560Using a longer test string (roughly 18KB, generated from Yahoo! Locals
551search API (http://nanoref.com/yahooapis/mgPdGg): 561search API (http://nanoref.com/yahooapis/mgPdGg):
552 562
553 module | encode | decode | 563 module | encode | decode |
554 -----------|------------|------------| 564 -----------|------------|------------|
555 JSON | 673 | 38 | 565 JSON | 273.023 | 44.674 |
556 JSON::DWIW | 5271 | 770 | 566 JSON::DWIW | 1089.383 | 1145.704 |
557 JSON::PC | 9901 | 2491 | 567 JSON::PC | 3097.419 | 2393.921 |
558 JSON::Syck | 2360 | 786 | 568 JSON::Syck | 514.060 | 843.053 |
559 JSON::XS | 37398 | 3202 | 569 JSON::XS | 6479.668 | 3636.364 |
560 JSON::XS/2 | 13765 | 3153 | 570 JSON::XS/2 | 3774.221 | 3599.124 |
561 -----------+------------+------------+ 571 -----------+------------+------------+
562 572
563Again, JSON::XS leads by far in the encoding case, while still beating 573Again, JSON::XS leads by far.
564every other module in the decoding case.
565 574
566On large strings containing lots of unicode characters, some modules 575On large strings containing lots of high unicode characters, some modules
567(such as JSON::PC) decode faster than JSON::XS, but the result will be 576(such as JSON::PC) seem to decode faster than JSON::XS, but the result
568broken due to missing unicode handling. Others refuse to decode or encode 577will be broken due to missing (or wrong) unicode handling. Others refuse
569properly, so it was impossible to prepare a fair comparison table for that 578to decode or encode properly, so it was impossible to prepare a fair
570case. 579comparison table for that case.
571 580
572=head1 RESOURCE LIMITS 581=head1 RESOURCE LIMITS
573 582
574JSON::XS does not impose any limits on the size of JSON texts or Perl 583JSON::XS does not impose any limits on the size of JSON texts or Perl
575values they represent - if your machine can handle it, JSON::XS will 584values they represent - if your machine can handle it, JSON::XS will

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines