dojo/_base/json.js

• Provides:

  • dojo

• dojo.fromJson

  • type

    Function

  • parameters:
    • json: (typeof String)

      a string literal of a JSON item, for instance:
      `'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`

  • source: [view]
     return eval("(" + json + ")"); // Object
  • summary

    Parses a [JSON](http://json.org) string to return a JavaScript object.

  • description

    Throws for invalid JSON strings, but it does not use a strict JSON parser. It
    delegates to eval().  The content passed to this method must therefore come
    from a trusted source.

  • returns

    Object

• dojo._escapeString

  • type

    Function

  • parameters:
    • str: (typeof String)
  • source: [view]
     return ('"' + str.replace(/(["\\])/g, '\\$1') + '"').
      replace(/[\f]/g, "\\f").replace(/[\b]/g, "\\b").replace(/[\n]/g, "\\n").
      replace(/[\t]/g, "\\t").replace(/[\r]/g, "\\r"); // string
  • summary

    Adds escape sequences for non-visual characters, double quote and
    backslash and surrounds with double quotes to form a valid string
    literal.

• dojo.toJson

  • type

    Function

  • parameters:
    • it: (typeof Object)

      an object to be serialized. Objects may define their own
      serialization via a special "__json__" or "json" function
      property. If a specialized serializer has been defined, it will
      be used as a fallback.

    • prettyPrint: (typeof Boolean)

      if true, we indent objects and arrays to make the output prettier.
      The variable `dojo.toJsonIndentStr` is used as the indent string --
      to use something other than the default (tab), change that variable
      before calling dojo.toJson().

    • _indentStr: (typeof String)

      private variable for recursive calls when pretty printing, do not use.

  • source: [view]
     if(it === undefined){
      return "undefined";
     }
     var objtype = typeof it;
     if(objtype == "number" || objtype == "boolean"){
      return it + "";
     }
     if(it === null){
      return "null";
     }
     if(dojo.isString(it)){
      return dojo._escapeString(it);
     }
     // recurse
     var recurse = arguments.callee;
     // short-circuit for objects that support "json" serialization
     // if they return "self" then just pass-through...
     var newObj;
     _indentStr = _indentStr || "";
     var nextIndent = prettyPrint ? _indentStr + dojo.toJsonIndentStr : "";
     var tf = it.__json__||it.json;
     if(dojo.isFunction(tf)){
      newObj = tf.call(it);
      if(it !== newObj){
       return recurse(newObj, prettyPrint, nextIndent);
      }
     }
     if(it.nodeType && it.cloneNode){ // isNode
      // we can't seriailize DOM nodes as regular objects because they have cycles
      // DOM nodes could be serialized with something like outerHTML, but
      // that can be provided by users in the form of .json or .__json__ function.
      throw new Error("Can't serialize DOM nodes");
     }
    
    
     var sep = prettyPrint ? " " : "";
     var newLine = prettyPrint ? "\n" : "";
    
    
     // array
     if(dojo.isArray(it)){
      var res = dojo.map(it, function(obj){
       var val = recurse(obj, prettyPrint, nextIndent);
       if(typeof val != "string"){
        val = "undefined";
       }
       return newLine + nextIndent + val;
      });
      return "[" + res.join("," + sep) + newLine + _indentStr + "]";
     }
     /*
     // look in the registry
     try {
      window.o = it;
      newObj = dojo.json.jsonRegistry.match(it);
      return recurse(newObj, prettyPrint, nextIndent);
     }catch(e){
      // console.log(e);
     }
     // it's a function with no adapter, skip it
     */
     if(objtype == "function"){
      return null; // null
     }
     // generic object code path
     var output = [], key;
     for(key in it){
      var keyStr, val;
      if(typeof key == "number"){
       keyStr = '"' + key + '"';
      }else if(typeof key == "string"){
       keyStr = dojo._escapeString(key);
      }else{
       // skip non-string or number keys
       continue;
      }
      val = recurse(it[key], prettyPrint, nextIndent);
      if(typeof val != "string"){
       // skip non-serializable values
       continue;
      }
      // FIXME: use += on Moz!!
      //  MOW NOTE: using += is a pain because you have to account for the dangling comma...
      output.push(newLine + nextIndent + keyStr + ":" + sep + val);
     }
     return "{" + output.join("," + sep) + newLine + _indentStr + "}"; // String
  • summary

    Returns a [JSON](http://json.org) serialization of an object.

  • description

    Returns a [JSON](http://json.org) serialization of an object.
    Note that this doesn't check for infinite recursion, so don't do that!

  • returns

    null|String

  • example

    simple serialization of a trivial object
    
    	var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true });
    	doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);

  • example

    a custom serializer for an objects of a particular class:
    
    	dojo.declare("Furby", null, {
    		furbies: "are strange",
    		furbyCount: 10,
    		__json__: function(){
    		},
    	});

• dojo.toJsonIndentStr

  • summary

• dojo

  • type

    Object

  • summary