File Coverage

Criterion Covered Total %
statement 18 18 100.0
branch n/a
condition n/a
subroutine 5 5 100.0
pod n/a
total 23 23 100.0

line stmt bran cond sub pod time code
1             =head1 NAME
3             JSON::XS - JSON serialising/deserialising, done correctly and fast
5             =encoding utf-8
7             JSON::XS - 正しくて高速な JSON シリアライザ/デシリアライザ
8             (
10             =head1 SYNOPSIS
12             use JSON::XS;
14             # exported functions, they croak on error
15             # and expect/generate UTF-8
17             $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref;
18             $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text;
20             # OO-interface
22             $coder = JSON::XS->new->ascii->pretty->allow_nonref;
23             $pretty_printed_unencoded = $coder->encode ($perl_scalar);
24             $perl_scalar = $coder->decode ($unicode_json_text);
26             # Note that JSON version 2.0 and above will automatically use JSON::XS
27             # if available, at virtually no speed overhead either, so you should
28             # be able to just:
30             use JSON;
32             # and do the same things, except that you have a pure-perl fallback now.
34             =head1 DESCRIPTION
36             This module converts Perl data structures to JSON and vice versa. Its
37             primary goal is to be I and its secondary goal is to be
38             I. To reach the latter goal it was written in C.
40             See MAPPING, below, on how JSON::XS maps perl values to JSON values and
41             vice versa.
43             =head2 FEATURES
45             =over
47             =item * correct Unicode handling
49             This module knows how to handle Unicode, documents how and when it does
50             so, and even documents what "correct" means.
52             =item * round-trip integrity
54             When you serialise a perl data structure using only data types supported
55             by JSON and Perl, the deserialised data structure is identical on the Perl
56             level. (e.g. the string "2.0" doesn't suddenly become "2" just because
57             it looks like a number). There I minor exceptions to this, read the
58             MAPPING section below to learn about those.
60             =item * strict checking of JSON correctness
62             There is no guessing, no generating of illegal JSON texts by default,
63             and only JSON is accepted as input by default (the latter is a security
64             feature).
66             =item * fast
68             Compared to other JSON modules and other serialisers such as Storable,
69             this module usually compares favourably in terms of speed, too.
71             =item * simple to use
73             This module has both a simple functional interface as well as an object
74             oriented interface.
76             =item * reasonably versatile output formats
78             You can choose between the most compact guaranteed-single-line format
79             possible (nice for simple line-based protocols), a pure-ASCII format
80             (for when your transport is not 8-bit clean, still supports the whole
81             Unicode range), or a pretty-printed format (for when you want to read that
82             stuff). Or you can combine those features in whatever way you like.
84             =back
86             =cut
88             package JSON::XS;
90 25     25   676004 use common::sense;
  25         540  
  25         144  
92             our $VERSION = '4.03';
93             our @ISA = qw(Exporter);
95             our @EXPORT = qw(encode_json decode_json);
97 25     25   2591 use Exporter;
  25         48  
  25         926  
98 25     25   136 use XSLoader;
  25         54  
  25         654  
100 25     25   11894 use Types::Serialiser ();
  25         79589  
  25         10670  
102             =head1 FUNCTIONAL INTERFACE
104             The following convenience methods are provided by this module. They are
105             exported by default:
107             =over
109             =item $json_text = encode_json $perl_scalar
111             Converts the given Perl data structure to a UTF-8 encoded, binary string
112             (that is, the string contains octets only). Croaks on error.
114             This function call is functionally identical to:
116             $json_text = JSON::XS->new->utf8->encode ($perl_scalar)
118             Except being faster.
120             =item $perl_scalar = decode_json $json_text
122             The opposite of C: expects a UTF-8 (binary) string and tries
123             to parse that as a UTF-8 encoded JSON text, returning the resulting
124             reference. Croaks on error.
126             This function call is functionally identical to:
128             $perl_scalar = JSON::XS->new->utf8->decode ($json_text)
130             Except being faster.
132             =back
135             =head1 A FEW NOTES ON UNICODE AND PERL
137             Since this often leads to confusion, here are a few very clear words on
138             how Unicode works in Perl, modulo bugs.
140             =over
142             =item 1. Perl strings can store characters with ordinal values > 255.
144             This enables you to store Unicode characters as single characters in a
145             Perl string - very natural.
147             =item 2. Perl does I associate an encoding with your strings.
149             ... until you force it to, e.g. when matching it against a regex, or
150             printing the scalar to a file, in which case Perl either interprets your
151             string as locale-encoded text, octets/binary, or as Unicode, depending
152             on various settings. In no case is an encoding stored together with your
153             data, it is I that decides encoding, not any magical meta data.
155             =item 3. The internal utf-8 flag has no meaning with regards to the
156             encoding of your string.
158             Just ignore that flag unless you debug a Perl bug, a module written in
159             XS or want to dive into the internals of perl. Otherwise it will only
160             confuse you, as, despite the name, it says nothing about how your string
161             is encoded. You can have Unicode strings with that flag set, with that
162             flag clear, and you can have binary data with that flag set and that flag
163             clear. Other possibilities exist, too.
165             If you didn't know about that flag, just the better, pretend it doesn't
166             exist.
168             =item 4. A "Unicode String" is simply a string where each character can be
169             validly interpreted as a Unicode code point.
171             If you have UTF-8 encoded data, it is no longer a Unicode string, but a
172             Unicode string encoded in UTF-8, giving you a binary string.
174             =item 5. A string containing "high" (> 255) character values is I a UTF-8 string.
176             It's a fact. Learn to live with it.
178             =back
180             I hope this helps :)
183             =head1 OBJECT-ORIENTED INTERFACE
185             The object oriented interface lets you configure your own encoding or
186             decoding style, within the limits of supported formats.
188             =over
190             =item $json = new JSON::XS
192             Creates a new JSON::XS object that can be used to de/encode JSON
193             strings. All boolean flags described below are by default I
194             (with the exception of C, which defaults to I since
195             version C<4.0>).
197             The mutators for flags all return the JSON object again and thus calls can
198             be chained:
200             my $json = JSON::XS->new->utf8->space_after->encode ({a => [1,2]})
201             => {"a": [1, 2]}
203             =item $json = $json->ascii ([$enable])
205             =item $enabled = $json->get_ascii
207             If C<$enable> is true (or missing), then the C method will not
208             generate characters outside the code range C<0..127> (which is ASCII). Any
209             Unicode characters outside that range will be escaped using either a
210             single \uXXXX (BMP characters) or a double \uHHHH\uLLLLL escape sequence,
211             as per RFC4627. The resulting encoded JSON text can be treated as a native
212             Unicode string, an ascii-encoded, latin1-encoded or UTF-8 encoded string,
213             or any other superset of ASCII.
215             If C<$enable> is false, then the C method will not escape Unicode
216             characters unless required by the JSON syntax or other flags. This results
217             in a faster and more compact format.
219             See also the section I later in this
220             document.
222             The main use for this flag is to produce JSON texts that can be
223             transmitted over a 7-bit channel, as the encoded JSON texts will not
224             contain any 8 bit characters.
226             JSON::XS->new->ascii (1)->encode ([chr 0x10401])
227             => ["\ud801\udc01"]
229             =item $json = $json->latin1 ([$enable])
231             =item $enabled = $json->get_latin1
233             If C<$enable> is true (or missing), then the C method will encode
234             the resulting JSON text as latin1 (or iso-8859-1), escaping any characters
235             outside the code range C<0..255>. The resulting string can be treated as a
236             latin1-encoded JSON text or a native Unicode string. The C method
237             will not be affected in any way by this flag, as C by default
238             expects Unicode, which is a strict superset of latin1.
240             If C<$enable> is false, then the C method will not escape Unicode
241             characters unless required by the JSON syntax or other flags.
243             See also the section I later in this
244             document.
246             The main use for this flag is efficiently encoding binary data as JSON
247             text, as most octets will not be escaped, resulting in a smaller encoded
248             size. The disadvantage is that the resulting JSON text is encoded
249             in latin1 (and must correctly be treated as such when storing and
250             transferring), a rare encoding for JSON. It is therefore most useful when
251             you want to store data structures known to contain binary data efficiently
252             in files or databases, not when talking to other JSON encoders/decoders.
254             JSON::XS->new->latin1->encode (["\x{89}\x{abc}"]
255             => ["\x{89}\\u0abc"] # (perl syntax, U+abc escaped, U+89 not)
257             =item $json = $json->utf8 ([$enable])
259             =item $enabled = $json->get_utf8
261             If C<$enable> is true (or missing), then the C method will encode
262             the JSON result into UTF-8, as required by many protocols, while the
263             C method expects to be handed a UTF-8-encoded string. Please
264             note that UTF-8-encoded strings do not contain any characters outside the
265             range C<0..255>, they are thus useful for bytewise/binary I/O. In future
266             versions, enabling this option might enable autodetection of the UTF-16
267             and UTF-32 encoding families, as described in RFC4627.
269             If C<$enable> is false, then the C method will return the JSON
270             string as a (non-encoded) Unicode string, while C expects thus a
271             Unicode string. Any decoding or encoding (e.g. to UTF-8 or UTF-16) needs
272             to be done yourself, e.g. using the Encode module.
274             See also the section I later in this
275             document.
277             Example, output UTF-16BE-encoded JSON:
279             use Encode;
280             $jsontext = encode "UTF-16BE", JSON::XS->new->encode ($object);
282             Example, decode UTF-32LE-encoded JSON:
284             use Encode;
285             $object = JSON::XS->new->decode (decode "UTF-32LE", $jsontext);
287             =item $json = $json->pretty ([$enable])
289             This enables (or disables) all of the C, C and
290             C (and in the future possibly more) flags in one call to
291             generate the most readable (or most compact) form possible.
293             Example, pretty-print some simple structure:
295             my $json = JSON::XS->new->pretty(1)->encode ({a => [1,2]})
296             =>
297             {
298             "a" : [
299             1,
300             2
301             ]
302             }
304             =item $json = $json->indent ([$enable])
306             =item $enabled = $json->get_indent
308             If C<$enable> is true (or missing), then the C method will use a multiline
309             format as output, putting every array member or object/hash key-value pair
310             into its own line, indenting them properly.
312             If C<$enable> is false, no newlines or indenting will be produced, and the
313             resulting JSON text is guaranteed not to contain any C.
315             This setting has no effect when decoding JSON texts.
317             =item $json = $json->space_before ([$enable])
319             =item $enabled = $json->get_space_before
321             If C<$enable> is true (or missing), then the C method will add an extra
322             optional space before the C<:> separating keys from values in JSON objects.
324             If C<$enable> is false, then the C method will not add any extra
325             space at those places.
327             This setting has no effect when decoding JSON texts. You will also
328             most likely combine this setting with C.
330             Example, space_before enabled, space_after and indent disabled:
332             {"key" :"value"}
334             =item $json = $json->space_after ([$enable])
336             =item $enabled = $json->get_space_after
338             If C<$enable> is true (or missing), then the C method will add an extra
339             optional space after the C<:> separating keys from values in JSON objects
340             and extra whitespace after the C<,> separating key-value pairs and array
341             members.
343             If C<$enable> is false, then the C method will not add any extra
344             space at those places.
346             This setting has no effect when decoding JSON texts.
348             Example, space_before and indent disabled, space_after enabled:
350             {"key": "value"}
352             =item $json = $json->relaxed ([$enable])
354             =item $enabled = $json->get_relaxed
356             If C<$enable> is true (or missing), then C will accept some
357             extensions to normal JSON syntax (see below). C will not be
358             affected in any way. I
359             JSON texts as if they were valid!>. I suggest only to use this option to
360             parse application-specific files written by humans (configuration files,
361             resource files etc.)
363             If C<$enable> is false (the default), then C will only accept
364             valid JSON texts.
366             Currently accepted extensions are:
368             =over
370             =item * list items can have an end-comma
372             JSON I array elements and key-value pairs with commas. This
373             can be annoying if you write JSON texts manually and want to be able to
374             quickly append elements, so this extension accepts comma at the end of
375             such items not just between them:
377             [
378             1,
379             2, <- this comma not normally allowed
380             ]
381             {
382             "k1": "v1",
383             "k2": "v2", <- this comma not normally allowed
384             }
386             =item * shell-style '#'-comments
388             Whenever JSON allows whitespace, shell-style comments are additionally
389             allowed. They are terminated by the first carriage-return or line-feed
390             character, after which more white-space and comments are allowed.
392             [
393             1, # this comment not allowed in JSON
394             # neither this one...
395             ]
397             =item * literal ASCII TAB characters in strings
399             Literal ASCII TAB characters are now allowed in strings (and treated as
400             C<\t>).
402             [
403             "Hello\tWorld",
404             "HelloWorld", # literal would not normally be allowed
405             ]
407             =back
409             =item $json = $json->canonical ([$enable])
411             =item $enabled = $json->get_canonical
413             If C<$enable> is true (or missing), then the C method will output JSON objects
414             by sorting their keys. This is adding a comparatively high overhead.
416             If C<$enable> is false, then the C method will output key-value
417             pairs in the order Perl stores them (which will likely change between runs
418             of the same script, and can change even within the same run from 5.18
419             onwards).
421             This option is useful if you want the same data structure to be encoded as
422             the same JSON text (given the same overall settings). If it is disabled,
423             the same hash might be encoded differently even if contains the same data,
424             as key-value pairs have no inherent ordering in Perl.
426             This setting has no effect when decoding JSON texts.
428             This setting has currently no effect on tied hashes.
430             =item $json = $json->allow_nonref ([$enable])
432             =item $enabled = $json->get_allow_nonref
434             Unlike other boolean options, this opotion is enabled by default beginning
435             with version C<4.0>. See L for the gory details.
437             If C<$enable> is true (or missing), then the C method can convert a
438             non-reference into its corresponding string, number or null JSON value,
439             which is an extension to RFC4627. Likewise, C will accept those JSON
440             values instead of croaking.
442             If C<$enable> is false, then the C method will croak if it isn't
443             passed an arrayref or hashref, as JSON texts must either be an object
444             or array. Likewise, C will croak if given something that is not a
445             JSON object or array.
447             Example, encode a Perl scalar as JSON value without enabled C,
448             resulting in an error:
450             JSON::XS->new->allow_nonref (0)->encode ("Hello, World!")
451             => hash- or arrayref expected...
453             =item $json = $json->allow_unknown ([$enable])
455             =item $enabled = $json->get_allow_unknown
457             If C<$enable> is true (or missing), then C will I throw an
458             exception when it encounters values it cannot represent in JSON (for
459             example, filehandles) but instead will encode a JSON C value. Note
460             that blessed objects are not included here and are handled separately by
461             c.
463             If C<$enable> is false (the default), then C will throw an
464             exception when it encounters anything it cannot encode as JSON.
466             This option does not affect C in any way, and it is recommended to
467             leave it off unless you know your communications partner.
469             =item $json = $json->allow_blessed ([$enable])
471             =item $enabled = $json->get_allow_blessed
473             See L for details.
475             If C<$enable> is true (or missing), then the C method will not
476             barf when it encounters a blessed reference that it cannot convert
477             otherwise. Instead, a JSON C value is encoded instead of the object.
479             If C<$enable> is false (the default), then C will throw an
480             exception when it encounters a blessed object that it cannot convert
481             otherwise.
483             This setting has no effect on C.
485             =item $json = $json->convert_blessed ([$enable])
487             =item $enabled = $json->get_convert_blessed
489             See L for details.
491             If C<$enable> is true (or missing), then C, upon encountering a
492             blessed object, will check for the availability of the C method
493             on the object's class. If found, it will be called in scalar context and
494             the resulting scalar will be encoded instead of the object.
496             The C method may safely call die if it wants. If C
497             returns other blessed objects, those will be handled in the same
498             way. C must take care of not causing an endless recursion cycle
499             (== crash) in this case. The name of C was chosen because other
500             methods called by the Perl core (== not by the user of the object) are
501             usually in upper case letters and to avoid collisions with any C
502             function or method.
504             If C<$enable> is false (the default), then C will not consider
505             this type of conversion.
507             This setting has no effect on C.
509             =item $json = $json->allow_tags ([$enable])
511             =item $enabled = $json->get_allow_tags
513             See L for details.
515             If C<$enable> is true (or missing), then C, upon encountering a
516             blessed object, will check for the availability of the C method on
517             the object's class. If found, it will be used to serialise the object into
518             a nonstandard tagged JSON value (that JSON decoders cannot decode).
520             It also causes C to parse such tagged JSON values and deserialise
521             them via a call to the C method.
523             If C<$enable> is false (the default), then C will not consider
524             this type of conversion, and tagged JSON values will cause a parse error
525             in C, as if tags were not part of the grammar.
527             =item $json->boolean_values ([$false, $true])
529             =item ($false, $true) = $json->get_boolean_values
531             By default, JSON booleans will be decoded as overloaded
532             C<$Types::Serialiser::false> and C<$Types::Serialiser::true> objects.
534             With this method you can specify your own boolean values for decoding -
535             on decode, JSON C will be decoded as a copy of C<$false>, and JSON
536             C will be decoded as C<$true> ("copy" here is the same thing as
537             assigning a value to another variable, i.e. C<$copy = $false>).
539             Calling this method without any arguments will reset the booleans
540             to their default values.
542             C will return both C<$false> and C<$true> values, or
543             the empty list when they are set to the default.
545             =item $json = $json->filter_json_object ([$coderef->($hashref)])
547             When C<$coderef> is specified, it will be called from C each
548             time it decodes a JSON object. The only argument is a reference to
549             the newly-created hash. If the code reference returns a single scalar
550             (which need not be a reference), this value (or rather a copy of it) is
551             inserted into the deserialised data structure. If it returns an empty
552             list (NOTE: I C, which is a valid scalar), the original
553             deserialised hash will be inserted. This setting can slow down decoding
554             considerably.
556             When C<$coderef> is omitted or undefined, any existing callback will
557             be removed and C will not change the deserialised hash in any
558             way.
560             Example, convert all JSON objects into the integer 5:
562             my $js = JSON::XS->new->filter_json_object (sub { 5 });
563             # returns [5]
564             $js->decode ('[{}]')
565             # throw an exception because allow_nonref is not enabled
566             # so a lone 5 is not allowed.
567             $js->decode ('{"a":1, "b":2}');
569             =item $json = $json->filter_json_single_key_object ($key [=> $coderef->($value)])
571             Works remotely similar to C, but is only called for
572             JSON objects having a single key named C<$key>.
574             This C<$coderef> is called before the one specified via
575             C, if any. It gets passed the single value in the JSON
576             object. If it returns a single value, it will be inserted into the data
577             structure. If it returns nothing (not even C but the empty list),
578             the callback from C will be called next, as if no
579             single-key callback were specified.
581             If C<$coderef> is omitted or undefined, the corresponding callback will be
582             disabled. There can only ever be one callback for a given key.
584             As this callback gets called less often then the C
585             one, decoding speed will not usually suffer as much. Therefore, single-key
586             objects make excellent targets to serialise Perl objects into, especially
587             as single-key JSON objects are as close to the type-tagged value concept
588             as JSON gets (it's basically an ID/VALUE tuple). Of course, JSON does not
589             support this in any way, so you need to make sure your data never looks
590             like a serialised Perl hash.
592             Typical names for the single object key are C<__class_whatever__>, or
593             C<$__dollars_are_rarely_used__$> or C<}ugly_brace_placement>, or even
594             things like C<__class_md5sum(classname)__>, to reduce the risk of clashing
595             with real hashes.
597             Example, decode JSON objects of the form C<< { "__widget__" => } >>
598             into the corresponding C<< $WIDGET{} >> object:
600             # return whatever is in $WIDGET{5}:
601             JSON::XS
602             ->new
603             ->filter_json_single_key_object (__widget__ => sub {
604             $WIDGET{ $_[0] }
605             })
606             ->decode ('{"__widget__": 5')
608             # this can be used with a TO_JSON method in some "widget" class
609             # for serialisation to json:
610             sub WidgetBase::TO_JSON {
611             my ($self) = @_;
613             unless ($self->{id}) {
614             $self->{id} =;
615             $WIDGET{$self->{id}} = $self;
616             }
618             { __widget__ => $self->{id} }
619             }
621             =item $json = $json->shrink ([$enable])
623             =item $enabled = $json->get_shrink
625             Perl usually over-allocates memory a bit when allocating space for
626             strings. This flag optionally resizes strings generated by either
627             C or C to their minimum size possible. This can save
628             memory when your JSON texts are either very very long or you have many
629             short strings. It will also try to downgrade any strings to octet-form
630             if possible: perl stores strings internally either in an encoding called
631             UTF-X or in octet-form. The latter cannot store everything but uses less
632             space in general (and some buggy Perl or C code might even rely on that
633             internal representation being used).
635             The actual definition of what shrink does might change in future versions,
636             but it will always try to save space at the expense of time.
638             If C<$enable> is true (or missing), the string returned by C will
639             be shrunk-to-fit, while all strings generated by C will also be
640             shrunk-to-fit.
642             If C<$enable> is false, then the normal perl allocation algorithms are used.
643             If you work with your data, then this is likely to be faster.
645             In the future, this setting might control other things, such as converting
646             strings that look like integers or floats into integers or floats
647             internally (there is no difference on the Perl level), saving space.
649             =item $json = $json->max_depth ([$maximum_nesting_depth])
651             =item $max_depth = $json->get_max_depth
653             Sets the maximum nesting level (default C<512>) accepted while encoding
654             or decoding. If a higher nesting level is detected in JSON text or a Perl
655             data structure, then the encoder and decoder will stop and croak at that
656             point.
658             Nesting level is defined by number of hash- or arrayrefs that the encoder
659             needs to traverse to reach a given point or the number of C<{> or C<[>
660             characters without their matching closing parenthesis crossed to reach a
661             given character in a string.
663             Setting the maximum depth to one disallows any nesting, so that ensures
664             that the object is only a single hash/object or array.
666             If no argument is given, the highest possible setting will be used, which
667             is rarely useful.
669             Note that nesting is implemented by recursion in C. The default value has
670             been chosen to be as large as typical operating systems allow without
671             crashing.
673             See SECURITY CONSIDERATIONS, below, for more info on why this is useful.
675             =item $json = $json->max_size ([$maximum_string_size])
677             =item $max_size = $json->get_max_size
679             Set the maximum length a JSON text may have (in bytes) where decoding is
680             being attempted. The default is C<0>, meaning no limit. When C
681             is called on a string that is longer then this many bytes, it will not
682             attempt to decode the string but throw an exception. This setting has no
683             effect on C (yet).
685             If no argument is given, the limit check will be deactivated (same as when
686             C<0> is specified).
688             See SECURITY CONSIDERATIONS, below, for more info on why this is useful.
690             =item $json_text = $json->encode ($perl_scalar)
692             Converts the given Perl value or data structure to its JSON
693             representation. Croaks on error.
695             =item $perl_scalar = $json->decode ($json_text)
697             The opposite of C: expects a JSON text and tries to parse it,
698             returning the resulting simple scalar or reference. Croaks on error.
700             =item ($perl_scalar, $characters) = $json->decode_prefix ($json_text)
702             This works like the C method, but instead of raising an exception
703             when there is trailing garbage after the first JSON object, it will
704             silently stop parsing there and return the number of characters consumed
705             so far.
707             This is useful if your JSON texts are not delimited by an outer protocol
708             and you need to know where the JSON text ends.
710             JSON::XS->new->decode_prefix ("[1] the tail")
711             => ([1], 3)
713             =back
716             =head1 INCREMENTAL PARSING
718             In some cases, there is the need for incremental parsing of JSON
719             texts. While this module always has to keep both JSON text and resulting
720             Perl data structure in memory at one time, it does allow you to parse a
721             JSON stream incrementally. It does so by accumulating text until it has
722             a full JSON object, which it then can decode. This process is similar to
723             using C to see if a full JSON object is available, but
724             is much more efficient (and can be implemented with a minimum of method
725             calls).
727             JSON::XS will only attempt to parse the JSON text once it is sure it
728             has enough text to get a decisive result, using a very simple but
729             truly incremental parser. This means that it sometimes won't stop as
730             early as the full parser, for example, it doesn't detect mismatched
731             parentheses. The only thing it guarantees is that it starts decoding as
732             soon as a syntactically valid JSON text has been seen. This means you need
733             to set resource limits (e.g. C) to ensure the parser will stop
734             parsing in the presence if syntax errors.
736             The following methods implement this incremental parser.
738             =over
740             =item [void, scalar or list context] = $json->incr_parse ([$string])
742             This is the central parsing function. It can both append new text and
743             extract objects from the stream accumulated so far (both of these
744             functions are optional).
746             If C<$string> is given, then this string is appended to the already
747             existing JSON fragment stored in the C<$json> object.
749             After that, if the function is called in void context, it will simply
750             return without doing anything further. This can be used to add more text
751             in as many chunks as you want.
753             If the method is called in scalar context, then it will try to extract
754             exactly I JSON object. If that is successful, it will return this
755             object, otherwise it will return C. If there is a parse error,
756             this method will croak just as C would do (one can then use
757             C to skip the erroneous part). This is the most common way of
758             using the method.
760             And finally, in list context, it will try to extract as many objects
761             from the stream as it can find and return them, or the empty list
762             otherwise. For this to work, there must be no separators (other than
763             whitespace) between the JSON objects or arrays, instead they must be
764             concatenated back-to-back. If an error occurs, an exception will be
765             raised as in the scalar context case. Note that in this case, any
766             previously-parsed JSON texts will be lost.
768             Example: Parse some JSON arrays/objects in a given string and return
769             them.
771             my @objs = JSON::XS->new->incr_parse ("[5][7][1,2]");
773             =item $lvalue_string = $json->incr_text
775             This method returns the currently stored JSON fragment as an lvalue, that
776             is, you can manipulate it. This I works when a preceding call to
777             C in I successfully returned an object. Under
778             all other circumstances you must not call this function (I mean it.
779             although in simple tests it might actually work, it I fail under
780             real world conditions). As a special exception, you can also call this
781             method before having parsed anything.
783             That means you can only use this function to look at or manipulate text
784             before or after complete JSON objects, not while the parser is in the
785             middle of parsing a JSON object.
787             This function is useful in two cases: a) finding the trailing text after a
788             JSON object or b) parsing multiple JSON objects separated by non-JSON text
789             (such as commas).
791             =item $json->incr_skip
793             This will reset the state of the incremental parser and will remove
794             the parsed text from the input buffer so far. This is useful after
795             C died, in which case the input buffer and incremental parser
796             state is left unchanged, to skip the text parsed so far and to reset the
797             parse state.
799             The difference to C is that only text until the parse error
800             occurred is removed.
802             =item $json->incr_reset
804             This completely resets the incremental parser, that is, after this call,
805             it will be as if the parser had never parsed anything.
807             This is useful if you want to repeatedly parse JSON objects and want to
808             ignore any trailing data, which means you have to reset the parser after
809             each successful decode.
811             =back
813             =head2 LIMITATIONS
815             The incremental parser is a non-exact parser: it works by gathering as
816             much text as possible that I be a valid JSON text, followed by
817             trying to decode it.
819             That means it sometimes needs to read more data than strictly necessary to
820             diagnose an invalid JSON text. For example, after parsing the following
821             fragment, the parser I stop with an error, as this fragment
822             I be the beginning of a valid JSON text:
824             [,
826             In reality, hopwever, the parser might continue to read data until a
827             length limit is exceeded or it finds a closing bracket.
829             =head2 EXAMPLES
831             Some examples will make all this clearer. First, a simple example that
832             works similarly to C: We want to decode the JSON object at
833             the start of a string and identify the portion after the JSON object:
835             my $text = "[1,2,3] hello";
837             my $json = new JSON::XS;
839             my $obj = $json->incr_parse ($text)
840             or die "expected JSON object or array at beginning of string";
842             my $tail = $json->incr_text;
843             # $tail now contains " hello"
845             Easy, isn't it?
847             Now for a more complicated example: Imagine a hypothetical protocol where
848             you read some requests from a TCP stream, and each request is a JSON
849             array, without any separation between them (in fact, it is often useful to
850             use newlines as "separators", as these get interpreted as whitespace at
851             the start of the JSON text, which makes it possible to test said protocol
852             with C...).
854             Here is how you'd do it (it is trivial to write this in an event-based
855             manner):
857             my $json = new JSON::XS;
859             # read some data from the socket
860             while (sysread $socket, my $buf, 4096) {
862             # split and decode as many requests as possible
863             for my $request ($json->incr_parse ($buf)) {
864             # act on the $request
865             }
866             }
868             Another complicated example: Assume you have a string with JSON objects
869             or arrays, all separated by (optional) comma characters (e.g. C<[1],[2],
870             [3]>). To parse them, we have to skip the commas between the JSON texts,
871             and here is where the lvalue-ness of C comes in useful:
873             my $text = "[1],[2], [3]";
874             my $json = new JSON::XS;
876             # void context, so no parsing done
877             $json->incr_parse ($text);
879             # now extract as many objects as possible. note the
880             # use of scalar context so incr_text can be called.
881             while (my $obj = $json->incr_parse) {
882             # do something with $obj
884             # now skip the optional comma
885             $json->incr_text =~ s/^ \s* , //x;
886             }
888             Now lets go for a very complex example: Assume that you have a gigantic
889             JSON array-of-objects, many gigabytes in size, and you want to parse it,
890             but you cannot load it into memory fully (this has actually happened in
891             the real world :).
893             Well, you lost, you have to implement your own JSON parser. But JSON::XS
894             can still help you: You implement a (very simple) array parser and let
895             JSON decode the array elements, which are all full JSON objects on their
896             own (this wouldn't work if the array elements could be JSON numbers, for
897             example):
899             my $json = new JSON::XS;
901             # open the monster
902             open my $fh, "
903             or die "bigfile: $!";
905             # first parse the initial "["
906             for (;;) {
907             sysread $fh, my $buf, 65536
908             or die "read error: $!";
909             $json->incr_parse ($buf); # void context, so no parsing
911             # Exit the loop once we found and removed(!) the initial "[".
912             # In essence, we are (ab-)using the $json object as a simple scalar
913             # we append data to.
914             last if $json->incr_text =~ s/^ \s* \[ //x;
915             }
917             # now we have the skipped the initial "[", so continue
918             # parsing all the elements.
919             for (;;) {
920             # in this loop we read data until we got a single JSON object
921             for (;;) {
922             if (my $obj = $json->incr_parse) {
923             # do something with $obj
924             last;
925             }
927             # add more data
928             sysread $fh, my $buf, 65536
929             or die "read error: $!";
930             $json->incr_parse ($buf); # void context, so no parsing
931             }
933             # in this loop we read data until we either found and parsed the
934             # separating "," between elements, or the final "]"
935             for (;;) {
936             # first skip whitespace
937             $json->incr_text =~ s/^\s*//;
939             # if we find "]", we are done
940             if ($json->incr_text =~ s/^\]//) {
941             print "finished.\n";
942             exit;
943             }
945             # if we find ",", we can continue with the next element
946             if ($json->incr_text =~ s/^,//) {
947             last;
948             }
950             # if we find anything else, we have a parse error!
951             if (length $json->incr_text) {
952             die "parse error near ", $json->incr_text;
953             }
955             # else add more data
956             sysread $fh, my $buf, 65536
957             or die "read error: $!";
958             $json->incr_parse ($buf); # void context, so no parsing
959             }
961             This is a complex example, but most of the complexity comes from the fact
962             that we are trying to be correct (bear with me if I am wrong, I never ran
963             the above example :).
967             =head1 MAPPING
969             This section describes how JSON::XS maps Perl values to JSON values and
970             vice versa. These mappings are designed to "do the right thing" in most
971             circumstances automatically, preserving round-tripping characteristics
972             (what you put in comes out as something equivalent).
974             For the more enlightened: note that in the following descriptions,
975             lowercase I refers to the Perl interpreter, while uppercase I
976             refers to the abstract Perl language itself.
979             =head2 JSON -> PERL
981             =over
983             =item object
985             A JSON object becomes a reference to a hash in Perl. No ordering of object
986             keys is preserved (JSON does not preserve object key ordering itself).
988             =item array
990             A JSON array becomes a reference to an array in Perl.
992             =item string
994             A JSON string becomes a string scalar in Perl - Unicode codepoints in JSON
995             are represented by the same codepoints in the Perl string, so no manual
996             decoding is necessary.
998             =item number
1000             A JSON number becomes either an integer, numeric (floating point) or
1001             string scalar in perl, depending on its range and any fractional parts. On
1002             the Perl level, there is no difference between those as Perl handles all
1003             the conversion details, but an integer may take slightly less memory and
1004             might represent more values exactly than floating point numbers.
1006             If the number consists of digits only, JSON::XS will try to represent
1007             it as an integer value. If that fails, it will try to represent it as
1008             a numeric (floating point) value if that is possible without loss of
1009             precision. Otherwise it will preserve the number as a string value (in
1010             which case you lose roundtripping ability, as the JSON number will be
1011             re-encoded to a JSON string).
1013             Numbers containing a fractional or exponential part will always be
1014             represented as numeric (floating point) values, possibly at a loss of
1015             precision (in which case you might lose perfect roundtripping ability, but
1016             the JSON number will still be re-encoded as a JSON number).
1018             Note that precision is not accuracy - binary floating point values cannot
1019             represent most decimal fractions exactly, and when converting from and to
1020             floating point, JSON::XS only guarantees precision up to but not including
1021             the least significant bit.
1023             =item true, false
1025             These JSON atoms become C and
1026             C, respectively. They are overloaded to act
1027             almost exactly like the numbers C<1> and C<0>. You can check whether
1028             a scalar is a JSON boolean by using the C
1029             function (after C, of course).
1031             =item null
1033             A JSON null atom becomes C in Perl.
1035             =item shell-style comments (C<< # I >>)
1037             As a nonstandard extension to the JSON syntax that is enabled by the
1038             C setting, shell-style comments are allowed. They can start
1039             anywhere outside strings and go till the end of the line.
1041             =item tagged values (C<< (I)I >>).
1043             Another nonstandard extension to the JSON syntax, enabled with the
1044             C setting, are tagged values. In this implementation, the
1045             I must be a perl package/class name encoded as a JSON string, and the
1046             I must be a JSON array encoding optional constructor arguments.
1048             See L, below, for details.
1050             =back
1053             =head2 PERL -> JSON
1055             The mapping from Perl to JSON is slightly more difficult, as Perl is a
1056             truly typeless language, so we can only guess which JSON type is meant by
1057             a Perl value.
1059             =over
1061             =item hash references
1063             Perl hash references become JSON objects. As there is no inherent
1064             ordering in hash keys (or JSON objects), they will usually be encoded
1065             in a pseudo-random order. JSON::XS can optionally sort the hash keys
1066             (determined by the I flag), so the same datastructure will
1067             serialise to the same JSON text (given same settings and version of
1068             JSON::XS), but this incurs a runtime overhead and is only rarely useful,
1069             e.g. when you want to compare some JSON text against another for equality.
1071             =item array references
1073             Perl array references become JSON arrays.
1075             =item other references
1077             Other unblessed references are generally not allowed and will cause an
1078             exception to be thrown, except for references to the integers C<0> and
1079             C<1>, which get turned into C and C atoms in JSON.
1081             Since C uses the boolean model from L, you
1082             can also C and then use C
1083             and C to improve readability.
1085             use Types::Serialiser;
1086             encode_json [\0, Types::Serialiser::true] # yields [false,true]
1088             =item Types::Serialiser::true, Types::Serialiser::false
1090             These special values from the L module become JSON true
1091             and JSON false values, respectively. You can also use C<\1> and C<\0>
1092             directly if you want.
1094             =item blessed objects
1096             Blessed objects are not directly representable in JSON, but C
1097             allows various ways of handling objects. See L,
1098             below, for details.
1100             =item simple scalars
1102             Simple Perl scalars (any scalar that is not a reference) are the most
1103             difficult objects to encode: JSON::XS will encode undefined scalars as
1104             JSON C values, scalars that have last been used in a string context
1105             before encoding as JSON strings, and anything else as number value:
1107             # dump as number
1108             encode_json [2] # yields [2]
1109             encode_json [-3.0e17] # yields [-3e+17]
1110             my $value = 5; encode_json [$value] # yields [5]
1112             # used as string, so dump as string
1113             print $value;
1114             encode_json [$value] # yields ["5"]
1116             # undef becomes null
1117             encode_json [undef] # yields [null]
1119             You can force the type to be a JSON string by stringifying it:
1121             my $x = 3.1; # some variable containing a number
1122             "$x"; # stringified
1123             $x .= ""; # another, more awkward way to stringify
1124             print $x; # perl does it for you, too, quite often
1126             You can force the type to be a JSON number by numifying it:
1128             my $x = "3"; # some variable containing a string
1129             $x += 0; # numify it, ensuring it will be dumped as a number
1130             $x *= 1; # same thing, the choice is yours.
1132             You can not currently force the type in other, less obscure, ways. Tell me
1133             if you need this capability (but don't forget to explain why it's needed
1134             :).
1136             Note that numerical precision has the same meaning as under Perl (so
1137             binary to decimal conversion follows the same rules as in Perl, which
1138             can differ to other languages). Also, your perl interpreter might expose
1139             extensions to the floating point numbers of your platform, such as
1140             infinities or NaN's - these cannot be represented in JSON, and it is an
1141             error to pass those in.
1143             =back
1145             =head2 OBJECT SERIALISATION
1147             As JSON cannot directly represent Perl objects, you have to choose between
1148             a pure JSON representation (without the ability to deserialise the object
1149             automatically again), and a nonstandard extension to the JSON syntax,
1150             tagged values.
1152             =head3 SERIALISATION
1154             What happens when C encounters a Perl object depends on the
1155             C, C and C settings, which are
1156             used in this order:
1158             =over
1160             =item 1. C is enabled and the object has a C method.
1162             In this case, C uses the L object
1163             serialisation protocol to create a tagged JSON value, using a nonstandard
1164             extension to the JSON syntax.
1166             This works by invoking the C method on the object, with the first
1167             argument being the object to serialise, and the second argument being the
1168             constant string C to distinguish it from other serialisers.
1170             The C method can return any number of values (i.e. zero or
1171             more). These values and the paclkage/classname of the object will then be
1172             encoded as a tagged JSON value in the following format:
1174             ("classname")[FREEZE return values...]
1176             e.g.:
1178             ("URI")[""]
1179             ("MyDate")[2013,10,29]
1180             ("ImageData::JPEG")["Z3...VlCg=="]
1182             For example, the hypothetical C C method might use the
1183             objects C and C members to encode the object:
1185             sub My::Object::FREEZE {
1186             my ($self, $serialiser) = @_;
1188             ($self->{type}, $self->{id})
1189             }
1191             =item 2. C is enabled and the object has a C method.
1193             In this case, the C method of the object is invoked in scalar
1194             context. It must return a single scalar that can be directly encoded into
1195             JSON. This scalar replaces the object in the JSON text.
1197             For example, the following C method will convert all L
1198             objects to JSON strings when serialised. The fatc that these values
1199             originally were L objects is lost.
1201             sub URI::TO_JSON {
1202             my ($uri) = @_;
1203             $uri->as_string
1204             }
1206             =item 3. C is enabled.
1208             The object will be serialised as a JSON null value.
1210             =item 4. none of the above
1212             If none of the settings are enabled or the respective methods are missing,
1213             C throws an exception.
1215             =back
1217             =head3 DESERIALISATION
1219             For deserialisation there are only two cases to consider: either
1220             nonstandard tagging was used, in which case C decides,
1221             or objects cannot be automatically be deserialised, in which
1222             case you can use postprocessing or the C or
1223             C callbacks to get some real objects our of
1224             your JSON.
1226             This section only considers the tagged value case: I a tagged JSON object
1227             is encountered during decoding and C is disabled, a parse
1228             error will result (as if tagged values were not part of the grammar).
1230             If C is enabled, C will look up the C method
1231             of the package/classname used during serialisation (it will not attempt
1232             to load the package as a Perl module). If there is no such method, the
1233             decoding will fail with an error.
1235             Otherwise, the C method is invoked with the classname as first
1236             argument, the constant string C as second argument, and all the
1237             values from the JSON array (the values originally returned by the
1238             C method) as remaining arguments.
1240             The method must then return the object. While technically you can return
1241             any Perl scalar, you might have to enable the C setting to
1242             make that work in all cases, so better return an actual blessed reference.
1244             As an example, let's implement a C function that regenerates the
1245             C from the C example earlier:
1247             sub My::Object::THAW {
1248             my ($class, $serialiser, $type, $id) = @_;
1250             $class->new (type => $type, id => $id)
1251             }
1254             =head1 ENCODING/CODESET FLAG NOTES
1256             The interested reader might have seen a number of flags that signify
1257             encodings or codesets - C, C and C. There seems to be
1258             some confusion on what these do, so here is a short comparison:
1260             C controls whether the JSON text created by C (and expected
1261             by C) is UTF-8 encoded or not, while C and C only
1262             control whether C escapes character values outside their respective
1263             codeset range. Neither of these flags conflict with each other, although
1264             some combinations make less sense than others.
1266             Care has been taken to make all flags symmetrical with respect to
1267             C and C, that is, texts encoded with any combination of
1268             these flag values will be correctly decoded when the same flags are used
1269             - in general, if you use different flag settings while encoding vs. when
1270             decoding you likely have a bug somewhere.
1272             Below comes a verbose discussion of these flags. Note that a "codeset" is
1273             simply an abstract set of character-codepoint pairs, while an encoding
1274             takes those codepoint numbers and I them, in our case into
1275             octets. Unicode is (among other things) a codeset, UTF-8 is an encoding,
1276             and ISO-8859-1 (= latin 1) and ASCII are both codesets I encodings at
1277             the same time, which can be confusing.
1279             =over
1281             =item C flag disabled
1283             When C is disabled (the default), then C/C generate
1284             and expect Unicode strings, that is, characters with high ordinal Unicode
1285             values (> 255) will be encoded as such characters, and likewise such
1286             characters are decoded as-is, no changes to them will be done, except
1287             "(re-)interpreting" them as Unicode codepoints or Unicode characters,
1288             respectively (to Perl, these are the same thing in strings unless you do
1289             funny/weird/dumb stuff).
1291             This is useful when you want to do the encoding yourself (e.g. when you
1292             want to have UTF-16 encoded JSON texts) or when some other layer does
1293             the encoding for you (for example, when printing to a terminal using a
1294             filehandle that transparently encodes to UTF-8 you certainly do NOT want
1295             to UTF-8 encode your data first and have Perl encode it another time).
1297             =item C flag enabled
1299             If the C-flag is enabled, C/C will encode all
1300             characters using the corresponding UTF-8 multi-byte sequence, and will
1301             expect your input strings to be encoded as UTF-8, that is, no "character"
1302             of the input string must have any value > 255, as UTF-8 does not allow
1303             that.
1305             The C flag therefore switches between two modes: disabled means you
1306             will get a Unicode string in Perl, enabled means you get a UTF-8 encoded
1307             octet/binary string in Perl.
1309             =item C or C flags enabled
1311             With C (or C) enabled, C will escape characters
1312             with ordinal values > 255 (> 127 with C) and encode the remaining
1313             characters as specified by the C flag.
1315             If C is disabled, then the result is also correctly encoded in those
1316             character sets (as both are proper subsets of Unicode, meaning that a
1317             Unicode string with all character values < 256 is the same thing as a
1318             ISO-8859-1 string, and a Unicode string with all character values < 128 is
1319             the same thing as an ASCII string in Perl).
1321             If C is enabled, you still get a correct UTF-8-encoded string,
1322             regardless of these flags, just some more characters will be escaped using
1323             C<\uXXXX> then before.
1325             Note that ISO-8859-1-I strings are not compatible with UTF-8
1326             encoding, while ASCII-encoded strings are. That is because the ISO-8859-1
1327             encoding is NOT a subset of UTF-8 (despite the ISO-8859-1 I being
1328             a subset of Unicode), while ASCII is.
1330             Surprisingly, C will ignore these flags and so treat all input
1331             values as governed by the C flag. If it is disabled, this allows you
1332             to decode ISO-8859-1- and ASCII-encoded strings, as both strict subsets of
1333             Unicode. If it is enabled, you can correctly decode UTF-8 encoded strings.
1335             So neither C nor C are incompatible with the C flag -
1336             they only govern when the JSON output engine escapes a character or not.
1338             The main use for C is to relatively efficiently store binary data
1339             as JSON, at the expense of breaking compatibility with most JSON decoders.
1341             The main use for C is to force the output to not contain characters
1342             with values > 127, which means you can interpret the resulting string
1343             as UTF-8, ISO-8859-1, ASCII, KOI8-R or most about any character set and
1344             8-bit-encoding, and still get the same data structure back. This is useful
1345             when your channel for JSON transfer is not 8-bit clean or the encoding
1346             might be mangled in between (e.g. in mail), and works because ASCII is a
1347             proper subset of most 8-bit and multibyte encodings in use in the world.
1349             =back
1352             =head2 JSON and ECMAscript
1354             JSON syntax is based on how literals are represented in javascript (the
1355             not-standardised predecessor of ECMAscript) which is presumably why it is
1356             called "JavaScript Object Notation".
1358             However, JSON is not a subset (and also not a superset of course) of
1359             ECMAscript (the standard) or javascript (whatever browsers actually
1360             implement).
1362             If you want to use javascript's C function to "parse" JSON, you
1363             might run into parse errors for valid JSON texts, or the resulting data
1364             structure might not be queryable:
1366             One of the problems is that U+2028 and U+2029 are valid characters inside
1367             JSON strings, but are not allowed in ECMAscript string literals, so the
1368             following Perl fragment will not output something that can be guaranteed
1369             to be parsable by javascript's C:
1371             use JSON::XS;
1373             print encode_json [chr 0x2028];
1375             The right fix for this is to use a proper JSON parser in your javascript
1376             programs, and not rely on C (see for example Douglas Crockford's
1377             F parser).
1379             If this is not an option, you can, as a stop-gap measure, simply encode to
1380             ASCII-only JSON:
1382             use JSON::XS;
1384             print JSON::XS->new->ascii->encode ([chr 0x2028]);
1386             Note that this will enlarge the resulting JSON text quite a bit if you
1387             have many non-ASCII characters. You might be tempted to run some regexes
1388             to only escape U+2028 and U+2029, e.g.:
1390             # DO NOT USE THIS!
1391             my $json = JSON::XS->new->utf8->encode ([chr 0x2028]);
1392             $json =~ s/\xe2\x80\xa8/\\u2028/g; # escape U+2028
1393             $json =~ s/\xe2\x80\xa9/\\u2029/g; # escape U+2029
1394             print $json;
1396             Note that I: the above only works for U+2028 and
1397             U+2029 and thus only for fully ECMAscript-compliant parsers. Many existing
1398             javascript implementations, however, have issues with other characters as
1399             well - using C naively simply I cause problems.
1401             Another problem is that some javascript implementations reserve
1402             some property names for their own purposes (which probably makes
1403             them non-ECMAscript-compliant). For example, Iceweasel reserves the
1404             C<__proto__> property name for its own purposes.
1406             If that is a problem, you could parse try to filter the resulting JSON
1407             output for these property strings, e.g.:
1409             $json =~ s/"__proto__"\s*:/"__proto__renamed":/g;
1411             This works because C<__proto__> is not valid outside of strings, so every
1412             occurrence of C<"__proto__"\s*:> must be a string used as property name.
1414             If you know of other incompatibilities, please let me know.
1417             =head2 JSON and YAML
1419             You often hear that JSON is a subset of YAML. This is, however, a mass
1420             hysteria(*) and very far from the truth (as of the time of this writing),
1421             so let me state it clearly: I
1422             JSON::XS to output a data structure as valid YAML> that works in all
1423             cases.
1425             If you really must use JSON::XS to generate YAML, you should use this
1426             algorithm (subject to change in future versions):
1428             my $to_yaml = JSON::XS->new->utf8->space_after (1);
1429             my $yaml = $to_yaml->encode ($ref) . "\n";
1431             This will I generate JSON texts that also parse as valid
1432             YAML. Please note that YAML has hardcoded limits on (simple) object key
1433             lengths that JSON doesn't have and also has different and incompatible
1434             unicode character escape syntax, so you should make sure that your hash
1435             keys are noticeably shorter than the 1024 "stream characters" YAML allows
1436             and that you do not have characters with codepoint values outside the
1437             Unicode BMP (basic multilingual page). YAML also does not allow C<\/>
1438             sequences in strings (which JSON::XS does not I generate, but
1439             other JSON generators might).
1441             There might be other incompatibilities that I am not aware of (or the YAML
1442             specification has been changed yet again - it does so quite often). In
1443             general you should not try to generate YAML with a JSON generator or vice
1444             versa, or try to parse JSON with a YAML parser or vice versa: chances are
1445             high that you will run into severe interoperability problems when you
1446             least expect it.
1448             =over
1450             =item (*)
1452             I have been pressured multiple times by Brian Ingerson (one of the
1453             authors of the YAML specification) to remove this paragraph, despite him
1454             acknowledging that the actual incompatibilities exist. As I was personally
1455             bitten by this "JSON is YAML" lie, I refused and said I will continue to
1456             educate people about these issues, so others do not run into the same
1457             problem again and again. After this, Brian called me a (quote)I
1458             and worthless idiot>(unquote).
1460             In my opinion, instead of pressuring and insulting people who actually
1461             clarify issues with YAML and the wrong statements of some of its
1462             proponents, I would kindly suggest reading the JSON spec (which is not
1463             that difficult or long) and finally make YAML compatible to it, and
1464             educating users about the changes, instead of spreading lies about the
1465             real compatibility for many I and trying to silence people who
1466             point out that it isn't true.
1468             Addendum/2009: the YAML 1.2 spec is still incompatible with JSON, even
1469             though the incompatibilities have been documented (and are known to Brian)
1470             for many years and the spec makes explicit claims that YAML is a superset
1471             of JSON. It would be so easy to fix, but apparently, bullying people and
1472             corrupting userdata is so much easier.
1474             =back
1477             =head2 SPEED
1479             It seems that JSON::XS is surprisingly fast, as shown in the following
1480             tables. They have been generated with the help of the C program
1481             in the JSON::XS distribution, to make it easy to compare on your own
1482             system.
1484             First comes a comparison between various modules using
1485             a very short single-line JSON string (also available at
1486             L).
1488             {"method": "handleMessage", "params": ["user1",
1489             "we were just talking"], "id": null, "array":[1,11,234,-5,1e5,1e7,
1490             1, 0]}
1492             It shows the number of encodes/decodes per second (JSON::XS uses
1493             the functional interface, while JSON::XS/2 uses the OO interface
1494             with pretty-printing and hashkey sorting enabled, JSON::XS/3 enables
1495             shrink. JSON::DWIW/DS uses the deserialise function, while JSON::DWIW::FJ
1496             uses the from_json method). Higher is better:
1498             module | encode | decode |
1499             --------------|------------|------------|
1500             JSON::DWIW/DS | 86302.551 | 102300.098 |
1501             JSON::DWIW/FJ | 86302.551 | 75983.768 |
1502             JSON::PP | 15827.562 | 6638.658 |
1503             JSON::Syck | 63358.066 | 47662.545 |
1504             JSON::XS | 511500.488 | 511500.488 |
1505             JSON::XS/2 | 291271.111 | 388361.481 |
1506             JSON::XS/3 | 361577.931 | 361577.931 |
1507             Storable | 66788.280 | 265462.278 |
1508             --------------+------------+------------+
1510             That is, JSON::XS is almost six times faster than JSON::DWIW on encoding,
1511             about five times faster on decoding, and over thirty to seventy times
1512             faster than JSON's pure perl implementation. It also compares favourably
1513             to Storable for small amounts of data.
1515             Using a longer test string (roughly 18KB, generated from Yahoo! Locals
1516             search API (L).
1518             module | encode | decode |
1519             --------------|------------|------------|
1520             JSON::DWIW/DS | 1647.927 | 2673.916 |
1521             JSON::DWIW/FJ | 1630.249 | 2596.128 |
1522             JSON::PP | 400.640 | 62.311 |
1523             JSON::Syck | 1481.040 | 1524.869 |
1524             JSON::XS | 20661.596 | 9541.183 |
1525             JSON::XS/2 | 10683.403 | 9416.938 |
1526             JSON::XS/3 | 20661.596 | 9400.054 |
1527             Storable | 19765.806 | 10000.725 |
1528             --------------+------------+------------+
1530             Again, JSON::XS leads by far (except for Storable which non-surprisingly
1531             decodes a bit faster).
1533             On large strings containing lots of high Unicode characters, some modules
1534             (such as JSON::PC) seem to decode faster than JSON::XS, but the result
1535             will be broken due to missing (or wrong) Unicode handling. Others refuse
1536             to decode or encode properly, so it was impossible to prepare a fair
1537             comparison table for that case.
1540             =head1 SECURITY CONSIDERATIONS
1542             When you are using JSON in a protocol, talking to untrusted potentially
1543             hostile creatures requires relatively few measures.
1545             First of all, your JSON decoder should be secure, that is, should not have
1546             any buffer overflows. Obviously, this module should ensure that and I am
1547             trying hard on making that true, but you never know.
1549             Second, you need to avoid resource-starving attacks. That means you should
1550             limit the size of JSON texts you accept, or make sure then when your
1551             resources run out, that's just fine (e.g. by using a separate process that
1552             can crash safely). The size of a JSON text in octets or characters is
1553             usually a good indication of the size of the resources required to decode
1554             it into a Perl structure. While JSON::XS can check the size of the JSON
1555             text, it might be too late when you already have it in memory, so you
1556             might want to check the size before you accept the string.
1558             Third, JSON::XS recurses using the C stack when decoding objects and
1559             arrays. The C stack is a limited resource: for instance, on my amd64
1560             machine with 8MB of stack size I can decode around 180k nested arrays but
1561             only 14k nested JSON objects (due to perl itself recursing deeply on croak
1562             to free the temporary). If that is exceeded, the program crashes. To be
1563             conservative, the default nesting limit is set to 512. If your process
1564             has a smaller stack, you should adjust this setting accordingly with the
1565             C method.
1567             Something else could bomb you, too, that I forgot to think of. In that
1568             case, you get to keep the pieces. I am always open for hints, though...
1570             Also keep in mind that JSON::XS might leak contents of your Perl data
1571             structures in its error messages, so when you serialise sensitive
1572             information you might want to make sure that exceptions thrown by JSON::XS
1573             will not end up in front of untrusted eyes.
1575             If you are using JSON::XS to return packets to consumption
1576             by JavaScript scripts in a browser you should have a look at
1577             L to
1578             see whether you are vulnerable to some common attack vectors (which really
1579             are browser design bugs, but it is still you who will have to deal with
1580             it, as major browser developers care only for features, not about getting
1581             security right).
1584             =head2 "OLD" VS. "NEW" JSON (RFC4627 VS. RFC7159)
1586             JSON originally required JSON texts to represent an array or object -
1587             scalar values were explicitly not allowed. This has changed, and versions
1588             of JSON::XS beginning with C<4.0> reflect this by allowing scalar values
1589             by default.
1591             One reason why one might not want this is that this removes a fundamental
1592             property of JSON texts, namely that they are self-delimited and
1593             self-contained, or in other words, you could take any number of "old"
1594             JSON texts and paste them together, and the result would be unambiguously
1595             parseable:
1597             [1,3]{"k":5}[][null] # four JSON texts, without doubt
1599             By allowing scalars, this property is lost: in the following example, is
1600             this one JSON text (the number 12) or two JSON texts (the numbers 1 and
1601             2):
1603             12 # could be 12, or 1 and 2
1605             Another lost property of "old" JSON is that no lookahead is required to
1606             know the end of a JSON text, i.e. the JSON text definitely ended at the
1607             last C<]> or C<}> character, there was no need to read extra characters.
1609             For example, a viable network protocol with "old" JSON was to simply
1610             exchange JSON texts without delimiter. For "new" JSON, you have to use a
1611             suitable delimiter (such as a newline) after every JSON text or ensure you
1612             never encode/decode scalar values.
1614             Most protocols do work by only transferring arrays or objects, and the
1615             easiest way to avoid problems with the "new" JSON definition is to
1616             explicitly disallow scalar values in your encoder and decoder:
1618             $json_coder = JSON::XS->new->allow_nonref (0)
1620             This is a somewhat unhappy situation, and the blame can fully be put on
1621             JSON's inmventor, Douglas Crockford, who unilaterally changed the format
1622             in 2006 without consulting the IETF, forcing the IETF to either fork the
1623             format or go with it (as I was told, the IETF wasn't amused).
1626             =head1 RELATIONSHIP WITH I-JSON
1628             JSON is a somewhat sloppily-defined format - it carries around obvious
1629             Javascript baggage, such as not really defining number range, probably
1630             because Javascript only has one type of numbers: IEEE 64 bit floats
1631             ("binary64").
1633             For this reaosn, RFC7493 defines "Internet JSON", which is a restricted
1634             subset of JSON that is supposedly more interoperable on the internet.
1636             While C does not offer specific support for I-JSON, it of course
1637             accepts valid I-JSON and by default implements some of the limitations
1638             of I-JSON, such as parsing numbers as perl numbers, which are usually a
1639             superset of binary64 numbers.
1641             To generate I-JSON, follow these rules:
1643             =over
1645             =item * always generate UTF-8
1647             I-JSON must be encoded in UTF-8, the default for C.
1649             =item * numbers should be within IEEE 754 binary64 range
1651             Basically all existing perl installations use binary64 to represent
1652             floating point numbers, so all you need to do is to avoid large integers.
1654             =item * objects must not have duplicate keys
1656             This is trivially done, as C does not allow duplicate keys.
1658             =item * do not generate scalar JSON texts, use C<< ->allow_nonref (0) >>
1660             I-JSON strongly requests you to only encode arrays and objects into JSON.
1662             =item * times should be strings in ISO 8601 format
1664             There are a myriad of modules on CPAN dealing with ISO 8601 - search for
1665             C on CPAN and use one.
1667             =item * encode binary data as base64
1669             While it's tempting to just dump binary data as a string (and let
1670             C do the escaping), for I-JSON, it's I to encode
1671             binary data as base64.
1673             =back
1675             There are some other considerations - read RFC7493 for the details if
1676             interested.
1681             C uses the L module to provide boolean
1682             constants. That means that the JSON true and false values will be
1683             comaptible to true and false values of other modules that do the same,
1684             such as L and L.
1689             As long as you only serialise data that can be directly expressed in JSON,
1690             C is incapable of generating invalid JSON output (modulo bugs,
1691             but C has found more bugs in the official JSON testsuite (1)
1692             than the official JSON testsuite has found in C (0)).
1694             When you have trouble decoding JSON generated by this module using other
1695             decoders, then it is very likely that you have an encoding mismatch or the
1696             other decoder is broken.
1698             When decoding, C is strict by default and will likely catch all
1699             errors. There are currently two settings that change this: C
1700             makes C accept (but not generate) some non-standard extensions,
1701             and C will allow you to encode and decode Perl objects, at the
1702             cost of not outputting valid JSON anymore.
1706             When you use C to use the extended (and also nonstandard and
1707             invalid) JSON syntax for serialised objects, and you still want to decode
1708             the generated When you want to serialise objects, you can run a regex
1709             to replace the tagged syntax by standard JSON arrays (it only works for
1710             "normal" package names without comma, newlines or single colons). First,
1711             the readable Perl version:
1713             # if your FREEZE methods return no values, you need this replace first:
1714             $json =~ s/\( \s* (" (?: [^\\":,]+|\\.|::)* ") \s* \) \s* \[\s*\]/[$1]/gx;
1716             # this works for non-empty constructor arg lists:
1717             $json =~ s/\( \s* (" (?: [^\\":,]+|\\.|::)* ") \s* \) \s* \[/[$1,/gx;
1719             And here is a less readable version that is easy to adapt to other
1720             languages:
1722             $json =~ s/\(\s*("([^\\":,]+|\\.|::)*")\s*\)\s*\[/[$1,/g;
1724             Here is an ECMAScript version (same regex):
1726             json = json.replace (/\(\s*("([^\\":,]+|\\.|::)*")\s*\)\s*\[/g, "[$1,");
1728             Since this syntax converts to standard JSON arrays, it might be hard to
1729             distinguish serialised objects from normal arrays. You can prepend a
1730             "magic number" as first array element to reduce chances of a collision:
1732             $json =~ s/\(\s*("([^\\":,]+|\\.|::)*")\s*\)\s*\[/["XU1peReLzT4ggEllLanBYq4G9VzliwKF",$1,/g;
1734             And after decoding the JSON text, you could walk the data
1735             structure looking for arrays with a first element of
1736             C.
1738             The same approach can be used to create the tagged format with another
1739             encoder. First, you create an array with the magic string as first member,
1740             the classname as second, and constructor arguments last, encode it as part
1741             of your JSON structure, and then:
1743             $json =~ s/\[\s*"XU1peReLzT4ggEllLanBYq4G9VzliwKF"\s*,\s*("([^\\":,]+|\\.|::)*")\s*,/($1)[/g;
1745             Again, this has some limitations - the magic string must not be encoded
1746             with character escapes, and the constructor arguments must be non-empty.
1749             =head1 (I-)THREADS
1751             This module is I guaranteed to be ithread (or MULTIPLICITY-) safe
1752             and there are no plans to change this. Note that perl's builtin so-called
1753             threads/ithreads are officially deprecated and should not be used.
1756             =head1 THE PERILS OF SETLOCALE
1758             Sometimes people avoid the Perl locale support and directly call the
1759             system's setlocale function with C.
1761             This breaks both perl and modules such as JSON::XS, as stringification of
1762             numbers no longer works correctly (e.g. C<$x = 0.1; print "$x"+1> might
1763             print C<1>, and JSON::XS might output illegal JSON as JSON::XS relies on
1764             perl to stringify numbers).
1766             The solution is simple: don't call C, or use it for only those
1767             categories you need, such as C or C.
1769             If you need C, you should enable it only around the code that
1770             actually needs it (avoiding stringification of numbers), and restore it
1771             afterwards.
1774             =head1 SOME HISTORY
1776             At the time this module was created there already were a number of JSON
1777             modules available on CPAN, so what was the reason to write yet another
1778             JSON module? While it seems there are many JSON modules, none of them
1779             correctly handled all corner cases, and in most cases their maintainers
1780             are unresponsive, gone missing, or not listening to bug reports for other
1781             reasons.
1783             Beginning with version 2.0 of the JSON module, when both JSON and
1784             JSON::XS are installed, then JSON will fall back on JSON::XS (this can be
1785             overridden) with no overhead due to emulation (by inheriting constructor
1786             and methods). If JSON::XS is not available, it will fall back to the
1787             compatible JSON::PP module as backend, so using JSON instead of JSON::XS
1788             gives you a portable JSON API that can be fast when you need it and
1789             doesn't require a C compiler when that is a problem.
1791             Somewhere around version 3, this module was forked into
1792             C, because its maintainer had serious trouble
1793             understanding JSON and insisted on a fork with many bugs "fixed" that
1794             weren't actually bugs, while spreading FUD about this module without
1795             actually giving any details on his accusations. You be the judge, but
1796             in my personal opinion, if you want quality, you will stay away from
1797             dangerous forks like that.
1800             =head1 BUGS
1802             While the goal of this module is to be correct, that unfortunately does
1803             not mean it's bug-free, only that I think its design is bug-free. If you
1804             keep reporting bugs they will be fixed swiftly, though.
1806             Please refrain from using or any other bug reporting
1807             service. I put the contact address into my modules for a reason.
1809             =cut
1811             BEGIN {
1812 25     25   122 *true = \$Types::Serialiser::true;
1813 25         59 *true = \&Types::Serialiser::true;
1814 25         50 *false = \$Types::Serialiser::false;
1815 25         47 *false = \&Types::Serialiser::false;
1816 25         45 *is_bool = \&Types::Serialiser::is_bool;
1818 25         1392 *JSON::XS::Boolean:: = *Types::Serialiser::Boolean::;
1819             }
1821             XSLoader::load "JSON::XS", $VERSION;
1823             =head1 SEE ALSO
1825             The F command line utility for quick experiments.
1827             =head1 AUTHOR
1829             Marc Lehmann
1832             =cut
1834             1