浅析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+"】");