|
JSON - JSON (JavaScript Object Notation) encoder/decoder
use JSON;
$json_text = to_json($perl_scalar);
$perl_scalar = from_json($json_text);
$json_text = to_json($perl_scalar, {ascii => 1});
$perl_scalar = from_json($json_text, {utf8 => 1});
$json = new JSON;
$json_text = $json->encode($perl_scalar);
$perl_scalar = $json->decode($json_text);
$json_text = $json->pretty->encode($perl_scalar);
$utf8_encoded_json_text = encode_json $perl_hash_or_arrayref;
$perl_hash_or_arrayref = decode_json $utf8_encoded_json_text;
use JSON -support_by_pp;
2.11
This version is compatible with JSON::XS 2.21.
************************** CAUTION ********************************
* This is 'JSON module version 2' and there are many differences *
* to version 1.xx *
* Please check your applications useing old version. *
* See to 'INCOMPATIBLE CHANGES TO OLD VERSION' *
*******************************************************************
JSON (JavaScript Object Notation) is a simple data format.
See to http://www.json.org/ and RFC4627(http://www.ietf.org/rfc/rfc4627.txt).
This module converts Perl data structures to JSON and vice versa using either
the JSON::XS manpage or the JSON::PP manpage.
JSON::XS is the fastest and most proper JSON module on CPAN which must be
compiled and installed in your environment.
JSON::PP is a pure-Perl module which is bundled in this distribution and
has a strong compatibility to JSON::XS.
This module try to use JSON::XS by default and fail to it, use JSON::PP instead.
So its features completely depend on JSON::XS or JSON::PP.
See to BACKEND MODULE DECISION.
To distinguish the module name 'JSON' and the format type JSON,
the former is quoted by C<> (its results vary with your using media),
and the latter is left just as it is.
Module name : JSON
Format type : JSON
- correct unicode handling
This module (i.e. backend modules) knows how to handle Unicode, documents
how and when it does so, and even documents what "correct" means.
Even though there are limitations, this feature is available since Perl version 5.6.
JSON::XS requires Perl 5.8.2 (but works correctly in 5.8.8 or later), so in older versions
JSON sholud call JSON::PP as the backend which can be used since Perl 5.005.
With Perl 5.8.x JSON::PP works, but from 5.8.0 to 5.8.2, because of a Perl side problem,
JSON::PP works slower in the versions. And in 5.005, the Unicode handling is not available.
See to UNICODE HANDLING ON PERLS in the JSON::PP manpage for more information.
See also to A FEW NOTES ON UNICODE AND PERL in the JSON::XS manpage
and ENCODING/CODESET_FLAG_NOTES in the JSON::XS manpage.
- round-trip integrity
When you serialise a perl data structure using only data types 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). There minor are exceptions to this, read the MAPPING
section below to learn about those.
- 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).
See to FEATURES in the JSON::XS manpage and FEATURES in the JSON::PP manpage.
- fast
This module returns a JSON::XS object itself if avaliable.
Compared to other JSON modules and other serialisers such as Storable,
JSON::XS usually compares favourably in terms of speed, too.
If not avaliable, JSON returns a JSON::PP object instead of JSON::XS and
it is very slow as pure-Perl.
- simple to use
This module has both a simple functional interface as well as an
object oriented interface interface.
- reasonably versatile output formats
You can choose between the most compact guaranteed-single-line format possible
(nice for simple line-based protocols), a pure-ASCII format (for when your transport
is not 8-bit clean, still supports the whole Unicode range), or a pretty-printed
format (for when you want to read that stuff). Or you can combine those features
in whatever way you like.
Some documents are copied and modified from FUNCTIONAL INTERFACE in the JSON::XS manpage.
to_json and from_json are additional functions.
$json_text = to_json($perl_scalar)
Converts the given Perl data structure to a json string.
This function call is functionally identical to:
$json_text = JSON->new->encode($perl_scalar)
Takes a hash reference as the second.
$json_text = to_json($perl_scalar, $flag_hashref)
So,
$json_text = encode_json($perl_scalar, {utf8 => 1, pretty => 1})
equivalent to:
$json_text = JSON->new->utf8(1)->pretty(1)->encode($perl_scalar)
$perl_scalar = from_json($json_text)
The opposite of to_json: expects a json string and tries
to parse it, returning the resulting reference.
This function call is functionally identical to:
$perl_scalar = JSON->decode($json_text)
Takes a hash reference as the second.
$perl_scalar = from_json($json_text, $flag_hashref)
So,
$perl_scalar = from_json($json_text, {utf8 => 1})
equivalent to:
$perl_scalar = JSON->new->utf8(1)->decode($json_text)
$json_text = encode_json $perl_scalar
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)
$perl_scalar = decode_json $json_text
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)
$is_boolean = JSON::is_bool($scalar)
Returns true if the passed scalar represents either JSON::true or
JSON::false, two constants that act like 1 and 0 respectively
and are also used to represent JSON true and false in Perl strings.
Returns JSON true value which is blessed object.
It isa JSON::Boolean object.
Returns JSON false value which is blessed object.
It isa JSON::Boolean object.
Returns undef.
See MAPPING, below, for more information on how JSON values are mapped to
Perl.
$json = new JSON
Returns a new JSON object inherited from either JSON::XS or JSON::PP
that can be used to de/encode JSON strings.
All boolean flags described below are by default disabled.
The mutators for flags all return the JSON object again and thus calls can
be chained:
my $json = JSON->new->utf8->space_after->encode({a => [1,2]})
=> {"a": [1, 2]}
$json = $json->ascii([$enable])
$enabled = $json->get_ascii
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.
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.
This feature depends on the used Perl version and environment.
See to UNICODE HANDLING ON PERLS in the JSON::PP manpage if the backend is PP.
JSON->new->ascii(1)->encode([chr 0x10401])
=> ["\ud801\udc01"]
$json = $json->latin1([$enable])
$enabled = $json->get_latin1
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->new->latin1->encode (["\x{89}\x{abc}"]
=> ["\x{89}\\u0abc"]
$json = $json->utf8([$enable])
$enabled = $json->get_utf8
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);
See to UNICODE HANDLING ON PERLS in the JSON::PP manpage if the backend is PP.
$json = $json->pretty([$enable])
This enables (or disables) all of the indent, space_before and
space_after (and in the future possibly more) flags in one call to
generate the most readable (or most compact) form possible.
Equivalent to:
$json->indent->space_before->space_after
The indent space length is three and JSON::XS cannot change the indent
space length.
$json = $json->indent([$enable])
$enabled = $json->get_indent
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 indent space length is three.
With JSON::PP, you can also access indent_length to change indent space length.
$json = $json->space_before([$enable])
$enabled = $json->get_space_before
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"}
$json = $json->space_after([$enable])
$enabled = $json->get_space_after
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"}
$json = $json->relaxed([$enable])
$enabled = $json->get_relaxed
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:
- 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...
]
$json = $json->canonical([$enable])
$enabled = $json->get_canonical
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.
$json = $json->allow_nonref([$enable])
$enabled = $json->get_allow_nonref
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!"
$json = $json->allow_unknown ([$enable])
$enabled = $json->get_allow_unknown
If $enable is true (or missing), then "encode" will *not* throw an
exception when it encounters values it cannot represent in JSON (for
example, filehandles) but instead will encode a JSON "null" value.
Note that blessed objects are not included here and are handled
separately by c<allow_nonref>.
If $enable is false (the default), then "encode" will throw an
exception when it encounters anything it cannot encode as JSON.
This option does not affect "decode" in any way, and it is
recommended to leave it off unless you know your communications
partner.
$json = $json->allow_blessed([$enable])
$enabled = $json->get_allow_blessed
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.
$json = $json->convert_blessed([$enable])
$enabled = $json->get_convert_blessed
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.
- convert_blessed_universally mode
-
If use JSON with -convert_blessed_universally, the UNIVERSAL::TO_JSON
subroutine is defined as the below code:
-
*UNIVERSAL::TO_JSON = sub {
my $b_obj = B::svref_2object( $_[0] );
return $b_obj->isa('B::HV') ? { %{ $_[0] } }
: $b_obj->isa('B::AV') ? [ @{ $_[0] } ]
: undef
;
}
-
This will cause that encode method converts simple blessed objects into
JSON objects as non-blessed object.
-
JSON -convert_blessed_universally;
$json->allow_blessed->convert_blessed->encode( $blessed_object )
-
This feature is experimental and may be removed in the future.
$json = $json->filter_json_object([$coderef])
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 });
$js->decode ('[{}]');
$js->decode ('{"a":1, "b":2}');
$json = $json->filter_json_single_key_object($key [=> $coderef])
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:
JSON
->new
->filter_json_single_key_object (__widget__ => sub {
$WIDGET{ $_[0] }
})
->decode ('{"__widget__": 5')
sub WidgetBase::TO_JSON {
my ($self) = @_;
unless ($self->{id}) {
$self->{id} = ..get..some..id..;
$WIDGET{$self->{id}} = $self;
}
{ __widget__ => $self->{id} }
}
$json = $json->shrink([$enable])
$enabled = $json->get_shrink
With JSON::XS, this flag resizes strings generated by either
encode or decode to their minimum size possible. This can save
memory when your JSON texts are either very very long or you have many
short strings. It will also try to downgrade any strings to octet-form
if possible: perl stores strings internally either in an encoding called
UTF-X or in octet-form. The latter cannot store everything but uses less
space in general (and some buggy Perl or C code might even rely on that
internal representation being used).
With JSON::PP, it is noop about resizing strings but tries
utf8::downgrade to the returned string by encode. See to the utf8 manpage.
See to OBJECT-ORIENTED INTERFACE in the JSON::XS manpage and METHODS in the JSON::PP manpage.
$json = $json->max_depth([$maximum_nesting_depth])
$max_depth = $json->get_max_depth
Sets the maximum nesting level (default 512) accepted while encoding
or decoding. If a higher nesting level is detected in JSON text or a Perl
data structure, 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.
If no argument is given, the highest possible setting will be used, which
is rarely useful.
Note that nesting is implemented by recursion in C. The default value has
been chosen to be as large as typical operating systems allow without
crashing. (JSON::XS)
With JSON::PP as the backend, 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.
See SECURITY CONSIDERATIONS in the JSON::XS manpage for more info on why this is useful.
$json = $json->max_size([$maximum_string_size])
$max_size = $json->get_max_size
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 that is longer then this many bytes, it will not
attempt to decode the string but throw an exception. This setting has no
effect on encode (yet).
If no argument is given, the limit check will be deactivated (same as when
0 is specified).
See SECURITY CONSIDERATIONS in the JSON::XS manpage, below, for more info on why this is useful.
$json_text = $json->encode($perl_scalar)
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.
$perl_scalar = $json->decode($json_text)
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.
($perl_scalar, $characters) = $json->decode_prefix($ | 
