NAME

       Mojo::JSON - Minimalistic JSON

SYNOPSIS

         use Mojo::JSON;

         # Encode and decode JSON
         my $json  = Mojo::JSON->new;
         my $bytes = $json->encode({foo => [1, 2], bar => 'hello!', baz => \1});
         my $hash  = $json->decode($bytes);

         # Check for errors
         my $json = Mojo::JSON->new;
         if (defined(my $hash = $json->decode($bytes))) { say $hash->{message} }
         else { say 'Error: ', $json->error }

         # Use the alternative interface
         use Mojo::JSON 'j';
         my $bytes = j({foo => [1, 2], bar => 'hello!', baz => \1});
         my $hash  = j($bytes);

DESCRIPTION

       Mojo::JSON is a minimalistic and possibly the fastest pure-Perl implementation of RFC
       4627.

       It supports normal Perl data types like "Scalar", "Array" reference, "Hash" reference and
       will try to call the "TO_JSON" method on blessed references, or stringify them if it
       doesn't exist. Differentiating between strings and numbers in Perl is hard, depending on
       how it has been used, a "Scalar" can be both at the same time. Since numeric comparisons
       on strings are very unlikely to happen intentionally, the numeric value always gets
       priority, so any "Scalar" that has been used in numeric context is considered a number.

         [1, -2, 3]     -> [1, -2, 3]
         {"foo": "bar"} -> {foo => 'bar'}

       Literal names will be translated to and from Mojo::JSON constants or a similar native Perl
       value.

         true  -> Mojo::JSON->true
         false -> Mojo::JSON->false
         null  -> undef

       In addition "Scalar" references will be used to generate booleans, based on if their
       values are true or false.

         \1 -> true
         \0 -> false

       Decoding UTF-16 (LE/BE) and UTF-32 (LE/BE) will be handled transparently, encoding will
       only generate UTF-8. The two Unicode whitespace characters "u2028" and "u2029" will always
       be escaped to make JSONP easier.

FUNCTIONS

       Mojo::JSON implements the following functions.

   j
         my $bytes = j([1, 2, 3]);
         my $bytes = j({foo => 'bar'});
         my $array = j($bytes);
         my $hash  = j($bytes);

       Encode Perl data structure or decode JSON and return "undef" if decoding fails.

ATTRIBUTES

       Mojo::JSON implements the following attributes.

   error
         my $err = $json->error;
         $json   = $json->error('Parser error');

       Parser errors.

METHODS

       Mojo::JSON inherits all methods from Mojo::Base and implements the following new ones.

   decode
         my $array = $json->decode($bytes);
         my $hash  = $json->decode($bytes);

       Decode JSON to Perl data structure and return "undef" if decoding fails.

   encode
         my $bytes = $json->encode([1, 2, 3]);
         my $bytes = $json->encode({foo => 'bar'});

       Encode Perl data structure to JSON.

   false
         my $false = Mojo::JSON->false;
         my $false = $json->false;

       False value, used because Perl has no native equivalent.

   true
         my $true = Mojo::JSON->true;
         my $true = $json->true;

       True value, used because Perl has no native equivalent.

SEE ALSO

       Mojolicious, Mojolicious::Guides, <http://mojolicio.us>.