浅析Js(Jquery)中,字符串与JSON格式互相转换的示例(直接运行实例)_jquery

/*
    http://www.JSON.org/json2.js
    公共领域。
    没有明示或暗示的保证。使用风险自负。
    请参阅 http://www.JSON.org/js.html
    在部署之前应缩小此代码。
    请参阅 http://javascript.crockford.com/jsmin。 html
    使用您自己的副本。从您无法控制的服务器加载代码是极其不明智的。
    此文件创建一个全局 JSON 对象，其中包含两个方法：stringify
    和 parse。
        JSON.stringify(value, replacementr, space )
            value       任何 JavaScript 值，通常是对象或数组。
            替换符    一个可选参数，用于确定对象
                        对象值的字符串化方式。它可以是
                        函数或字符串数​​组。
            空格       一个可选参数，指定嵌套结构的缩进
                        。如果省略，文本将
                        被打包，没有额外的空格。如果它是一个数字，
                        它将指定每个
                        级别缩进的空格数。如果它是字符串（例如 't' 或 ' '），
                        它包含用于在每个级别缩进的字符。
            此方法从 JavaScript 值生成 JSON 文本。
             当对象找到 value 后，如果对象包含 toJSON
            方法，则会调用其 toJSON 方法，并将结果
            字符串化。 toJSON 方法不会序列化：它返回由应序列化的名称/值对表示的
            值，
            如果不应该序列化任何内容，则返回未定义的值。 toJSON 方法
            将传递与值关联的键，这将
            绑定到值
            例如，这会将日期序列化为 ISO 字符串。
                Date.prototype.toJSON = function (key) {
                    function f(n) {
                        // 将整数格式化为至少有两位数。
                        return n                     }
                    return this.getUTCFullYear()   '-'
                        f(this.getUTCMonth() 1) '-'
                         f(this.get UTCDate())      'T'
                         f(this.getUTCHours( ))     ':'
                         f(this.getUTCMinutes())   ':'
                         f(this.getUTCSeconds())   'Z';
                };
            您可以提供可选的替换方法。它将传递每个成员的
            键和值，并将其绑定到包含的
            对象。从您的方法返回的值将被序列化
           。如果您的方法返回未定义，则该成员将
            被排除在序列化之外。
            如果replacer 参数是字符串数组，则它将
            用于选择要序列化的成员。它会过滤结果
           ，以便只有具有替换数组中列出的键的成员
            字符串化。
            没有 JSON 表示形式的值，例如未定义或
            函数，将不会被序列化。对象中的此类值将被删除
           ；在数组中，它们将被替换为 null。您可以使用
            替换函数将其替换为 JSON 值。
            JSON.stringify(undefined) 返回未定义。
            可选的 space 参数生成
            值的字符串化，并用换行符填充和缩进，使其
            更易于阅读。
            如果空格参数是非空字符串，则该字符串将
            用于缩进。如果 space 参数是数字，则
            缩进将是那么多空格。
            示例：
            text = JSON.stringify(['e', {pluribus: 'unum'}]);
            // 文本为 '["e",{"pluribus":"unum"}]'
            text = JSON.stringify(['e', {pluribus: 'unum'}], null, 't ');
            // 文本为 '[nt"e",nt{ntt"pluribus": "unum"nt}n]'
            text = JSON.stringify([new Date()], function ( key, value) {
                返回 this[key] instanceof Date ?
                    'Date(' this[key] ')' : value;
            });
            // text is '["Date(---current time---)"]'
        JSON.parse(text, reviver)
            此方法解析 JSON 文本以生成对象或数组。
            它可以抛出 SyntaxError 异常。
            可选的 reviver 参数是一个可以过滤和
            转换结果的函数。它接收每个键和值，
            并使用其返回值代替原始值。
            如果它返回收到的内容，则结构不会被修改。
            如果它返回未定义，则成员已删除。
            示例：
            // 解析文本。看起来像 ISO 日期字符串的值将
            // 转换为 Date 对象。
            myData = JSON.parse(text, function (key, value) {
                var a;
                if (typeof value === '字符串') {
                    a =
/^(d{4})-(d{2})-(d{2})T(d{2}):(d{2 }):(d{2}(?:.d*)?)Z$/.exec(value);
                    if (a) {
                        return new Date(Date.UTC( a[1], a[2] - 1, a[3], a[4],
                            a[5], a[6]));
                   }
                }
                返回值;
            } );
            myData = JSON.parse('["日期(09/09/2001)"]', function (key, value) {
                var d;
                if (typeof value === ' string' &&
                        value.slice(0, 5) === '日期(' &&
                       value.slice(-1) === ')') {
                    d = 新日期（值。 slice(5, -1));
                    if (d) {
                       return d;
                    }
                }
                返回值;
            });
    这是一个参考实现。您可以自由复制、修改或
    重新分发。
*/
/*jslint 邪恶: true, strict: false, regexp: false */
/*members "", "b" , "t", "n", "f", "r", """, JSON, "\", apply,
    调用, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
    getUTCMinutes, getUTCMonth, getUTCSeconds , hasOwnProperty, join,
    lastIndex, length, parse, prototype, Push, Replace, slice, stringify,
    test, toJSON, toString, valueOf
*/
// 仅创建 JSON 对象我们在闭包中创建
//方法以避免创建全局变量。
if (!this.JSON2)
{
    this.JSON2 = {};
}
(function () {
    "use strict";
    function f(n) {
        // 将整数格式化为至少有两位数。
        return n     }
    if (typeof Date.prototype.toJSON !== 'function') {
        Date.prototype.toJSON = function (key) {
            return isFinite( this.valueOf()) ?
                   this.getUTCFullYear()   '-'
                 f(this.getUTCMonth() 1) '-'
                 f(this.getUTCDate())      “T”
f(this.getUTCHours())     ':'
                 f(this.getUTCMinutes())   ':'
                 f(this.getUTCSeconds())   'Z' : null;
        };
String.prototype.toJSON =
        Number.prototype.toJSON =
        Boolean.prototype.toJSON = function (key) {
            return this.valueOf();
        };
    }
    var cx = /[u0000u00adu0600-u0604u070fu17b4u17b5u200c-u200fu2028-u202fu2060-u206fuffeffufff0-uffff]/g,
        可转义 = /[\"x00-x1fx7f-x9 fu00adu0600-u0604u070fu17b4u17b5u200c-u200fu2028-u202fu2060-u206fufeffufff0-uffff]/g,
        间隙,
        缩进,
        meta = {    // 字符替换表
            'b': '\b',
            '\t',
            'n ': '\n',
            'f': '\f',
            'r': '\r',
            '"' : '\"',
            '\': '\\'
        },
        代表;
    function quote(string) {
        escapable.lastIndex = 0;
        return escapable.test(string) ?
            '"' 字符串.replace(可转义, function (a) {
                var c = meta[a];
                return typeof c === 'string' ? c :
                    '\u' ('0000' a.charCodeAt(0).toString(16)).slice(-4);
            }) '"' :
            '"' 字符串 '" ';
    }
    function str(key,holder) {
        var i,          // 循环计数器。
            k,          // 成员键。
            v,          // 成员值。
            长度，
            心灵 = 间隙，
            部分，
            value =holder[key];
        if (value && typeof value === 'object' &&
                typeof value.toJSON === '功能') {
            value = value.toJSON(key);
        }
        if (typeof rep === 'function') {
            value =rep.call(holder, key, value);
        }
        switch (typeof value) {
        case 'string':
            return quote(value);
        case 'number':
            return isFinite(value) ? String(value) : 'null';
        case 'boolean':
        case 'null':
            return String(value);
        case 'object':
            if (!value) {
                return 'null';
            }
            间隙 = 缩进;
            部分 = [];
            if (Object.prototype.toString.apply(value ) === '[对象数组]') {
                length = value.length;
                for (i = 0; i                    partial[i] = str(i, value) || 'null';
                }
                v =partial.length === 0 ? '[]' :
                    间隙？ '[n' 间隙
                           partial.join(',n' 间隙) 'n'
                               头脑 ']' :
                          '['partial.join(',') ']';
间隙=头脑;
                return v;
            }
            if (rep && typeof rep === 'object') {
                length = rep.length;
                for (i = 0; i                     k = rep[i];
                   if (typeof k === 'string') {
                       v = str(k, value);
                        if (v) {
                           partial.push(quote(k ) (间隙 ? ': ' : ':') v);
                       }
                   }
                }
            } else {
                for (k 值) {
                    if (Object. hasOwnProperty.call(value, k)) {
                        v = str(k, value);
                       if (v) {
                            部分。推（引用（k）（间隙？'：'：'： ') v);
                       }
                   }
               }
            }
           v = 部分. 长度 === 0 ? '{}' :
                间隙？ '{n'间隙partial.join（'，n'间隙）'n'
                       头脑'}'：'{'partial.join（'，'）'}';
           间隙=头脑;
            return v;
        }
    }
    if (typeof JSON2.stringify !== 'function') {
        JSON2.stringify = 函数（值、替换符、空格）{
            var i ;
            间隙 = '';
             缩进 = '';
            if (typeof space === 'number') {
                for (i = 0; i                     缩进 = ' ';
                }
            } else if (typeof space === 'string') {
                缩进 = 空格;
           }
           rep = 替换器;
            if (替换器 && 替换器类型 !== '函数' &&
                    (替换器类型 !== '对象' ||
                     typeof replacement.length !== 'number' )) {
                throw new Error('JSON2.stringify');
            }
            return str('', {'': value});
        };
    }
if (typeof JSON2.parse !== 'function') {
        JSON2.parse = function (text, reviver) {
            var j;
            function walk(holder, key) {
                var k , v, value =holder[key];
                if (value && typeof value === 'object') {
                    for (k in value) {
                        if (Object.hasOwnProperty.call （值， k)) {
                            v = walk(value, k);
                          if (v !== undefined) {
                               value[k] = v;
                            } else {
                                删除值[ k];
                            }
                       }
                    }
                }
                return reviver.call(holder, key, value);
            }
            text = String(text);
            cx.lastIndex = 0;
            if (cx.test(text)) {
                text = text.replace(cx, function (a) {
                    return '\u'
                        ('0000 ' a.charCodeAt(0).toString(16)).slice(-4);
                });
            }
            if (/^[],:{}s]*$/
.test(text.replace(/\(?:["\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
.replace(/"[^"\nr]*"|true|false|null|-?d (?:.d*)?(?:[eE][ -]?d )?/g, ']')
.replace(/(?:^|:|,)(?:s*[) /g, ''))) {
                j = eval('(' text ')');
                return typeof reviver === 'function' ?
                    walk({'': j}, '') : j;
            }
            throw new SyntaxError('JSON2.parse');
        };
    }
}());

  
   
        var a = '{ "name": "tom", "sex": "男", "age": "24" }';    // 用于组成json的字符串;
        alert("用于组成json的字符串:【" a "】");
        var b = JSON2.parse(a);   // 把字符串a转换为json格式b
        var c = JSON2.stringify(a); //把json格式b转换为字符串c
        alert("转换后的字符串：【" c "】");