Java Script Object Notation

JSON (JavaScript Object Notation) is a lightweight data-interchange format, with language bindings for CeeLanguage, CeeSharp, JavaLanguage, JavaScript, ObjectiveCaml, PhpLanguage, SmlLanguage, RubyLanguage. It basically uses Python's syntax for dictionaries and lists, and so it works in PythonLanguage, too (but watch out for true, false, and null).

Also watch out for cyclical structures. Some tuning of the json.parse() method (see below) is needed.

JSON-RPC is a simple RemoteProcedureCall protocol similar to XmlRpc although it uses the lightweight JSON format instead of XML. Lightweight JSON-RPC clients have been implemented in JavaScript, making it possible to call remote methods from a WebBrowser without reloading the page. Think 'Google Suggest' (and AjaxWebApplications).

The definitive reference to JSON is http://www.json.org/

Pros:

Better browser support than AJAX
More succinct than XML, so it takes less bandwidth
It's a direct object representation, so it should be easier to reconstitute in the JavaScript code

Cons:

Parsing JSON in JavaScript *may* be slower than parsing XML in a native browser for some data sets
XML is better supported by web frameworks
XML is better at encoding than JavaScript

JSON is very close in syntax to a subset of YamlAintMarkupLanguage, with almost the same InfoSet.

JSON-LD (see http://json-ld.org/ ) is JSON for linking data.

For illustration, here is a naive PythonLanguage class for handling JSON data. Because according to the grammar, a JSON structure is always enclosed by curly braces, it is essentially a dict.

 from pprint import pprint
 from StringIO import StringIO

 true, false = True, False
 null = None

 class JSON(dict):
    """Naive JSON class.

    A safer __init__ method would parse the JSON string rather than 
    do eval. A smarter __str__ method would perform more careful 
    matches of True, False, and None. Per the JSON spec, the __str__ 
    method should output string values in double quotes, but this 
    outputs single quotes. Also, a correct implementation would use 
    Unicode. 
    """

    def __init__(self, arg={}):
        """JSON(dictOrString)"""
        try:
            e = eval(arg)
            self.update(e)
        except TypeError:
            self.update(arg)

    def __str__(self):
        """return pretty print of JSON object"""
        stream = StringIO()
        pprint(dict(self), stream)
        s = stream.getvalue().strip()
        s = s.replace('True', 'true')
        s = s.replace('False', 'false')
        s = s.replace('None', 'null')
        return s

 obj = {"bindings": [
    {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"},
    {"ircEvent": "PRIVMSG", "method": "deleteURI", "regex": "^delete.*"},
    {"ircEvent": "PRIVMSG", "method": "randomURI", "regex": "^random.*"}
    ], "foo": true, "bar": null
 }

 print JSON()
 print JSON(obj)
 json = JSON(str(obj))
 for binding in json['bindings']: print binding['method']

outputs...

 {}
 {'bar': null,
  'bindings': [{'ircEvent': 'PRIVMSG',
                'method': 'newURI',
                'regex': '^http://.*'},
               {'ircEvent': 'PRIVMSG',
                'method': 'deleteURI',
                'regex': '^delete.*'},
               {'ircEvent': 'PRIVMSG',
                'method': 'randomURI',
                'regex': '^random.*'}],
  'foo': true}
 newURI
 deleteURI
 randomURI

See the JSON home page for a link to a much smarter PythonLanguage module.

Question: How do you efficiently decode JSON in JavaScript without potentially running arbitrary code? Just eval'ing a string would let a sender create or call functions. Does JavaScript have the concept of safe interpreters? Or must a parser for JSON be written in JavaScript.

Answer: Use json.parse(text), as follows (from http://www.json.org):

 /*
    Parse a JSON text, producing a JavaScript value.
    It returns false if there is a syntax error.
 */
    parse: function (text) {
        try {
            return !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
                    text.replace(/"(\\.|[^"\\])*"/g, ''))) &&
                eval('(' + text + ')');
        } catch (e) {
            return false;
        }
    }
 };

See AlternativesToXml. See also CubicWeb.

CategoryInformation CategorySemanticWeb