docs/source/JSON3.html

   1 <!DOCTYPE html>
   2 <html>
   3 <head>
   4   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   5   <title>The source code</title>
   6   <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
   8   <style type="text/css">
   9     .highlight { display: block; background-color: #ddd; }
  10   </style>
  11   <script type="text/javascript">
  12     function highlight() {
  13       document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
  14     }
  15   </script>
  16 </head>
  17 <body onload="prettyPrint(); highlight();">
  18   <pre class="prettyprint lang-js"><span id='Ext-JSON'>/**
  19 </span> * @class Ext.JSON
  20  * Modified version of Douglas Crockford's JSON.js that doesn't
  21  * mess with the Object prototype
  22  * http://www.json.org/js.html
  23  * @singleton
  24  */
  25 Ext.JSON = new(function() {
  26     var useHasOwn = !! {}.hasOwnProperty,
  27     isNative = function() {
  28         var useNative = null;
  29
  30         return function() {
  31             if (useNative === null) {
  32                 useNative = Ext.USE_NATIVE_JSON &amp;&amp; window.JSON &amp;&amp; JSON.toString() == '[object JSON]';
  33             }
  34
  35             return useNative;
  36         };
  37     }(),
  38     pad = function(n) {
  39         return n &lt; 10 ? &quot;0&quot; + n : n;
  40     },
  41     doDecode = function(json) {
  42         return eval(&quot;(&quot; + json + ')');
  43     },
  44     doEncode = function(o) {
  45         if (!Ext.isDefined(o) || o === null) {
  46             return &quot;null&quot;;
  47         } else if (Ext.isArray(o)) {
  48             return encodeArray(o);
  49         } else if (Ext.isDate(o)) {
  50             return Ext.JSON.encodeDate(o);
  51         } else if (Ext.isString(o)) {
  52             return encodeString(o);
  53         } else if (typeof o == &quot;number&quot;) {
  54             //don't use isNumber here, since finite checks happen inside isNumber
  55             return isFinite(o) ? String(o) : &quot;null&quot;;
  56         } else if (Ext.isBoolean(o)) {
  57             return String(o);
  58         } else if (Ext.isObject(o)) {
  59             return encodeObject(o);
  60         } else if (typeof o === &quot;function&quot;) {
  61             return &quot;null&quot;;
  62         }
  63         return 'undefined';
  64     },
  65     m = {
  66         &quot;\b&quot;: '\\b',
  67         &quot;\t&quot;: '\\t',
  68         &quot;\n&quot;: '\\n',
  69         &quot;\f&quot;: '\\f',
  70         &quot;\r&quot;: '\\r',
  71         '&quot;': '\\&quot;',
  72         &quot;\\&quot;: '\\\\',
  73         '\x0b': '\\u000b' //ie doesn't handle \v
  74     },
  75     charToReplace = /[\\\&quot;\x00-\x1f\x7f-\uffff]/g,
  76     encodeString = function(s) {
  77         return '&quot;' + s.replace(charToReplace, function(a) {
  78             var c = m[a];
  79             return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
  80         }) + '&quot;';
  81     },
  82     encodeArray = function(o) {
  83         var a = [&quot;[&quot;, &quot;&quot;],
  84         // Note empty string in case there are no serializable members.
  85         len = o.length,
  86         i;
  87         for (i = 0; i &lt; len; i += 1) {
  88             a.push(doEncode(o[i]), ',');
  89         }
  90         // Overwrite trailing comma (or empty string)
  91         a[a.length - 1] = ']';
  92         return a.join(&quot;&quot;);
  93     },
  94     encodeObject = function(o) {
  95         var a = [&quot;{&quot;, &quot;&quot;],
  96         // Note empty string in case there are no serializable members.
  97         i;
  98         for (i in o) {
  99             if (!useHasOwn || o.hasOwnProperty(i)) {
 100                 a.push(doEncode(i), &quot;:&quot;, doEncode(o[i]), ',');
 101             }
 102         }
 103         // Overwrite trailing comma (or empty string)
 104         a[a.length - 1] = '}';
 105         return a.join(&quot;&quot;);
 106     };
 107
 108 <span id='Ext-JSON-method-encodeDate'>    /**
 109 </span>     * &lt;p&gt;Encodes a Date. This returns the actual string which is inserted into the JSON string as the literal expression.
 110      * &lt;b&gt;The returned value includes enclosing double quotation marks.&lt;/b&gt;&lt;/p&gt;
 111      * &lt;p&gt;The default return format is &quot;yyyy-mm-ddThh:mm:ss&quot;.&lt;/p&gt;
 112      * &lt;p&gt;To override this:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
 113 Ext.JSON.encodeDate = function(d) {
 114     return Ext.Date.format(d, '&quot;Y-m-d&quot;');
 115 };
 116      &lt;/code&gt;&lt;/pre&gt;
 117      * @param {Date} d The Date to encode
 118      * @return {String} The string literal to use in a JSON string.
 119      */
 120     this.encodeDate = function(o) {
 121         return '&quot;' + o.getFullYear() + &quot;-&quot;
 122         + pad(o.getMonth() + 1) + &quot;-&quot;
 123         + pad(o.getDate()) + &quot;T&quot;
 124         + pad(o.getHours()) + &quot;:&quot;
 125         + pad(o.getMinutes()) + &quot;:&quot;
 126         + pad(o.getSeconds()) + '&quot;';
 127     };
 128
 129 <span id='Ext-JSON-method-encode'>    /**
 130 </span>     * Encodes an Object, Array or other value
 131      * @param {Object} o The variable to encode
 132      * @return {String} The JSON string
 133      */
 134     this.encode = function() {
 135         var ec;
 136         return function(o) {
 137             if (!ec) {
 138                 // setup encoding function on first access
 139                 ec = isNative() ? JSON.stringify : doEncode;
 140             }
 141             return ec(o);
 142         };
 143     }();
 144
 145
 146 <span id='Ext-JSON-method-decode'>    /**
 147 </span>     * Decodes (parses) a JSON string to an object. If the JSON is invalid, this function throws a SyntaxError unless the safe option is set.
 148      * @param {String} json The JSON string
 149      * @param {Boolean} safe (optional) Whether to return null or throw an exception if the JSON is invalid.
 150      * @return {Object} The resulting object
 151      */
 152     this.decode = function() {
 153         var dc;
 154         return function(json, safe) {
 155             if (!dc) {
 156                 // setup decoding function on first access
 157                 dc = isNative() ? JSON.parse : doDecode;
 158             }
 159             try {
 160                 return dc(json);
 161             } catch (e) {
 162                 if (safe === true) {
 163                     return null;
 164                 }
 165                 Ext.Error.raise({
 166                     sourceClass: &quot;Ext.JSON&quot;,
 167                     sourceMethod: &quot;decode&quot;,
 168                     msg: &quot;You're trying to decode an invalid JSON String: &quot; + json
 169                 });
 170             }
 171         };
 172     }();
 173
 174 })();
 175 <span id='Ext-method-encode'>/**
 176 </span> * Shorthand for {@link Ext.JSON#encode}
 177  * @member Ext
 178  * @method encode
 179  * @alias Ext.JSON#encode
 180  */
 181 Ext.encode = Ext.JSON.encode;
 182 <span id='Ext-method-decode'>/**
 183 </span> * Shorthand for {@link Ext.JSON#decode}
 184  * @member Ext
 185  * @method decode
 186  * @alias Ext.JSON#decode
 187  */
 188 Ext.decode = Ext.JSON.decode;
 189
 190 </pre>
 191 </body>
 192 </html>