… | |
… | |
86 | package JSON::XS; |
86 | package JSON::XS; |
87 | |
87 | |
88 | use strict; |
88 | use strict; |
89 | |
89 | |
90 | BEGIN { |
90 | BEGIN { |
91 | our $VERSION = '1.12'; |
91 | our $VERSION = '1.24'; |
92 | our @ISA = qw(Exporter); |
92 | our @ISA = qw(Exporter); |
93 | |
93 | |
94 | our @EXPORT = qw(to_json from_json objToJson jsonToObj); |
94 | our @EXPORT = qw(to_json from_json objToJson jsonToObj); |
95 | require Exporter; |
95 | require Exporter; |
96 | |
96 | |
… | |
… | |
374 | |
374 | |
375 | JSON numbers and strings become simple Perl scalars. JSON arrays become |
375 | JSON numbers and strings become simple Perl scalars. JSON arrays become |
376 | Perl arrayrefs and JSON objects become Perl hashrefs. C<true> becomes |
376 | Perl arrayrefs and JSON objects become Perl hashrefs. C<true> becomes |
377 | C<1>, C<false> becomes C<0> and C<null> becomes C<undef>. |
377 | C<1>, C<false> becomes C<0> and C<null> becomes C<undef>. |
378 | |
378 | |
|
|
379 | =item ($perl_scalar, $characters) = $json->decode_prefix ($json_text) |
|
|
380 | |
|
|
381 | This works like the C<decode> method, but instead of raising an exception |
|
|
382 | when there is trailing garbage after the first JSON object, it will |
|
|
383 | silently stop parsing there and return the number of characters consumed |
|
|
384 | so far. |
|
|
385 | |
|
|
386 | This is useful if your JSON texts are not delimited by an outer protocol |
|
|
387 | (which is not the brightest thing to do in the first place) and you need |
|
|
388 | to know where the JSON text ends. |
|
|
389 | |
|
|
390 | JSON::XS->new->decode_prefix ("[1] the tail") |
|
|
391 | => ([], 3) |
|
|
392 | |
379 | =back |
393 | =back |
380 | |
394 | |
381 | |
395 | |
382 | =head1 MAPPING |
396 | =head1 MAPPING |
383 | |
397 | |
… | |
… | |
387 | (what you put in comes out as something equivalent). |
401 | (what you put in comes out as something equivalent). |
388 | |
402 | |
389 | For the more enlightened: note that in the following descriptions, |
403 | For the more enlightened: note that in the following descriptions, |
390 | lowercase I<perl> refers to the Perl interpreter, while uppcercase I<Perl> |
404 | lowercase I<perl> refers to the Perl interpreter, while uppcercase I<Perl> |
391 | refers to the abstract Perl language itself. |
405 | refers to the abstract Perl language itself. |
|
|
406 | |
392 | |
407 | |
393 | =head2 JSON -> PERL |
408 | =head2 JSON -> PERL |
394 | |
409 | |
395 | =over 4 |
410 | =over 4 |
396 | |
411 | |
… | |
… | |
427 | =item null |
442 | =item null |
428 | |
443 | |
429 | A JSON null atom becomes C<undef> in Perl. |
444 | A JSON null atom becomes C<undef> in Perl. |
430 | |
445 | |
431 | =back |
446 | =back |
|
|
447 | |
432 | |
448 | |
433 | =head2 PERL -> JSON |
449 | =head2 PERL -> JSON |
434 | |
450 | |
435 | The mapping from Perl to JSON is slightly more difficult, as Perl is a |
451 | The mapping from Perl to JSON is slightly more difficult, as Perl is a |
436 | truly typeless language, so we can only guess which JSON type is meant by |
452 | truly typeless language, so we can only guess which JSON type is meant by |
… | |
… | |
591 | |
607 | |
592 | Does not check input for validity. |
608 | Does not check input for validity. |
593 | |
609 | |
594 | =back |
610 | =back |
595 | |
611 | |
|
|
612 | |
|
|
613 | =head2 JSON and YAML |
|
|
614 | |
|
|
615 | You often hear that JSON is a subset (or a close subset) of YAML. This is, |
|
|
616 | however, a mass hysteria and very far from the truth. In general, there is |
|
|
617 | no way to configure JSON::XS to output a data structure as valid YAML. |
|
|
618 | |
|
|
619 | If you really must use JSON::XS to generate YAML, you should use this |
|
|
620 | algorithm (subject to change in future versions): |
|
|
621 | |
|
|
622 | my $to_yaml = JSON::XS->new->utf8->space_after (1); |
|
|
623 | my $yaml = $to_yaml->encode ($ref) . "\n"; |
|
|
624 | |
|
|
625 | This will usually generate JSON texts that also parse as valid |
|
|
626 | YAML. Please note that YAML has hardcoded limits on (simple) object key |
|
|
627 | lengths that JSON doesn't have, so you should make sure that your hash |
|
|
628 | keys are noticably shorter than the 1024 characters YAML allows. |
|
|
629 | |
|
|
630 | There might be other incompatibilities that I am not aware of. In general |
|
|
631 | you should not try to generate YAML with a JSON generator or vice versa, |
|
|
632 | or try to parse JSON with a YAML parser or vice versa: chances are high |
|
|
633 | that you will run into severe interoperability problems. |
|
|
634 | |
|
|
635 | |
596 | =head2 SPEED |
636 | =head2 SPEED |
597 | |
637 | |
598 | It seems that JSON::XS is surprisingly fast, as shown in the following |
638 | It seems that JSON::XS is surprisingly fast, as shown in the following |
599 | tables. They have been generated with the help of the C<eg/bench> program |
639 | tables. They have been generated with the help of the C<eg/bench> program |
600 | in the JSON::XS distribution, to make it easy to compare on your own |
640 | in the JSON::XS distribution, to make it easy to compare on your own |
601 | system. |
641 | system. |
602 | |
642 | |
603 | First comes a comparison between various modules using a very short JSON |
643 | First comes a comparison between various modules using a very short |
604 | string: |
644 | single-line JSON string: |
605 | |
645 | |
606 | {"method": "handleMessage", "params": ["user1", "we were just talking"], "id": null} |
646 | {"method": "handleMessage", "params": ["user1", "we were just talking"], \ |
|
|
647 | "id": null, "array":[1,11,234,-5,1e5,1e7, true, false]} |
607 | |
648 | |
608 | It shows the number of encodes/decodes per second (JSON::XS uses the |
649 | It shows the number of encodes/decodes per second (JSON::XS uses |
609 | functional interface, while JSON::XS/2 uses the OO interface with |
650 | the functional interface, while JSON::XS/2 uses the OO interface |
610 | pretty-printing and hashkey sorting enabled). Higher is better: |
651 | with pretty-printing and hashkey sorting enabled, JSON::XS/3 enables |
|
|
652 | shrink). Higher is better: |
611 | |
653 | |
612 | module | encode | decode | |
654 | module | encode | decode | |
613 | -----------|------------|------------| |
655 | -----------|------------|------------| |
614 | JSON | 11488.516 | 7823.035 | |
656 | JSON | 7645.468 | 4208.613 | |
615 | JSON::DWIW | 94708.054 | 129094.260 | |
657 | JSON::DWIW | 40721.398 | 77101.176 | |
616 | JSON::PC | 63884.157 | 128528.212 | |
658 | JSON::PC | 65948.176 | 78251.940 | |
617 | JSON::Syck | 34898.677 | 42096.911 | |
659 | JSON::Syck | 22844.793 | 26479.192 | |
618 | JSON::XS | 654027.064 | 396423.669 | |
660 | JSON::XS | 388361.481 | 199728.762 | |
619 | JSON::XS/2 | 371564.190 | 371725.613 | |
661 | JSON::XS/2 | 218453.333 | 192399.266 | |
|
|
662 | JSON::XS/3 | 338250.323 | 192399.266 | |
|
|
663 | Storable | 15779.925 | 14169.946 | |
620 | -----------+------------+------------+ |
664 | -----------+------------+------------+ |
621 | |
665 | |
622 | That is, JSON::XS is more than six times faster than JSON::DWIW on |
666 | That is, JSON::XS is about five times faster than JSON::DWIW on encoding, |
623 | encoding, more than three times faster on decoding, and about thirty times |
667 | about three times faster on decoding, and over fourty times faster |
624 | faster than JSON, even with pretty-printing and key sorting. |
668 | than JSON, even with pretty-printing and key sorting. It also compares |
|
|
669 | favourably to Storable for small amounts of data. |
625 | |
670 | |
626 | Using a longer test string (roughly 18KB, generated from Yahoo! Locals |
671 | Using a longer test string (roughly 18KB, generated from Yahoo! Locals |
627 | search API (http://nanoref.com/yahooapis/mgPdGg): |
672 | search API (http://nanoref.com/yahooapis/mgPdGg): |
628 | |
673 | |
629 | module | encode | decode | |
674 | module | encode | decode | |
630 | -----------|------------|------------| |
675 | -----------|------------|------------| |
631 | JSON | 273.023 | 44.674 | |
676 | JSON | 254.685 | 37.665 | |
632 | JSON::DWIW | 1089.383 | 1145.704 | |
677 | JSON::DWIW | 843.343 | 1049.731 | |
633 | JSON::PC | 3097.419 | 2393.921 | |
678 | JSON::PC | 3602.116 | 2307.352 | |
634 | JSON::Syck | 514.060 | 843.053 | |
679 | JSON::Syck | 505.107 | 787.899 | |
635 | JSON::XS | 6479.668 | 3636.364 | |
680 | JSON::XS | 5747.196 | 3690.220 | |
636 | JSON::XS/2 | 3774.221 | 3599.124 | |
681 | JSON::XS/2 | 3968.121 | 3676.634 | |
|
|
682 | JSON::XS/3 | 6105.246 | 3662.508 | |
|
|
683 | Storable | 4417.337 | 5285.161 | |
637 | -----------+------------+------------+ |
684 | -----------+------------+------------+ |
638 | |
685 | |
639 | Again, JSON::XS leads by far. |
686 | Again, JSON::XS leads by far (except for Storable which non-surprisingly |
|
|
687 | decodes faster). |
640 | |
688 | |
641 | On large strings containing lots of high unicode characters, some modules |
689 | On large strings containing lots of high unicode characters, some modules |
642 | (such as JSON::PC) seem to decode faster than JSON::XS, but the result |
690 | (such as JSON::PC) seem to decode faster than JSON::XS, but the result |
643 | will be broken due to missing (or wrong) unicode handling. Others refuse |
691 | will be broken due to missing (or wrong) unicode handling. Others refuse |
644 | to decode or encode properly, so it was impossible to prepare a fair |
692 | to decode or encode properly, so it was impossible to prepare a fair |
… | |
… | |
672 | |
720 | |
673 | And last but least, something else could bomb you that I forgot to think |
721 | And last but least, something else could bomb you that I forgot to think |
674 | of. In that case, you get to keep the pieces. I am always open for hints, |
722 | of. In that case, you get to keep the pieces. I am always open for hints, |
675 | though... |
723 | though... |
676 | |
724 | |
|
|
725 | If you are using JSON::XS to return packets to consumption |
|
|
726 | by javascript scripts in a browser you should have a look at |
|
|
727 | L<http://jpsykes.com/47/practical-csrf-and-json-security> to see wether |
|
|
728 | you are vulnerable to some common attack vectors (which really are browser |
|
|
729 | design bugs, but it is still you who will have to deal with it, as major |
|
|
730 | browser developers care only for features, not about doing security |
|
|
731 | right). |
|
|
732 | |
677 | |
733 | |
678 | =head1 BUGS |
734 | =head1 BUGS |
679 | |
735 | |
680 | While the goal of this module is to be correct, that unfortunately does |
736 | While the goal of this module is to be correct, that unfortunately does |
681 | not mean its bug-free, only that I think its design is bug-free. It is |
737 | not mean its bug-free, only that I think its design is bug-free. It is |