JSON::PP - JSON::XS compatible pure-Perl module.
use JSON::PP; # exported functions, they croak on error # and expect/generate UTF-8 $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; # OO-interface $coder = JSON::PP->new->ascii->pretty->allow_nonref; $pretty_printed_unencoded = $coder->encode ($perl_scalar); $perl_scalar = $coder->decode ($unicode_json_text); # Note that JSON version 2.0 and above will automatically use # JSON::XS or JSON::PP, so you should be able to just: use JSON;
This module is JSON::XS compatible pure Perl module. (Perl 5.8 or later is recommended)
JSON::XS is the fastest and most proper JSON module on CPAN. It is written by Marc Lehmann in C, so must be compiled and installed in the used environment.
JSON::PP is a pure-Perl module and has compatibility to JSON::XS.
correct unicode handling
This module knows how to handle Unicode (depending on Perl version).
See to "A FEW NOTES ON UNICODE AND PERL" in JSON::XS and "OBJECT-ORIENTED INTERFACE" in JSON::XS.
In Perl 5.8.x, the feature is available.
In 5.6.x, Unicode handling requires Unicode::String module.
Perl 5.005_xx, Unicode handling is disable currenlty.
round-trip integrity
When you serialise a perl data structure using only datatypes supported by JSON, the deserialised data structure is identical on the Perl level. (e.g. the string "2.0" doesn't suddenly become "2" just because it looks like a number).
strict checking of JSON correctness
There is no guessing, no generating of illegal JSON texts by default, and only JSON is accepted as input by default (the latter is a security feature). But when some options are set, loose chcking features are available.
Converts the given Perl data structure to a UTF-8 encoded, binary string.
This function call is functionally identical to:
$json_text = JSON->new->utf8->encode($perl_scalar)
The opposite of encode_json: expects an UTF-8 (binary) string and tries to parse that as an UTF-8 encoded JSON text, returning the resulting reference.
encode_json
$perl_scalar = JSON->new->utf8->decode($json_text)
Returns JSON true value which is blessed object. It isa JSON::PP::Boolean object.
isa
Returns JSON false value which is blessed object. It isa JSON::PP::Boolean object.
Returns undef.
undef
Rturns a new JSON::PP object that can be used to de/encode JSON strings.
If $enable is true (or missing), then the encode method will not generate characters outside the code range 0..127. Any Unicode characters outside that range will be escaped using either a single \uXXXX or a double \uHHHH\uLLLLL escape sequence, as per RFC4627. (See to "OBJECT-ORIENTED INTERFACE" in JSON::XS).
(Currently this module always handles UTF-16 as UTF-16BE.)
In Perl 5.6, this function requires Unicode::String and if you don't have it, the method is always set to false and warns.
In 5.005, this option is currently disable.
If $enable is false, then the encode method will not escape Unicode characters unless required by the JSON syntax or other flags. This results in a faster and more compact format.
JSON::PP->new->ascii(1)->encode([chr 0x10401]) => ["\ud801\udc01"]
If $enable is true (or missing), then the encode method will encode the resulting JSON text as latin1 (or iso-8859-1), escaping any characters outside the code range 0..255.
If $enable is false, then the encode method will not escape Unicode characters unless required by the JSON syntax or other flags.
See to "OBJECT-ORIENTED INTERFACE" in JSON::XS.
JSON::XS->new->latin1->encode (["\x{89}\x{abc}"] => ["\x{89}\\u0abc"] # (perl syntax, U+abc escaped, U+89 not)
If $enable is true (or missing), then the encode method will encode the JSON result into UTF-8, as required by many protocols, while the decode method expects to be handled an UTF-8-encoded string. Please note that UTF-8-encoded strings do not contain any characters outside the range 0..255, they are thus useful for bytewise/binary I/O.
In future versions, enabling this option might enable autodetection of the UTF-16 and UTF-32 encoding families, as described in RFC4627.
If $enable is false, then the encode method will return the JSON string as a (non-encoded) Unicode string, while decode expects thus a Unicode string. Any decoding or encoding (e.g. to UTF-8 or UTF-16) needs to be done yourself, e.g. using the Encode module.
Example, output UTF-16BE-encoded JSON:
use Encode; $jsontext = encode "UTF-16BE", JSON::XS->new->encode ($object);
Example, decode UTF-32LE-encoded JSON:
use Encode; $object = JSON::XS->new->decode (decode "UTF-32LE", $jsontext);
This enables (or disables) all of the indent, space_before and space_after flags in one call to generate the most readable (or most compact) form possible.
indent
space_before
space_after
Equivalent to:
$json->indent->space_before->space_after
Example, pretty-print some simple structure:
my $json = JSON->new->pretty(1)->encode ({a => [1,2]}) => { "a" : [ 1, 2 ] }
The indent space length is three.
If $enable is true (or missing), then the encode method will use a multiline format as output, putting every array member or object/hash key-value pair into its own line, identing them properly.
$enable
encode
If $enable is false, no newlines or indenting will be produced, and the resulting JSON text is guarenteed not to contain any newlines.
newlines
This setting has no effect when decoding JSON texts.
The default indent space lenght is three. You can use indent_length to change the length.
indent_length
If $enable is true (or missing), then the encode method will add an extra optional space before the : separating keys from values in JSON objects.
:
If $enable is false, then the encode method will not add any extra space at those places.
Example, space_before enabled, space_after and indent disabled:
{"key" :"value"}
If $enable is true (or missing), then the encode method will add an extra optional space after the : separating keys from values in JSON objects and extra whitespace after the , separating key-value pairs and array members.
,
Example, space_before and indent disabled, space_after enabled:
{"key": "value"}
If $enable is true (or missing), then decode will accept some extensions to normal JSON syntax (see below). encode will not be affected in anyway. Be aware that this option makes you accept invalid JSON texts as if they were valid!. I suggest only to use this option to parse application-specific files written by humans (configuration files, resource files etc.)
decode
If $enable is false (the default), then decode will only accept valid JSON texts.
Currently accepted extensions are:
list items can have an end-comma
JSON separates array elements and key-value pairs with commas. This can be annoying if you write JSON texts manually and want to be able to quickly append elements, so this extension accepts comma at the end of such items not just between them:
[ 1, 2, <- this comma not normally allowed ] { "k1": "v1", "k2": "v2", <- this comma not normally allowed }
shell-style '#'-comments
Whenever JSON allows whitespace, shell-style comments are additionally allowed. They are terminated by the first carriage-return or line-feed character, after which more white-space and comments are allowed.
[ 1, # this comment not allowed in JSON # neither this one... ]
If $enable is true (or missing), then the encode method will output JSON objects by sorting their keys. This is adding a comparatively high overhead.
If $enable is false, then the encode method will output key-value pairs in the order Perl stores them (which will likely change between runs of the same script).
This option is useful if you want the same data structure to be encoded as the same JSON text (given the same overall settings). If it is disabled, the same hash might be encoded differently even if contains the same data, as key-value pairs have no inherent ordering in Perl.
See to "OBJECT-ORIENTED INTERFACE" in JSON::XS
If you want your own sorting routine, you can give a code referece or a subroutine name to sort_by. See to JSON::PP OWN METHODS.
sort_by
JSON::PP OWN METHODS
If $enable is true (or missing), then the encode method can convert a non-reference into its corresponding string, number or null JSON value, which is an extension to RFC4627. Likewise, decode will accept those JSON values instead of croaking.
If $enable is false, then the encode method will croak if it isn't passed an arrayref or hashref, as JSON texts must either be an object or array. Likewise, decode will croak if given something that is not a JSON object or array.
JSON->new->allow_nonref->encode ("Hello, World!") => "Hello, World!"
If $enable is true (or missing), then the encode method will not barf when it encounters a blessed reference. Instead, the value of the convert_blessed option will decide whether null (convert_blessed disabled or no TO_JSON method found) or a representation of the object (convert_blessed enabled and TO_JSON method found) is being encoded. Has no effect on decode.
null
convert_blessed
TO_JSON
If $enable is false (the default), then encode will throw an exception when it encounters a blessed object.
If $enable is true (or missing), then encode, upon encountering a blessed object, will check for the availability of the TO_JSON method on the object's class. If found, it will be called in scalar context and the resulting scalar will be encoded instead of the object. If no TO_JSON method is found, the value of allow_blessed will decide what to do.
allow_blessed
The TO_JSON method may safely call die if it wants. If TO_JSON returns other blessed objects, those will be handled in the same way. TO_JSON must take care of not causing an endless recursion cycle (== crash) in this case. The name of TO_JSON was chosen because other methods called by the Perl core (== not by the user of the object) are usually in upper case letters and to avoid collisions with the to_json function or method.
to_json
This setting does not yet influence decode in any way.
If $enable is false, then the allow_blessed setting will decide what to do when a blessed object is found.
When $coderef is specified, it will be called from decode each time it decodes a JSON object. The only argument passed to the coderef is a reference to the newly-created hash. If the code references returns a single scalar (which need not be a reference), this value (i.e. a copy of that scalar to avoid aliasing) is inserted into the deserialised data structure. If it returns an empty list (NOTE: not undef, which is a valid scalar), the original deserialised hash will be inserted. This setting can slow down decoding considerably.
$coderef
When $coderef is omitted or undefined, any existing callback will be removed and decode will not change the deserialised hash in any way.
Example, convert all JSON objects into the integer 5:
my $js = JSON->new->filter_json_object (sub { 5 }); # returns [5] $js->decode ('[{}]'); # the given subroutine takes a hash reference. # throw an exception because allow_nonref is not enabled # so a lone 5 is not allowed. $js->decode ('{"a":1, "b":2}');
Works remotely similar to filter_json_object, but is only called for JSON objects having a single key named $key.
filter_json_object
$key
This $coderef is called before the one specified via filter_json_object, if any. It gets passed the single value in the JSON object. If it returns a single value, it will be inserted into the data structure. If it returns nothing (not even undef but the empty list), the callback from filter_json_object will be called next, as if no single-key callback were specified.
If $coderef is omitted or undefined, the corresponding callback will be disabled. There can only ever be one callback for a given key.
As this callback gets called less often then the filter_json_object one, decoding speed will not usually suffer as much. Therefore, single-key objects make excellent targets to serialise Perl objects into, especially as single-key JSON objects are as close to the type-tagged value concept as JSON gets (it's basically an ID/VALUE tuple). Of course, JSON does not support this in any way, so you need to make sure your data never looks like a serialised Perl hash.
Typical names for the single object key are __class_whatever__, or $__dollars_are_rarely_used__$ or }ugly_brace_placement, or even things like __class_md5sum(classname)__, to reduce the risk of clashing with real hashes.
__class_whatever__
$__dollars_are_rarely_used__$
}ugly_brace_placement
__class_md5sum(classname)__
Example, decode JSON objects of the form { "__widget__" => <id> } into the corresponding $WIDGET{<id>} object:
{ "__widget__" => <id> }
$WIDGET{<id>}
# return whatever is in $WIDGET{5}: JSON ->new ->filter_json_single_key_object (__widget__ => sub { $WIDGET{ $_[0] } }) ->decode ('{"__widget__": 5') # this can be used with a TO_JSON method in some "widget" class # for serialisation to json: sub WidgetBase::TO_JSON { my ($self) = @_; unless ($self->{id}) { $self->{id} = ..get..some..id..; $WIDGET{$self->{id}} = $self; } { __widget__ => $self->{id} } }
In JSON::XS, this flag resizes strings generated by either encode or decode to their minimum size possible. It will also try to downgrade any strings to octet-form if possible.
In JSON::PP, it is noop about resizing strings but tries utf8::downgrade to the returned string by encode. See to utf8.
utf8::downgrade
Sets the maximum nesting level (default 512) accepted while encoding or decoding. If the JSON text or Perl data structure has an equal or higher nesting level then this limit, then the encoder and decoder will stop and croak at that point.
512
Nesting level is defined by number of hash- or arrayrefs that the encoder needs to traverse to reach a given point or the number of { or [ characters without their matching closing parenthesis crossed to reach a given character in a string.
{
[
The argument to max_depth will be rounded up to the next highest power of two. If no argument is given, the highest possible setting will be used, which is rarely useful.
max_depth
This rounding up feature is for JSON::XS internal C structure. To the compatibility, JSON::PP has the same feature.
See "SSECURITY CONSIDERATIONS" in JSON::XS for more info on why this is useful.
When a large value (100 or more) was set and it de/encodes a deep nested object/text, it may raise a warning 'Deep recursion on subroutin' at the perl runtime phase.
Set the maximum length a JSON text may have (in bytes) where decoding is being attempted. The default is 0, meaning no limit. When decode is called on a string longer then this number of characters it will not attempt to decode the string but throw an exception. This setting has no effect on encode (yet).
0
The argument to max_size will be rounded up to the next highest power of two (so may be more than requested). If no argument is given, the limit check will be deactivated (same as when 0 is specified).
max_size
Converts the given Perl data structure (a simple scalar or a reference to a hash or array) to its JSON representation. Simple scalars will be converted into JSON string or number sequences, while references to arrays become JSON arrays and references to hashes become JSON objects. Undefined Perl values (e.g. undef) become JSON null values. Neither true nor false values will be generated.
true
false
The opposite of encode: expects a JSON text and tries to parse it, returning the resulting simple scalar or reference. Croaks on error.
JSON numbers and strings become simple Perl scalars. JSON arrays become Perl arrayrefs and JSON objects become Perl hashrefs. true becomes 1, false becomes 0 and null becomes undef.
1
This works like the decode method, but instead of raising an exception when there is trailing garbage after the first JSON object, it will silently stop parsing there and return the number of characters consumed so far.
JSON->new->decode_prefix ("[1] the tail") => ([], 3)
If $enable is true (or missing), then the encode method tests for a toJson() method on the given object, and obtains its returned value as the converted value of the object.
toJson()
This feature is for the old JSON (v1.xx) compatibility. It may be obsoleted.
JSON
If $enable is true (or missing), then decode will accept JSON strings quoted by single quotations that are invalid JSON format.
$json->allow_singlequote->decode({"foo":'bar'}); $json->allow_singlequote->decode({'foo':"bar"}); $json->allow_singlequote->decode({'foo':'bar'});
As same as the relaxed option, this option may be used to parse application-specific files written by humans.
relaxed
If $enable is true (or missing), then decode will accept bare keys of JSON object that are invalid JSON format.
$json->allow_barekey->decode({foo:"bar"});
Obsoleted. Use allow_bignum instead.
allow_bignum
If $enable is true (or missing), then decode will convert the big integer Perl cannot handle as integer into a Math::BigInt object and convert a floating number (any) into a Math::BigFloat.
See to "MAPPING" in JSON::XS aboout the conversion of JSON number.
The unescaped [\x00-\x1f\x22\x2f\x5c] strings are invalid in JSON strings and the module doesn't allow to decode to these (except for \x2f). If $enable is true (or missing), then decode will accept these unescaped strings.
$json->loose->decode(qq|["abc def"]|);
See "SSECURITY CONSIDERATIONS" in JSON::XS.
According to JSON Grammar, slash (U+002F) is escaped. But default JSON::PP (as same as JSON::XS) encodes strings without escaping slash.
If $enable is true (or missing), then encode will escape slashes.
JSON::XS indent space length is 3 and cannot be changed. JSON::PP set the indent space length with the given $length. The default is 3.
If $function_name or $subroutine_ref are set, its sort routine are used in encoding JSON objects.
$js = $pc->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })->encode($obj); # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); $js = $pc->sort_by('own_sort')->encode($obj); # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b }
As the sorting routine runs in the JSON::PP scope, the given subroutine name and the special variables $a, $b will begin 'JSON::PP::'.
$a
$b
If $integer is set, then the effect is same as canonical on.
canonical
See to "MAPPING" in JSON.
It is troublesome.
Under the cleaning.
Most of the document are copied and modified from JSON::XS doc.
JSON::XS
RFC4627
Makamaka Hannyaharamitu, <makamaka[at]cpan.org>
Copyright 2007 by Makamaka Hannyaharamitu
This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
To install JSON, copy and paste the appropriate command in to your terminal.
cpanm
cpanm JSON
CPAN shell
perl -MCPAN -e shell install JSON
For more information on module installation, please visit the detailed CPAN module installation guide.