淺析Js(Jquery)中,字符串與JSON格式互相轉換的示例

這幾天遇到了json格式在JS和Jquey的環境中需要相互轉換在網上查了一下大多為缺胳膊少腿也許咱是菜鳥吧終於測試成功後還是給初學者們一個實例吧  

　　首先准備新建一個js文件以下是JSONjs的內容把內容拷到js文件中以便調用

復制代碼 代碼如下:
/*
   
    Public Domain
    NO WARRANTY EXPRESSED OR IMPLIED USE AT YOUR OWN RISK
    See
    This code should be minified before deployment
    See
    USE YOUR OWN COPY IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
    NOT CONTROL
    This file creates a global JSON object containing two methods: stringify
    and parse
        JSONstringify(value replacer space)
            value       any JavaScript value usually an object or array
            replacer    an optional parameter that determines how object
                        values are stringified for objects It can be a
                        function or an array of strings
            space       an optional parameter that specifies the indentation
                        of nested structures If it is omitted the text will
                        be packed without extra whitespace If it is a number
                        it will specify the number of spaces to indent at each
                        level If it is a string (such as t or  )
                        it contains the characters used to indent at each level
            This method produces a JSON text from a JavaScript value
            When an object value is found if the object contains a toJSON
            method its toJSON method will be called and the result will be
            stringified A toJSON method does not serialize: it returns the
            value represented by the name/value pair that should be serialized
            or undefined if nothing should be serialized The toJSON method
            will be passed the key associated with the value and this will be
            bound to the value
            For example this would serialize Dates as ISO strings
                DateprototypetoJSON = function (key) {
                    function f(n) {
                        // Format integers to have at least two digits
                        return n < ? + n : n;
                    }
                    return thisgetUTCFullYear()   + +
                         f(thisgetUTCMonth() + ) + +
                         f(thisgetUTCDate())      + T +
                         f(thisgetUTCHours())     + : +
                         f(thisgetUTCMinutes())   + : +
                         f(thisgetUTCSeconds())   + Z;
                };
            You can provide an optional replacer method It will be passed the
            key and value of each member with this bound to the containing
            object The value that is returned from your method will be
            serialized If your method returns undefined then the member will
            be excluded from the serialization
            If the replacer parameter is an array of strings then it will be
            used to select the members to be serialized It filters the results
            such that only members with keys listed in the replacer array are
            stringified
            Values that do not have JSON representations such as undefined or
            functions will not be serialized Such values in objects will be
            dropped; in arrays they will be replaced with null You can use
            a replacer function to replace those with JSON values
            JSONstringify(undefined) returns undefined
            The optional space parameter produces a stringification of the
            value that is filled with line breaks and indentation to make it
            easier to read
            If the space parameter is a nonempty string then that string will
            be used for indentation If the space parameter is a number then
            the indentation will be that many spaces
            Example:
            text = JSONstringify([e {pluribus: unum}]);
            // text is ["e"{"pluribus":"unum"}]
            text = JSONstringify([e {pluribus: unum}] null t);
            // text is [nt"e"nt{ntt"pluribus": "unum"nt}n]
            text = JSONstringify([new Date()] function (key value) {
                return this[key] instanceof Date ?
                    Date( + this[key] + ) : value;
            });
            // text is ["Date(current time)"]
        JSONparse(text reviver)
            This method parses a JSON text to produce an object or array
            It can throw a SyntaxError exception
            The optional reviver parameter is a function that can filter and
            transform the results It receives each of the keys and values
            and its return value is used instead of the original value
            If it returns what it received then the structure is not modified
            If it returns undefined then the member is deleted
            Example:
            // Parse the text Values that look like ISO date strings will
            // be converted to Date objects
            myData = JSONparse(text function (key value) {
                var a;
                if (typeof value === string) {
                    a =
/^(d{})(d{})(d{})T(d{}):(d{}):(d{}(?:d*)?)Z$/exec(value);
                    if (a) {
                        return new Date(DateUTC(+a[] +a[] +a[] +a[]
                            +a[] +a[]));
                    }
                }
                return value;
            });
            myData = JSONparse(["Date(//)"] function (key value) {
                var d;
                if (typeof value === string &&
                        valueslice( ) === Date( &&
                        valueslice() === )) {
                    d = new Date(valueslice( ));
                    if (d) {
                        return d;
                    }
                }
                return value;
            });
    This is a reference implementation You are free to copy modify or
    redistribute
*/
/*jslint evil: true strict: false regexp: false */
/*members "" "b" "t" "n" "f" "r" """ JSON "" apply
    call charCodeAt getUTCDate getUTCFullYear getUTCHours
    getUTCMinutes getUTCMonth getUTCSeconds hasOwnProperty join
    lastIndex length parse prototype push replace slice stringify
    test toJSON toString valueOf
*/
// Create a JSON object only if one does not already exist We create the
// methods in a closure to avoid creating global variables
if (!thisJSON)
{
    thisJSON = {};
}
(function () {
    "use strict";
    function f(n) {
        // Format integers to have at least two digits
        return n < ? + n : n;
    }
    if (typeof DateprototypetoJSON !== function) {
        DateprototypetoJSON = function (key) {
            return isFinite(thisvalueOf()) ?
                   thisgetUTCFullYear()   + +
                 f(thisgetUTCMonth() + ) + +
                 f(thisgetUTCDate())      + T +
                 f(thisgetUTCHours())     + : +
                 f(thisgetUTCMinutes())   + : +
                 f(thisgetUTCSeconds())   + Z : null;
        };
        StringprototypetoJSON =
        NumberprototypetoJSON =
        BooleanprototypetoJSON = function (key) {
            return thisvalueOf();
        };
    }
    var cx = /[uuaduuufububucufuufuufufeffufffuffff]/g
        escapable = /["xxfxfxfuaduuufububucufuufuufufeffufffuffff]/g
        gap
        indent
        meta = {    // table of character substitutions
            b: b
            t: t
            n: n
            f: f
            r: r
            " : "
            : \
        }
        rep;
    function quote(string) {
        escapablelastIndex = ;
        return escapabletest(string) ?
            " + stringreplace(escapable function (a) {
                var c = meta[a];
                return typeof c === string ? c :
                    u + ( + acharCodeAt()toString())slice();
            }) + " :
            " + string + ";
    }
    function str(key holder) {
        var i          // The loop counter
            k          // The member key
            v          // The member value
            length
            mind = gap
            partial
            value = holder[key];
        if (value && typeof value === object &&
                typeof valuetoJSON === function) {
            value = valuetoJSON(key);
        }
        if (typeof rep === function) {
            value = repcall(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;
            }
            gap += indent;
            partial = [];
            if (ObjectprototypetoStringapply(value) === [object Array]) {
                length = valuelength;
                for (i = ; i < length; i += ) {
                    partial[i] = str(i value) || null;
                }
                v = partiallength === ? [] :
                    gap ? [n + gap +
                            partialjoin(n + gap) + n +
                                mind + ] :
                          [ + partialjoin() + ];
                gap = mind;
                return v;
            }
            if (rep && typeof rep === object) {
                length = replength;
                for (i = ; i < length; i += ) {
                    k = rep[i];
                    if (typeof k === string) {
                        v = str(k value);
                        if (v) {
                            partialpush(quote(k) + (gap ? : : :) + v);
                        }
                    }
                }
            } else {
                for (k in value) {
                    if (ObjecthasOwnPropertycall(value k)) {
                        v = str(k value);
                        if (v) {
                            partialpush(quote(k) + (gap ? : : :) + v);
                        }
                    }
                }
            }
            v = partiallength === ? {} :
                gap ? {n + gap + partialjoin(n + gap) + n +
                        mind + } : { + partialjoin() + };
            gap = mind;
            return v;
        }
    }
    if (typeof JSONstringify !== function) {
        JSONstringify = function (value replacer space) {
            var i;
            gap = ;
            indent = ;
            if (typeof space === number) {
                for (i = ; i < space; i += ) {
                    indent += ;
                }
            } else if (typeof space === string) {
                indent = space;
            }
            rep = replacer;
            if (replacer && typeof replacer !== function &&
                    (typeof replacer !== object ||
                     typeof replacerlength !== number)) {
                throw new Error(JSONstringify);
            }
            return str( {: value});
        };
    }
    if (typeof JSONparse !== function) {
        JSONparse = 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 (ObjecthasOwnPropertycall(value k)) {
                            v = walk(value k);
                            if (v !== undefined) {
                                value[k] = v;
                            } else {
                                delete value[k];
                            }
                        }
                    }
                }
                return revivercall(holder key value);
            }
            text = String(text);
            cxlastIndex = ;
            if (cxtest(text)) {
                text = textreplace(cx function (a) {
                    return u +
                        ( + acharCodeAt()toString())slice();
                });
            }
            if (/^[]:{}s]*$/
test(textreplace(/(?:["/bfnrt]|u[afAF]{})/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(JSONparse);
        };
    }
}());

　　
第二調用頁的內容
注意調用js文件的路徑需要自己調整這點如果不會那就別再繼續看了

復制代碼 代碼如下:

　　
   <script src="/jquery/jqueryminjs" type="text/javascript"></script>
    <script src="/jsonjs" type="text/javascript"></script>
        var a = { "name": "tom" "sex": "男" "age": "" };    // 用於組成json的字符串;
        alert("用於組成json的字符串:【"+a+"】");
        var b = JSONparse(a);   // 把字符串a轉換為json格式b
        var c = JSONstringify(a); //把json格式b轉換為字符串c
        alert("轉換後的字符串【"+c+"】");

From:http://tw.wingwit.com/Article/program/Java/JSP/201311/20282.html