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.
This module knows how to handle Unicode (depending on Perl version).
See to JSON::XS/A FEW NOTES ON UNICODE AND PERL and UNICODE HANDLING ON PERLS.
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.
This function call is functionally identical to:
$perl_scalar = JSON->new->utf8->decode($json_text)
isa JSON::PP::Boolean object.
isa JSON::PP::Boolean object.
undef.
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 JSON::XS/OBJECT-ORIENTED INTERFACE).
In Perl 5.005, there is no character having high value (more than 255). See to UNICODE HANDLING ON PERLS.
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.
JSON::XS->new->latin1->encode (["\x{89}\x{abc}"]
=> ["\x{89}\\u0abc"] # (perl syntax, U+abc escaped, U+89 not)
See to UNICODE HANDLING ON PERLS.
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 Perl 5.005, any character outside the range 0..255 does not exist. See to UNICODE HANDLING ON PERLS.)
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.
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.
If $enable is false, no newlines or indenting will be produced, and the
resulting JSON text is guarenteed not to contain any 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.
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.
This setting has no effect when decoding JSON texts.
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.
If $enable is false, then the encode method will not add any extra
space at those places.
This setting has no effect when decoding JSON texts.
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.)
If $enable is false (the default), then decode will only accept
valid JSON texts.
Currently accepted extensions are:
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
}
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.
This setting has no effect when decoding JSON texts.
See to JSON::XS/OBJECT-ORIENTED INTERFACE
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.
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.
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.
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.
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.
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.
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.
Example, decode JSON objects of the form { "__widget__" => <id> }
into the corresponding $WIDGET{<id>} object:
# 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.
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.
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.
This rounding up feature is for JSON::XS internal C structure. To the compatibility, JSON::PP has the same feature.
See JSON::XS/SSECURITY CONSIDERATIONS 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).
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).
This rounding up feature is for JSON::XS internal C structure. To the compatibility, JSON::PP has the same feature.
See JSON::XS/SSECURITY CONSIDERATIONS for more info on why this is useful.
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.
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.
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 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.
If $enable is true (or missing), then decode will accept
bare keys of JSON object that are invalid JSON format.
As same as the relaxed option, this option may be used to parse
application-specific files written by humans.
$json->allow_barekey->decode({foo:"bar"});
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.
On the contary, encode converts Math::BigInt objects and Math::BigFloat
objects into JSON numbers with allow_blessed enable.
$json->allow_nonref->allow_blessed->allow_bignum;
$bigfloat = $json->decode('2.000000000000000000000000001');
print $json->encode($bigfloat);
# => 2.000000000000000000000000001
See to JSON::XS/MAPPING aboout the normal 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"]|);
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.
(EXPERIMENTAL)
If $enable is true (or missing), then encode will convert
a blessed hash reference or a blessed array reference (contains
other blessed references) into JSON members and arrays.
This feature is effective only when allow_blessed is enable.
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::'.
If $integer is set, then the effect is same as canonical on.
For developers.
Returns
{
depth => $depth,
indent_count => $indent_count,
}
Returns
{
text => $text,
at => $at,
ch => $ch,
len => $len,
is_utf8 => $is_utf8,
depth => $depth,
encoding => $encoding,
is_valid_utf8 => $is_valid_utf8,
};
See to JSON::XS/MAPPING.
If you do not know about Unicode on Perl well, please check JSON::XS/A FEW NOTES ON UNICODE AND PERL.
Perl can handle Unicode and the JSON::PP de/encode methods also work properly.
$json->allow_nonref->encode(chr hex 3042);
$json->allow_nonref->encode(chr hex 12345);
Reuturns "\u3042" and "\ud808\udf45" respectively.
$json->allow_nonref->decode('"\u3042"');
$json->allow_nonref->decode('"\ud808\udf45"');
Returns UTF-8 encoded strings with UTF8 flag, regarded as U+3042 and U+12345.
Note that the versions from Perl 5.8.0 to 5.8.2, Perl built-in join was broken,
so JSON::PP wraps the join with a subroutine. Thus JSON::PP works slow in the versions.
Perl can handle Unicode and the JSON::PP de/encode methods also work.
Perl 5.005 is a byte sementics world -- all strings are sequences of bytes. That means the unicode handling is not available.
In encoding,
$json->allow_nonref->encode(chr hex 3042); # hex 3042 is 12354.
$json->allow_nonref->encode(chr hex 12345); # hex 12345 is 74565.
Returns B and E, as chr takes a value more than 255, it treats
as $value % 256, so the above codes are equivalent to :
$json->allow_nonref->encode(chr 66);
$json->allow_nonref->encode(chr 69);
In decoding,
$json->decode('"\u00e3\u0081\u0082"');
The returned is a byte sequence 0xE3 0x81 0x82 for UTF-8 encoded
japanese character (HIRAGANA LETTER A).
And if it is represented in Unicode code point, U+3042.
Next,
$json->decode('"\u3042"');
We ordinary expect the returned value is a Unicode character U+3042.
But here is 5.005 world. This is 0xE3 0x81 0x82.
$json->decode('"\ud808\udf45"');
This is not a character U+12345 but bytes - 0xf0 0x92 0x8d 0x85.
Most of the document are copied and modified from JSON::XS doc.
RFC4627 (http://www.ietf.org/rfc/rfc4627.txt)
Makamaka Hannyaharamitu, <makamaka[at]cpan.org>
Copyright 2008 by Makamaka Hannyaharamitu
This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.