JSON

JavaScript Object Notation (commonly abbreviated JSON) is as it name suggests, a JavaScript syntax-based markup for providing dynamic data access to web pages & web applications (often used in session-based accesses to unique data via API). With JSON a session can range from the lifetime of a single (HTTP) request, or each time it a page is loaded - to actually storing the JSON longer term in a traditional SQL database as text or a JSON Blob, or, even purely JSON-based or NoSQL databases like MongoDB. JSON is particular useful for building AJAX type of functionality, but with an even simpler to parse data model in native JavaScript. The syntax and formatting rules were designed to specify a lightweight data-interchange format that is easy for humans to both read and write. As a core design goal, it is equally important for this format to be easy for machines to parse and generate as well, though.

PROS

Advocates of JSON claim it has most of the expressiveness of XML without the overhead that well-formedness of elements (redundant tag closures), comments and/or floating CDATA blocks all tend to bring. Another commonly praised characteristic is the ability to circumvent the same-origin policy when processing JSON data via JSONP (although JSONp as an approach itself has recently come under criticism for its own security vulnerabilities), however circumventing same-origin is impossible to do when using XML or other data formats without use of a server-side proxy or other hacks/tricks that may pose an even greater security risk that requires strict whitelist/blacklist and other security approaches to close off.

CONS

Critics of JSON have often cited its lack of server-side support and limitation to browser-based applications, which is increasingly less of an issue as many native language implementations and extensions emerge; they also note the inability to represent cyclical and/or referential data structures as a shortcoming, which library implementations^[1] as well as RDF/JSON (in response to inability to represent RDF) and similar initatives are trying to solve. Finally, an often debated subject is the safety of eval commonly used in processing JSON, and the potential security issues that can arise through the use of JSON in cross-domain requests (via JSONP). In the words of JSON's founder "eval is evil" and there are alternative approaches that don't rely on this, such as native parsing libraries (JSON is now native to most browsers) and HTML5 cross-domain messaging.

Specifications

The application/json Media Type for JavaScript Object Notation (JSON): http://www.ietf.org/rfc/rfc4627.txt

JSON

JSON spec (and large list of implementations/extensions): http://json.org

JSONP

See dedicated section: JSONp ^[2]

JSON Schema

Similar to XML Schema, JSON Schema proposes a structured data definition language for expressing allowed/expected elements of a JSON Object.

JSON Schema Proposal: http://json-schema.org/
jsonschema -- A JSON Schema Definition validator: http://code.google.com/p/jsonschema/
JSON Schema and inputEx (comparison): http://javascript.neyric.com/blog/2009/01/26/json-schema-and-inputex/
json-schema-2-pojo: http://www.jsonschema2pojo.org/ (Generate Plain Old Java Objects from JSON or JSON-Schema)
Also noteworthy is Google's Resource Discovery format (for JSON): http://code.google.com/apis/discovery/v1/reference.html#resource_discovery

RDF/JSON

There are a few different approaches to serializing RDF as JSON (or, mapping JSON into RDF). None have been formally standardized as yet, but some of the ongoing efforts include:

W3C - RDF/JSON spec: http://www.w3.org/2001/sw/wiki/index.php?title=RDF_Core_Work_Items#JSON ^[13]^[14]
RDF/JSON Specification (proposal by Talis): http://n2.talis.com/wiki/RDF_JSON_Specification
JRON: https://dvcs.w3.org/hg/rdf/raw-file/default/rdf-json/index.html ^[15]
BSON spec: http://bsonspec.org/

JSON-LD

JSON for Linking Data: http://www.json-ld.org/
The Origins of JSON-LD: http://manu.sporny.org/2014/json-ld-origins/

Language

Using native JSON: https://developer.mozilla.org/En/Using_native_JSON (Browser support: IE8+, FF 3.6+, Safari 5+, Chrome 9+, Opera 11+

Derivation

It is based on a subset of the JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is completely language independent but uses conventions that are familiar to programmers of the C-family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others. These properties make JSON an ideal data-interchange language.

Structure

JSON is built on two structures:

   * A collection of name/value pairs. In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array.
   * An ordered list of values. In most languages, this is realized as an array, vector, list, or sequence.

These are universal data structures. Virtually all modern programming languages support them in one form or another. It makes sense that a data format that is interchangable with programming languages also be based on these structures.

In JSON, they take on these forms:

An object is an unordered set of name/value pairs. An object begins with { (left brace) and ends with } (right brace). Each name is followed by : (colon) and the name/value pairs are separated by , (comma).

Grammar

object

   {}
   { members }

members

   pair
   pair , members

pair

   string : value

array

   []
   [ elements ]

elements

   value
   value , elements

value

   string
   number
   object
   array
   true
   false
   null

string

   ""
   " chars "

chars

   char
   char chars

char

   any-Unicode-character-
       except-"-or-\-or-
       control-character
   \"
   \\
   \/
   \b
   \f
   \n
   \r
   \t
   \u four-hex-digits

number

   int
   int frac
   int exp
   int frac exp

int

   digit
   digit1-9 digits
   - digit
   - digit1-9 digits

frac

   . digits

exp

   e digits

digits

   digit
   digit digits

e

   e
   e+
   e-
   E
   E+
   E-

^[16]

Security

JSON and Browser Security: http://yuiblog.com/blog/2007/04/10/json-and-browser-security/

EXAMPLES

Example 1

{
   "message":
            {
               "service":
                         {
                            "id": "BMI",
                            "endpoint": "/bmi/bus-interface/savoir-wrapper.php?bmi=24&height=1.75&weight=75&mode=json",
                            "parameter":
                                       [
                                         {"id": "bmi", "value": "24"},
                                         {"id": "height", "value": "179", "unit": "cm", "unit_type": "LENGTH"},
                                         {"id": "weight", "value": "88", "unit": "kg", "unit_type": "MASS"},
                                       ]
                         }
            }
}

(Equivalent XML):

<message>
  <service id="BMI" endpoint="/bmi/bus-interface/savoir-wrapper.php">
    <parameter id="bmi" value="27.5"/>
    <parameter name="height" value="179" unit="cm" unit_type="LENGTH"/>
    <parameter name="weight" value="88" unit="kg" unit_type="MASS"/>
  </service>
</message>

Example 2

Google AJAX (JSON) Search API: http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=Mobile+TV&rsz=large

{
    "responseData" : {
        "results" : [{
            "GsearchResultClass" : "GwebSearch",
            "unescapedUrl" : "http://www.wireless.att.com/learn/messaging-internet/mobile-tv/",
            "url" : "http://www.wireless.att.com/learn/messaging-internet/mobile-tv/",
            "visibleUrl" : "www.wireless.att.com",
            "cacheUrl" : "http://www.google.com/search?q\u003dcache:eBCoR4tgM24J:www.wireless.att.com",
            "title" : "AT\u0026amp;T \u003cb\u003eMobile TV\u003c/b\u003e®",
            "titleNoFormatting" : "AT\u0026amp;T Mobile TV®",
            "content" : "Tune in anytime 24/7 for prime time TV with \u003cb\u003eMobile TV\u003c/b\u003e from AT\u0026amp;T."
        },
        {
            "GsearchResultClass" : "GwebSearch",
            "unescapedUrl" : "http://en.wikipedia.org/wiki/Mobile_television",
            "url" : "http://en.wikipedia.org/wiki/Mobile_television",
            "visibleUrl" : "en.wikipedia.org",
            "cacheUrl" : "http://www.google.com/search?q\u003dcache:dEPdCpJUClkJ:en.wikipedia.org",
            "title" : "\u003cb\u003eMobile\u003c/b\u003e television - Wikipedia, the free encyclopedia",
            "titleNoFormatting" : "Mobile television - Wikipedia, the free encyclopedia",
            "content" : "\u003cb\u003eMobile TV\u003c/b\u003e is one of the features provided by many 3G phones. In 2005, South   Korea became the first country in the world to have \u003cb\u003emobile TV\u003c/b\u003e when it started   \u003cb\u003e...\u003c/b\u003e"
        }],
        "cursor" : {
            "pages" : [{
                "start" : "0",
                "label" : 1
            },
            {
                "start" : "8",
                "label" : 2
            },
            {
                "start" : "16",
                "label" : 3
            },
            {
                "start" : "24",
                "label" : 4
            },
            {
                "start" : "32",
                "label" : 5
            },
            {
                "start" : "40",
                "label" : 6
            },
            {
                "start" : "48",
                "label" : 7
            },
            {
                "start" : "56",
                "label" : 8
            }],
            "estimatedResultCount" : "65600000",
            "currentPageIndex" : 0,
            "moreResultsUrl" : "http://www.google.com/search?oe\u003dutf8\u0026ie\u003dutf8\u0026source\u003duds\u0026start\u003d0\u0026hl\u003den\u0026q\u003dMobile+TV"
        }
    },
    "responseDetails" : null,
    "responseStatus" : 200
}

Parsing the results in JavaScript (with the evil of eval):

 <script>
   var json =  eval('(' + jsonText + ')');
   result = json.responseData.results[1].url;
   document.write(result);
 </script>

Parsing the results in JavaScript (without eval, using json2.js by Douglas Crockford)

 <script type="text/javascript" src="https://github.com/douglascrockford/JSON-js/raw/master/json2.js"></script>
 <script>
   var json = JSON.parse(jsonText);
   result = json.responseData.results[1].url; 
 </script>

^[17]

Tools

JSON Viewer: http://jsonviewer.codeplex.com/^[18]
Online JSON parser: http://json.parser.online.fr/
JSONpath - expression tool: https://jsonpath.curiousconcept.com/ (evaluate)

JQ

JSON Query tool (JQ): https://stedolan.github.io/jq/^[19]
JQ Playground: https://jqplay.org/ (JSON Query tool sandbox to test parsing of values from a given JSON dataset)

Validator

JSONlint - JSON Validator: http://jsonlint.com/

Editor

Web-based JSON editor: http://www.thomasfrank.se/json_editor.html
JSON Diff (apart from diff function, also gives a tree view of JSON): http://tlrobinson.net/projects/javascript-fun/jsondiff/
JSON Editor online: www.jsoneditoronline.org
JSON Editor: http://braincast.nl/samples/jsoneditor/

Converter

Conversion from JS Object to JSON String and back: http://ajaxify.com/run/json/
BadgerFish -- XML to JSON (Java): http://www.sklar.com/badgerfish/ (convention for translating an XML document into a JSON object)
XML2JSON.js – an online converter (JavaScript): http://www.thomasfrank.se/xml_to_json.html
JSON-to-HTML converter: http://json.bloople.net/
JSON formatting: http://jsonformat.com (convert JSON to another format defined by you)

^[20]