【www.guakaob.com--体育高考】
javascriptjson解析器篇一
《javaScript解析json数据》
JSON （JavaScript Object Notation）一种简单的数据格式，比xml更轻巧。 JSON 是 JavaScript 原生格式，这意味着在 JavaScript 中处理 JSON 数据不需要任何特殊的 API 或工具包。JSON的规则很简单： 对象是一个无序的“‘名称/值’对”集合。一个对象以“{”（左括号）开始，“}”（右括号）结束。每个“名称”后跟一个“:”（冒号）；“‘名称/值’ 对”之间使用“,”（逗号）分隔。具体细节参考举个简单的例子：js 代码1. function showJSON() { 2. var user = 3. { 4. "username":"andy", 5. "age":20, 6. "info": { "tel": "123456", "cellphone": "98765"}, 7. "address": 8. [ 9. {"city":"beijing","postcode":"222333"}, 10. {"city":"newyork","postcode":"555666"} 11. ] 12. } 13. 14. alert(user.username); 15. alert(user.age); 16. alert(user.info.cellphone); 17. alert(user.address[0].city); 18. alert(user.address[0].postcode); 19. } 这表示一个user对象，拥有username, age, info, address 等属性。同样也可以用JSON来简单的修改数据，修改上面的例子js 代码1. function showJSON() { 2. var user = 3. { 4. "username":"andy", 5. "age":20, 6. "info": { "tel": "123456", "cellphone": "98765"}, 7. "address": 8. [ 9. {"city":"beijing","postcode":"222333"}, 10. {"city":"newyork","postcode":"555666"} 11. ] 12. } 13. 14. alert(user.username); 15. alert(user.age); 16. alert(user.info.cellphone); 17. alert(user.address[0].city); 18. alert(user.address[0].postcode); 19. 20. user.username = "Tom"; 21. alert(user.username); 22. } JSON提供了json.js包，下载后，将其引入然后就可以简单的使用object.toJSONString()转换成JSON数据。js 代码1. function showCar() { 2. var carr = new Car("Dodge", "Coronet R/T", 1968, "yellow"); 3. alert(carr.toJSONString()); 4. } 5. 6. function Car(make, model, year, color) { 7. this.make = make; 8. this.model = model; 9. this.year = year; 10. this.color = color; 11. } 可以使用eval来转换JSON字符到Objectjs 代码1. function myEval() { 2. var str = '{ "name": "Violet", "occupation": "character" }'; 3. var obj = eval('(' + str + ')'); 4. alert(obj.toJSONString()); 5.
} 或者使用parseJSON()方法js 代码1. function myEval() { 2. var str = '{ "name": "Violet", "occupation": "character" }'; 3. var obj = str.parseJSON(); 4. alert(obj.toJSONString()); 5. } 下面使用prototype写一个JSON的ajax例子。先写一个servlet (我的是servlet.ajax.JSONTest1.java)就写一句话java 代码1. response.getWriter().print("{ \"name\": \"Violet\", \"occupation\": \"character\" }"); 再在页面中写一个ajax的请求js 代码1. function sendRequest() { 2. var url = "/MyWebApp/JSONTest1"; 3. var mailAjax = new Ajax.Request( 4. url, 5. { 6. method: 'get', 7. onComplete: jsonResponse 8. } 9. ); 10. } 11. 12. function jsonResponse(originalRequest) { 13. alert(originalRequest.responseText); 14. var myobj = originalRequest.responseText.parseJSON(); 15. alert(myobj.name); 16. } prototype-1.5.1.js中提供了JSON的方法，String.evalJSON(), 可以不使用json.js, 修改上面的方法js 代码1. function jsonResponse(originalRequest) { 2. alert(originalRequest.responseText); 3. var myobj = originalRequest.responseText.evalJSON(true); 4. alert(myobj.name); 5. } JSON还提供了java的jar包 API也很简单，下面举个例子在javascript中填加请求参数js 代码1. function sendRequest() { 2. var carr = new Car("Dodge", "Coronet R/T", 1968, "yellow"); 3. var pars = "car=" + carr.toJSONString(); 4. 5. var url = "/MyWebApp/JSONTest1"; 6. var mailAjax = new Ajax.Request( 7. url, 8. { 9. method: 'get', 10. parameters: pars, 11. onComplete: jsonResponse 12. } 13. ); 14. } 使用JSON请求字符串就可以简单的生成JSONObject并进行解析,修改servlet添加JSON的处理(要使用json.jar)java 代码1. private void doService(HttpServletRequest request, HttpServletResponse response) throws IOException { 2. String s3 = request.getParameter("car"); 3. try { 4. JSONObject jsonObj = new JSONObject(s3); 5. System.out.println(jsonObj.getString("model")); 6. System.out.println(jsonObj.getInt("year")); 7. } catch (JSONException e) { 8. e.printStackTrace(); 9. } 10. response.getWriter().print("{ \"name\": \"Violet\", \"occupation\": \"character\" }"); 11. } 同样可以使用JSONObject生成JSON字符串，修改servletjava 代码1. private void doService(HttpServletRequest request, HttpS
ervletResponse response) throws IOException { 2. String s3 = request.getParameter("car"); 3. try { 4. JSONObject jsonObj = new JSONObject(s3); 5. System.out.println(jsonObj.getString("model")); 6. System.out.println(jsonObj.getInt("year")); 7. } catch (JSONException e) { 8. e.printStackTrace(); 9. } 10. 11. JSONObject resultJSON = new JSONObject(); 12. try { 13. resultJSON.append("name", "Violet") 14. .append("occupation", "developer") 15. .append("age", new Integer(22)); 16. System.out.println(resultJSON.toString()); 17. } catch (JSONException e) { 18. e.printStackTrace(); 19. } 20. response.getWriter().print(resultJSON.toString()); 21. } js 代码1. function jsonResponse(originalRequest) { 2. alert(originalRequest.responseText); 3. var myobj = originalRequest.responseText.evalJSON(true); 4. alert(myobj.name); 5. alert(myobj.age); 6. } 参考使用JSONJSON也就是JavaScript Object Notation，是一个描述数据的轻量级语法。JSON的优雅是因为它是JavaScript语言的一个子集。接下来你将看到它为什么如此重要。首先，来比较一下JSON和XML语法。JSON和XML都使用结构化方法描述数据。例如一个地址簿应用程序可以提供用来产生XML格式的地址卡的web服务：<?xml version='1.0' encoding='UTF-8'?><card><fullname>Sean Kelly</fullname><org>SK Consulting</org><emailaddrs><address type='work'>kelly@seankelly.biz</address><address type='home' pref='1'>kelly@seankelly.tv</address></emailaddrs><telephones><tel type='work' pref='1'>+1 214 555 1212</tel><tel type='fax'>+1 214 555 1213</tel><tel type='mobile'>+1 214 555 1214</tel></telephones><addresses><address type='work' format='us'>1234 Main StSpringfield, TX 78080-1216</address><address type='home' format='us'>5678 Main StSpringfield, TX 78080-1316</address></addresses><urls><address type='work'><address type='home'></urls></card>使用JSON, 形式如下:{"fullname": "Sean Kelly","org": "SK Consulting","emailaddrs": [{"type": "work", "value": "kelly@seankelly.biz"},{"type": "home",
"pref": 1, "value": "kelly@seankelly.tv"}],"telephones": [{"type": "work", "pref": 1, "value": "+1 214 555 1212"},{"type": "fax", "value": "+1 214 555 1213"},{"type": "mobile", "value": "+1 214 555 1214"}],"addresses": [{"type": "work", "format": "us","value": "1234 Main StnSpringfield, TX 78080-1216"},{"type": "home", "format": "us","value": "5678 Main StnSpringfield, TX 78080-1316"}],"urls": [{"type": "work", "value": "{"type": "home", "value": "]}如你所看到的，JSON有结构化的嵌套数据元素，这一点和XML相似。JSON也是基于文本的，XML也是如此。两者都使用Unicode。 JSON和XML都很容易阅读。主观上，JSON更清晰，冗余更少。JSON WEB站点严格地描述了JSON语法，目前就是这样的。它确实是一个简单的小语言！ XML确实适合标记文档，但是JSON是数据交互的理想格式。每个JSON文档描述了一个这样一个对象，该对象包含有：嵌套对象、数组、字符串、数字、布 尔值或空值。在这些地址卡例子代码中，JSON版本是更轻量级的，只占用了682字节的空间，而XML版本需要744字节空间。尽管这不是一个可观的节省。而实际的好处则来自解析过程。XML对比JSON：地位丧失通过使用XMLHttpRequest对象，可以从你的基于AJAX的应用程序取得XML和JSON文件。典型的，交互代码如下：var req = new XMLHttpRequest();req.open("GET", "/*async*/true);req.onreadystatechange = myHandler;req.send(/*no params*/null);作为WEB服务器响应，你提供的处理器函数（myHandler函数）被多次调用，为你提供提前终止事务，更新进度条等机会。通常的，只有在web请求完成以后才起作用：那时，你就可以使用返回的数据了。为了处理XML版本的地址卡数据，myHandler的代码如下：function myHandler() {if (req.readyState == 4 /*complete*/) {// Update address field in a form with first street addressvar addrField = document.getElementById('addr');var root = req.responseXML;var addrsElem = root.getElementsByTagName('addresses')[0];var firstAddr = addrsElem.getElementsByTagName('address')[0];var addrText = fistAddr.firstChild;var addrValue = addrText.nodeValue;addrField.value = addrValue;}}值得注意的是你不必解析XML文档：XMLHttpRequest对象自动地解析了，并使responseXML中的DOM树可用。通过使用 responseXML属性，可以调用getElementsByTagName方法查找文档的地址部分，你还可以使用第一个去找到它。然后，可以再次调 用getElementsByTagName在地址部分查找第一个地址元素。这就取得了文档的第一个DOM子节点，就是一
个文本节点，并取得节点的值，这 就是你想要的街道地址。最后，可以在表单域中显示结果。确实不是一个简单的工作，现在，使用JSON再试一下：function myHandler() {if (req.readyState == 4 /*complete*/) {var addrField = document.getElementById('addr');var card = eval('(' + req.responseText + ')');addrField.value = card.addresses[0].value;}}你所做的第一件事情就是解析JSON响应。但是，因为JSON是JavaScript的一个子集，你可以使用JavaScript自己的编译器来解析它， 通过调用eval函数。解析JSON仅需要一行！此外，操纵JSON中的对象就像操纵其他JavaScript对象一样。这显然要比通过DOM树来操纵简 单，例如：card.addresses[0].value 是第一个街道地址, "1234 Main Stb &"card.addresses[0].type 是地址类型, "work"card.addresses[1] 是家庭地址对象card.fullname 是card的名称, "Sean Kelly"如果更仔细观察，你可能会发现XML格式中文档至少有一个跟元素，card。这在JSON里是不存在的，为什么？ 大概就是，如果你正在开发JavaScript来访问Web服务，你已经知道你想要得到的。然而，你可以在JSON中这么使用：{"card": {"fullname": ...}}使用这个技术，你的JSON文件总是以一个带有单一命名属性的对象开始，该属性标识了对象的种类。JSON是快速可靠的吗？JSON提供轻量的小文档，并且JSON在JavaScript更容易使用。XMLHttpRequest自动为你解析了XML文档，而你还要手工解析 JSON文件，但是解析JSON比解析XML更慢么？作者通过几千次的反复测试，使用XMLHttpRequest解析XML和解析JSON，结果是解析 JSON比XML要快10倍！当把AJAX当作桌面应用看待时，速度是最重要的因素，很明显，JSON更优秀。当然，你不能总是控制服务器端来为AJAX程序产生数据。你还可以使用第三方服务器代替服务器提供XML格式的输出。并且，如果服务器恰好提供JSON，你可以确定你真的想使用它吗?代码中值得注意的是，你将响应文本直接传入到eval中。如果你控制着服务器，就可以这么做。如果不是，一个恶意服务器可以使你的浏览器执行危险操作。在这样的情况下，你最好使用写在JavaScript中的代码来解析JSON。幸运地，这已经有了。说到解析，Python爱好者可能注意到JSON不只是JavaScript的子集，它还是Python的一个子集。你可以在Python中直接执行JSON，或者使用安全JSON解析代替。JSON.org网站列举了许多常用JSON解析器。服务器端的JSON到现在为止，你或许将焦点注意在运行在客户浏览器中的基于AJAX的web应用程序使用JSON。自然地，首先，JSON格式的数据必须在服务器端产生。 幸运地是，创建JSON或将其他存在的数据转换成JSON是相当简单的。一些WEB
javascriptjson解析器篇二
《JavaScript操作Json》
JSON （JavaScript Object Notation）一种简单的数据格式，比xml更轻巧。 JSON 是 JavaScript 原生格式，这意味着在 JavaScript 中处理 JSON 数据不需要任何特殊的 API 或工具包。
JSON的规则很简单： 对象是一个无序的“‘名称/值’对”集合。一个对象以“{”（左括号）开始，“}”（右括号）结束。每个“名称”后跟一个“:”（冒号）；“‘名称/值’ 对”之间使用“,”（逗号）分隔。具体细节参考
举个简单的例子：
js 代码 1.
2.
3.
4.
5.
6. 7.
8.
9. function showJSON() { var user = { "username":"andy", "age":20, "info": { "tel": "123456", "cellphone": "98765"}, "address": [ {"city":"beijing","postcode":"222333"},
10. {"city":"newyork","postcode":"555666"}
11. ]
12. }
13.
14. alert(user.username);
15. alert(user.age);
16. alert(user.info.cellphone);
17. alert(user.address[0].city);
18. alert(user.address[0].postcode);
19. }
这表示一个user对象，拥有username, age, info, address 等属性。
同样也可以用JSON来简单的修改数据，修改上面的例子
js 代码
1.
2. function showJSON() { var user =
3.
4.
5.
6.
7.
8.
9. { "username":"andy", "age":20, "info": { "tel": "123456", "cellphone": "98765"}, "address": [ {"city":"beijing","postcode":"222333"},
10. {"city":"newyork","postcode":"555666"}
11. ]
12. }
13.
14. alert(user.username);
15. alert(user.age);
16. alert(user.info.cellphone);
17. alert(user.address[0].city);
18. alert(user.address[0].postcode);
19.
20. user.username = "Tom";
21. alert(user.username);
22. }
JSON提供了json.js包，下载 后，将其引入然后就可以简单的使用object.toJSONString()转换成JSON数据。
js 代码
1.
2.
3.
4.
5.
6.
7.
8.
9. function showCar() { var carr = new Car("Dodge", "Coronet R/T", 1968, "yellow"); alert(carr.toJSONString()); } function Car(make, model, year, color) { this.make = make; this.model = model; this.year = year;
10. this.color = color;
11. }
可以使用eval来转换JSON字符到Object
js 代码 1.
2.
3.
4.
5. function myEval() { var str = '{ "name": "Violet", "occupation": "character" }'; var obj = eval('(' + str + ')'); alert(obj.toJSONString()); }
或者使用parseJSON()方法
js 代码 1.
2.
3.
4.
5. function myEval() { var str = '{ "name": "Violet", "occupation": "character" }'; var obj = str.parseJSON(); alert(obj.toJSONString()); }
下面使用prototype写一个JSON的ajax例子。
先写一个servlet (我的是servlet.ajax.JSONTest1.java)就写一句话
java 代码
1. response.getWriter().print("{ /"name/": /"Violet/", /"occupation/": /"c
haracter/" }");
再在页面中写一个ajax的请求
js 代码 1.
2.
3.
4.
5.
6.
7.
8.
9. function sendRequest() { var url = "/MyWebApp/JSONTest1"; var mailAjax = new Ajax.Request( url, { method: 'get', onComplete: jsonResponse } );
11.
12. function jsonResponse(originalRequest) {
13. alert(originalRequest.responseText);
14. var myobj = originalRequest.responseText.parseJSON();
15. alert(myobj.name);
16. }
prototype-1.5.1.js中提供了JSON的方法，String.evalJSON(), 可以不使用json.js, 修改上面的方法
js 代码
1.
2.
3.
4. 5. function jsonResponse(originalRequest) { alert(originalRequest.responseText); var myobj = originalRequest.responseText.evalJSON(true); alert(myobj.name); }
JSON还提供了java的jar包 API也很简单，下面举个例子
在javascript中填加请求参数
js 代码 1.
2.
3.
4.
5.
6.
7.
8.
9. function sendRequest() { var carr = new Car("Dodge", "Coronet R/T", 1968, "yellow"); var pars = "car=" + carr.toJSONString(); var url = "/MyWebApp/JSONTest1"; var mailAjax = new Ajax.Request( url, { method: 'get',
10. parameters: pars,
11. onComplete: jsonResponse
12. }
13. );
使用JSON请求字符串就可以简单的生成JSONObject并进行解析,修改servlet添加JSON的处理(要使用json.jar)
java 代码 1. private void doService(HttpServletRequest request, HttpServletR
esponse response) throws IOException {
String s3 = request.getParameter("car"); try {
JSONObject jsonObj = new JSONObject(s3);
System.out.println(jsonObj.getString("model"));
System.out.println(jsonObj.getInt("year"));
} catch (JSONException e) {
e.printStackTrace();
}
/": /"character/" }"); 2. 3. 4. 5. 6. 7. 8. 9. 10. response.getWriter().print("{ /"name/": /"Violet/", /"occupation
11. }
同样可以使用JSONObject生成JSON字符串，修改servlet
java 代码 1. private void doService(HttpServletRequest request, HttpServletResponse resp
onse) throws IOException {
2. String s3 = request.getParameter("car");
3. try {
4. JSONObject jsonObj = new JSONObject(s3);
5. System.out.println(jsonObj.getString("model"));
6. System.out.println(jsonObj.getInt("year"));
7. } catch (JSONException e) {
8. e.printStackTrace();
9. }
10.
11. JSONObject resultJSON = new JSONObject();
12. try {
javascriptjson解析器篇三
《javascript_JSON》
JSONJavaScript对象表示法（JavaScript Object Notation，简称JSON）是一种轻量级的数据交换格式。它基于JavaScript的对象字面量表示法，那是JavaScript最精华的部分之一。尽管只是JavaScript的一个子集，但它与语言武官。它可以被用于在所有以现代编程语言编写的程序之间交换数据。它是一种文本格式，所以可以被人和机器阅读。它易于实现且易于使用。1、JSON语法JSON有6种类型的值：对象、数组、字符串、数字、布尔值（true和false）和特殊值null。空白（空格符、制表符、回车符和换行符）可被插到任何值的前后。这可以使的JSON文本更容易被人阅读。为了减少传输和存储的成本，空白可以被省略。JSON对象是一个容纳“名/值”对的无序集合。名字可以是任何字符串。值可以是任何类型的JSON值，包括数组和对象。JSON对象可以被无限层地嵌套，但一般来说保持其结构的相对扁平是最高效的。大多数语言都有容易被映射为JSON对象的数据类型，比如对象（object）、结构（struct）、字典（dictionary）、哈西表（hash table）、属性列表（prototype list）或关联数组（associative array）。JSON数组是一个值的有序序列。其值可以是任何类型的JSON值，包括数组和对象。大多数语言都有容易被映射为JSON数组的数据类型，比如数组（array）、向量（vector）、列表（list）或序列（sequence）。JSON字符串要被包围在一对双引号之间。\字符被用于转义。JSON允许/字符被转义，所以JSON可以被嵌入HTML的<script>标签中。除非用</script>标签初始化，否则HTML不允许使用</字符序列。但JSON允许使用<\/，它能产生同样的结果却不会与HTML相混淆。JSON数字与JavaScript的数字相似。整数的首位不允许为0，因为一些语言用它来标示八进制。这种基数的混乱在数据交换格式中是不可取的。数字可以是整数、实数或科学计数。就是这样。这就是JSON的全部。JSON的设计目标是成为一个极简的轻便的和文本式的JavaScript子集。实现互通所需要的共识越少，互通就越容易实现。[{"first":"Jerome","middle":"Lester","last":"Howard","nick-name":"Curly","born":1903,"died":1952,"quote":"nyuk-nyuk-nyuk!"},{"first":"Harry","middle":"Moses","last":"Howard","nick-name":"Moe","born":1897,"died":1975,"quote":"Why,you!"},{"first":"Louis","last":"Feinberg","nick-name":"Larry","born":1902,"died":1975,"quote":"I'm sorry.Moe,it was an accident!"}]2、安全地使用JSONJSON特别易于用在Web应用中，因为JSON就是JavaScript。使用eval函数可以把一段JSON文本转化成一个有用的
数据结构：var myData=eval('('+myJSONText+')');（用圆括号把JSON文本括起来是一种避免JavaScript语法中的歧义（译注1）的变通方案。）———————————————————————————————译注1： 在JavaScript的语法中，表达式语句（Expression Statement）不允许以花括号“{”开始，因为那会与块语句（Block Statements）产生混淆。在使用eval()解析JSON文本时，为了解决此问题，可以将JSON文本套上一对圆括号。圆括号在此处作为表达式的分组运算符，能对包围在其中的表达式进行求值。它能正确地识别对象字面量。然而，eval函数有着骇人的安全问题。用eval去解析JSON文本安全吗？目前，在Web浏览器中从服务器端获取数据的最佳技术是XMLHttpRequest。XMLHttpRequest只能从生成HTML的同意服务器获取数据。使用eval解析来自那个服务器的文本安全性和解析最初HTML的安全性一样低。那是假定该服务器存有恶意的前提下，但如果它只是存在漏洞呢？有漏洞的服务器或许并不能正确地对JSON进行编码。如果它通过拼凑一些字符串而不是使用一个合适的JSON编码器来创建JSON文本，那么它可能在无意间发送危险的数据。如果它充当的是代理的角色，并且尚未确定JSON文本是否格式良好就简单地传递它，那么它可能再次发送了危险数据。通过使用JSON.parse（译注2）方法替代eval就能避免这种危险。如果文本中包含任何危险数据，那么JSON.parse将抛出一个异常。为了防止服务器出现漏洞的状况，我推荐你总是用JSON.parse替代eval。即使有一天浏览器提供了连到其他服务器的安全数据访问，使用它同样是个好习惯。——————————————————————————————译注2：原生JSON支持的需求已被提交为ES3.1的工作草案，另外IE8已经提供了原生的JSON支持。在外部数据与innerHTML进行交互时还存在另一种危险。一种常见的Ajax模式是把服务器端发送过来的一个HTML文本片段赋值给某个HTML元素的innerHTML属性。这是一个非常糟糕的习惯。如果这个HTML包含一个<script>标签或其等价物，那么一个恶意脚本将被运行。这可能又是因为服务端存在漏洞。具体有什么危险呢？如果一个恶意脚本在你的页面上被运行，它就有权访问这个页面的所有的状态和该页面能做的操作。它能与你的服务器进行交互，而你的服务器将不能区分正当请求和恶意请求。恶意脚本还能访问全局对象，这使得它有权访问该应用中除隐藏于闭包中的变量之外的所有数据。它可以访问document对象，这会使它有权访问用户所能看到的一切。它还给
这个恶意脚本提供了与用户进行会话的能力。浏览器的地址栏和所有的反钓鱼程序将告诉用户这个会话是可靠的。document对象还给该恶意脚本授权访问网络，允许它去下载更多的恶意脚本，或者是在你的防火墙之内探测站点，或者是将它已经窃取的隐私内容发送给世界的任何一个服务器。这个危险是JavaScript全局变量的直接后果，它是JavaScript众多糟粕之中最糟糕的一个。这些危险并不是由Ajax、JSON、XMLHttpRequest或Web 2.0（不管它是什么）导致的。自从JavaScript被引入浏览器，这些危险就已经存在了，并且它将一直存在，直到JavaScript有一天被取代。所以，请务必当心。3、一个JSON解析器这是一个用JavaScript编写的JSON解析器的实现方案：var json_parse=function(){//这是一个能把JSON文本解析成JavaScript数据结构的函数。//它是一个简单的递归降序解析器。//我们在另一个函数中定义此函数，以避免创建全局变量var at, //当前字符的索引ch, //当前字符escapee={'"':'"','\\':'\\','/':'/',b:'b',f:'\f',n:'\n',r:'\r',t:'\t'},text,error=function(m){//当某处出错时，调用error。throw{name:'SyntaxError',message:m,at:at,text:text};},next=function(c){//如果提供了参数c，那么检验它是否匹配当前字符。if(c&&c!==ch){error("Expected '"+c+"' instead of '"+ch+"'");}//获取下一个字符。当没有下一个字符时，返回一个空字符串。ch=text.charAt(at);at+=1;return ch;},number=function(){//解析一个数字值。var number,string='';if(ch==='-'){string='-';next('-');}while(ch>='0'&&ch<='9'){string+=ch;next();}if(ch==='.'){string+='.';while(next()&&ch>='0'&&ch<='9'){string+=ch;}}if(ch==='e'||ch==='E'){string+=ch;next();if(ch==='-'||ch==='+'){string+=ch;next();}while(ch>='0'&&ch<='9'){string+=ch;next();}}number=+string;if(isNaN(number)){error("Bad number");}else{return number;}},string=function(){//解析一个字符串值。var hex,i,string='',ufff;//当解析字符串值时，我们必须找到"和\字符。if(ch==='"'){while(next()){if(ch==='"'){next();return string;}else if(ch==='\\'){next();if(ch==='u'){uffff=0;for(i=0;i<4;i+=1){hex=parseInt(next(),16);if(!isFinite(hex)){break;}uffff=uffff*16+hex;}string+=String.
fromCharCode(uffff);}else if(typeof escapee[ch]==='string'){string+=escapee[ch];}else{break;}}else{string+=ch;}}}error("Bad string");},white=function(){while(ch&&ch<=' '){next();}},word=function(){//true、false或null。switch(ch){case 't':next('t');next('r');next('u');next('e');return true;case 'f':next('f');next('a');next('l');next('s');next('e');return false;case 'n':next('n');next('u');next('l');next('l');return null;}error("Unexpected '"+ch+"'");},value, //值函数的占位符。array=function(){//解析一个数组值。var array=[];if(ch==='['){next('[');while();if(ch===']'){next(']');return array; //空数组}while(ch){array.push(value());white();if(ch===']'){next(']');return array;}next(',');white();}}error("Bad array");},object=function(){//解析一个对象值。var key,object={};if(ch==='{'){next('{');white();if(ch==='}'){next('}');return object; //空对象}while(ch){key=string();white();next(':');object[key]=value();white();if(ch===')'){next(')');return object;}next(',');white();}}error("Bad object");};value=function(){//解析一个JSON值。它可以是对象、数组、字符串、数字或一个词。white();switch(ch){case '{':return object();case '(':return array();case '"':return string();case '-':return number();default:return ch>='0'&&ch<='9'?number():word();}};//返回json_parse函数。它将能反问上述所有的函数和变量return function(source,reviver){var result;text=source;at=0;ch=' ';result=value();white();if(ch){error("Syntax error");}//如果存在reviver函数，我们就递归地对这个新结构调用walk函数，//开始时先创造一个临时的启动对象，并以一个空字符串作为键名保存结果，//然后传递每个“名/值”对给reviver函数去处理可能存在的转换。//如果没有reviver函数，我们就简单地返回这个结果。return typeof reviver==='function'?function walk(holder,key){var k,v,value=holder[key];if(value&&typeof value==='object'){for(k in value){if(Object.hasOwnProperty.call(value,k)){v=walk(value,k);if(v!==undefined){value[k]=v;}else{
delete value[k];}}}}return reviver.call(holder,key,value);}({'':result},''):result;};}();
javascriptjson解析器篇四
《JavaScript解析JSON格式数据简单方法》
JavaScript解析JSON格式数据简单方法 利用JS代码可简单实现解析JSON格式数据,下面介绍主要步骤:
1、 JSON验证规则验证,过滤掉非JSON格式数据.
如：{name:'王强',age:31,qq:567565656}
2、 根据冒号来切割JSON数据键和值,形成key->alue格式.
如:name->”王强”
Age->32
Qq->567565656
3、 创建一个Object对象,动态绑定属性和值,需要利用eval函数南京宝云教育值得信赖！
4、 最后得到就是一个类似于JSON对象,通过”对象.属性”来访问. 如:wangqiang.name=”王强”
代码请参考下图
javascriptjson解析器篇五
《json与javascript》
JSON 解析器
提示：eval() 函数可编译并执行任何 JavaScript 代码。这隐藏了一个潜在的安全问题。
使用 JSON 解析器将 JSON 转换为 JavaScript 对象是更安全的做法。JSON 解析器只能识别 JSON 文本，而不会编译脚本。
在浏览器中，这提供了原生的 JSON 支持，而且 JSON 解析器的速度更快。
JSON 语法是 JavaScript 对象表示法语法的子集。
数据在名称/值对中
数据由逗号分隔
花括号保存对象
方括号保存数组
JSON 值可以是：
数字（整数或浮点数）
字符串（在双引号中）
逻辑值（true 或 false）
数组（在方括号中）
对象（在花括号中）
null
由于 JSON 语法是 JavaScript 语法的子集，JavaScript 函数 eval() 可用于将 JSON 文本转换为 JavaScript 对象。
eval() 函数使用的是 JavaScript 编译器，可解析 JSON 文本，然后生成 JavaScript 对象。必须把文本包围在括号中，这样才能避免语法错误：
json数组：
{ "employees": [ { "firstName":"John" , "lastName":"Doe" }, { "firstName":"Anna" , "lastName":"Smith" }, { "firstName":"Peter" , "lastName":"Jones" } ] }
Json的使用：
Json数组中存放了多个employee对象 var txt = '{ "employees" : [' +
'{ "firstName":"Bill" , "lastName":"Gates" },' +
'{ "firstName":"George" , "lastName":"Bush" },' + '{ "firstName":"Thomas" , "lastName":"Carter" } ]}';
var obj = eval ("(" + txt + ")");
取到obj对象中的employee数组对象
Javascript数组：
或
Var array=[“hello”,”goose”,”glad”]; 二维数组:
Var twoArray = new Array([1,2,3],[5,6,2]); Var array = new Array(1,2,3); Obj.employee[0].lastName; javascript数组常用函数
toString()：把数组转换成一个字符串
toLocaleString()：把数组转换成一个字符串
join()：把数组转换成一个用符号连接的字符串 shift()：将数组头部的一个元素移出
unshift()：在数组的头部插入一个元素
pop()：从数组尾部删除一个元素
push()：把一个元素添加到数组的尾部
concat()：给数组添加元素
slice()：返回数组的部分
reverse()：将数组反向排序
sort()：对数组进行排序操作
splice()：插入、删除或者替换一个数组元素
javascript 数组排序：
arrayobj.sort(sortfunction)
参数：sortfunction是比较函数
For example:
var testArray=[1,5,2,3,6,4]
testArray.sort(function(a,b){return a-b;});
alert(testArray);
javascriptjson解析器篇六
《JSON基础教程》
JSON 教程JSON：JavaScript 对象表示法（JavaScript Object Notation）。 JSON 是存储和交换文本信息的语法。类似 XML。 JSON 比 XML 更小、更快，更易解析。每一章中用到的实例{ "employees": [ { "firstName":"Bill" , "lastName":"Gates" }, { "firstName":"George" , "lastName":"Bush" }, { "firstName":"Thomas" , "lastName":"Carter" } ] }这个 employee 对象是包含 3 个员工记录（对象）的数组。什么是 JSON ？ JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation） JSON 是轻量级的文本数据交换格式 JSON 独立于语言 * JSON 具有自我描述性，更易理解* JSON 使用 JavaScript 语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言。JSON - 转换为 JavaScript 对象JSON 文本格式在语法上与创建 JavaScript 对象的代码相同。 由于这种相似性，无需解析器，JavaScript 程序能够使用内建的 eval() 函数，用 JSON 数据来生成原生的 JavaScript 对象。亲自试一试 - 实例通过我们的编辑器，您可以在线编辑 JavaScript 代码，然后通过点击一个按钮来查看结果：<html> <body> <h2>在 JavaScript 中创建 JSON 对象</h2><p> Name: <span id="jname"></span><br />
Age: <span id="jage"></span><br /> Address: <span id="jstreet"></span><br /> Phone: <span id="jphone"></span><br /> </p><script type="text/javascript">var JSONObject= { "name":"Bill Gates", "street":"Fifth Avenue New York 666", "age":56, "phone":"555 1234567"};document.getElementById("jname").innerHTML=JSONObject.name document.getElementById("jage").innerHTML=JSONObject.age document.getElementById("jstreet").innerHTML=JSONObject.street document.getElementById("jphone").innerHTML=JSONObject.phone </script></body> </html>亲自试一试类似 XML JSON 是纯文本 JSON 具有“自我描述性”（人类可读） JSON 具有层级结构（值中存在值） JSON 可通过 JavaScript 进行解析 JSON 数据可使用 AJAX 进行传输相比 XML 的不同之处 没有结束标签 更短 读写的速度更快 能够使用内建的 JavaScript eval() 方法进行解析 使用数组 不使用保留字
为什么使用 JSON？对于 AJAX 应用程序来说，JSON 比 XML 更快更易使用：使用 XML 使用 JSON读取 XML 文档 使用 XML DOM 来循环遍历文档 读取值并存储在变量中 读取 JSON 字符串 用 eval() 处理 JSON 字符串SON 语法是 JavaScript 语法的子集。JSON 语法规则JSON 语法是 JavaScript 对象表示法语法的子集。 数据在名称/值对中 数据由逗号分隔 花括号保存对象 方括号保存数组JSON 名称/值对JSON 数据的书写格式是：名称/值对。 名称/值对包括字段名称（在双引号中），后面写一个冒号，然后是值："firstName" : "John"这很容易理解，等价于这条 JavaScript 语句：firstName = "John"JSON 值JSON 值可以是： 数字（整数或浮点数） 字符串（在双引号中） 逻辑值（true 或 false） 数组（在方括号中） 对象（在花括号中） null
JSON 对象JSON 对象在花括号中书写： 对象可以包含多个名称/值对：{ "firstName":"John" , "lastName":"Doe" }这一点也容易理解，与这条 JavaScript 语句等价：firstName = "John" lastName = "Doe"JSON 数组JSON 数组在方括号中书写： 数组可包含多个对象：{ "employees": [ { "firstName":"John" , "lastName":"Doe" }, { "firstName":"Anna" , "lastName":"Smith" }, { "firstName":"Peter" , "lastName":"Jones" } ] }在上面的例子中，对象 "employees" 是包含三个对象的数组。每个对象代表一条关于某人（有姓和名）的记录。JSON 使用 JavaScript 语法因为 JSON 使用 JavaScript 语法，所以无需额外的软件就能处理 JavaScript 中的 JSON。 通过 JavaScript，您可以创建一个对象数组，并像这样进行赋值：例子var employees = [ { "firstName":"Bill" , "lastName":"Gates" }, { "firstName":"George" , "lastName":"Bush" }, { "firstName":"Thomas" , "lastName": "Carter" } ];可以像这样访问 JavaScript 对象数组中的第一项：
employees[0].lastName;返回的内容是：Gates可以像这样修改数据：employees[0].lastName = "Jobs";亲自试一试 在下面的章节，您将学到如何把 JSON 文本转换为 JavaScript 对象。JSON 文件 JSON 文件的文件类型是 ".json" JSON 文本的 MIME 类型是 "application/json"把 JSON 文本转换为 JavaScript 对象JSON 最常见的用法之一，是从 web 服务器上读取 JSON 数据（作为文件或作为 HttpRequest），将 JSON 数据转换为 JavaScript 对象， 然后在网页中使用该数据。 为了更简单地为您讲解，我们使用字符串作为输入进行演示（而不是文件）。JSON 实例 - 来自字符串的对象创建包含 JSON 语法的 JavaScript 字符串：var txt = '{ "employees" : [' + '{ "firstName":"Bill" , "lastName":"Gates" },' + '{ "firstName":"George" , "lastName":"Bush" },' + '{ "firstName":"Thomas" , "lastName":"Carter" } ]}';由于 JSON 语法是 JavaScript 语法的子集，JavaScript 函数 eval() 可用于将 JSON 文本转换为 JavaScript 对象。 eval() 函数使用的是 JavaScript 编译器，可解析 JSON 文本，然后生成 JavaScript 对象。必须把文本包围在括号中，这样才能避免语法错 误：var obj = eval ("(" + txt + ")");在网页中使用 JavaScript 对象：例子<p> First Name: <span id="fname"></span><br />
javascriptjson解析器篇七
《02. JavaScript和Json入门》
JavaScript
JavaScript是基于对象和事件驱动的客户端脚本语言。有如下特点：
交互性
安全性（不可以直接访问本地硬盘）
跨平台性（只要是可以解析js的浏览器都可以执行，和平台无关）
1、JavaScript和Java不同！ ①所属：NetScape和Sun ②基于对象和面向对象 ③JS可以直接解析执行，Java需先编译在运行 ④JavaScript是一种弱类型的语言，Java是强类型的语言。
2、JavaScript的实现包括以下3个部分：
① 核心（ECMAScript）：描述了JS的语法和基本对象。
② 文档对象模型 ☆（DOM）：处理网页内容的方法和接口
③ 浏览器对象模型（BOM）：与浏览器交互的方法和接口
ECMAScript扩展知识：
① ECMAScript是一个标准，JS只是它的一个实现，其他实现包括ActionScript。 ② “ECMAScript可以为不同种类的宿主环境提供核心的脚本编程能力„„”，即ECMAScript不与具体的宿主环境相绑定，如JS的宿主环境是浏览器，AS的宿主环境是Flash。
③ECMAScript描述了以下内容：语法、类型、语句、关键字、保留字、运算符、对象。
3、在HTML中使用JavaScript
1）在<script></script>标签内部直接编写JS代码
2）通过script标签的src属性直接引入外部js文件
注意：若以上两种方式同时存在，则标签内部定义的JS代码不会被执行。
JS核心
4、JS的数据类型（☆）
在JS中使用var关键词声明变量，变量的类型会根据其所赋值来决定。JS中数据类型分为原始数据类型（5种）和引用数据类型（Object类型）。
1）5种原始数据类型：Undefined、Null、Boolean、Number和String。需要注意的是JS中字符串属于原始数据类型。
2）typeof运算符：查看变量类型，对变量或值调用typeof运算符将返回下列值之一：
undefined - 如果变量是 Undefined 类型的
boolean - 如果变量是 Boolean 类型的
number - 如果变量是 Number 类型的
string - 如果变量是 String 类型的
object - 如果变量是一种引用类型或 Null 类型的
3）通过instanceof 运算符解决引用类型判断问题
4）JS中对类型的定义：一组值的集合。如Boolean类型的值有两个：true、false。Undefined和Null 类型都只有一个值，分别是undefined和null。
5）null 被认为是对象的占位符，typeof运算符对于null值返回“object”。
6）原始数据类型和引用数据类型变量在内存中的存放如下：
5、局部变量和全局变量
在函数中声明的变量只能在函数中使用，当你退出函数时，变量就会被释放，这种变量被称为局部变量。因为每个局部变量只在各自的函数中有效，所以你可以在不同的函数中使用名称相同的变量。
如果在函数之外声明变量，那么页面中所有的函数都可以使用它。在全局变量被声明后，它们就开始生效了。在网页被关闭后，变量才会失效。
注意：JS语言中，在代码块中声明的变量属于全局变量。
6、数组（两种创建方式）
1）var arr = [123,”abc”,true,null]
2）var arr = new Array(4); //创建数组长度为4的数组
var arr = new Array(123,”abc”,true,null);//等同于1）
注意：
①js中，数组元素类型可以不一致。
②js中，数组长度可以动态改变。
③接着上述代码，typeof arr 和 arr instanceof Array 分别输出object和true。
7、函数
特点：关键字function；无需指定返回值类型；参数列表声明不需var关键字；无函数重载；函数内部可以直接调用arguments数组（隐式定义），该数组存储了实参列表；函数名代表一种引用类型，可用（函数名 instanceof Function）测试；打印函数引用会输出整个函数定义。
8、动态函数和匿名函数
1）动态函数是通过js的内置对象Function定义。形式为：new Function(arg1 , arg2)，由于arg1和arg2为变量，所以可以动态指定。如：
var run = new Function("x,y","return x+y;");
2） 匿名函数：没有函数名，形如：var run = function(x,y){return x+y;}; 注：打印动态函数的引用可以发现动态函数也是匿名函数。
9、JS核心对象（需要new一个对象）
1）String对象，方法分为两类：①与Html有关的 ②同java中的String相似的。具体查文档。
2）Array对象，一些常用方法：
concat() 同String的concat()方法。
join() 同String的split()方法相反。
pop()、push() 同栈中的弹栈、压栈。
sort() 对数组元素排序。
3）Date对象
getTime()、Date.parse(dateString)方法返回时间戳。
钟表例子：在body中加入onload=”startTime();”则可以在#div_1块中动态显示当前时间
4）Math对象，主要是一些静态方法，常用的有random()、ceil(x)/floor(x)/round(x)方法。
5）RegExp对象：该对象代表正则表达式，用于字符串匹配
① 两种RegExp对象创建方式：
方式一，new 一个RegExp对象：var regExp = new RegExp(“[a-zA-Z0-9]{3,8}”);
方式二，通过直接量赋值：var regExp = /^[a-zA-Z0-9]{3,8}$/;
② 正则表达式的具体写法使用时查询文档。
③ 常用方法：test(string)，返回true或false。
10、全局函数
encodeURI / decodeURI：编码解码URI
进行url跳转时可以整体使用encodeURI
encodeURIComponent / decodeURIComponent：编码解码URI组件
传递参数时需要使用encodeURIComponent
escape / unescape：对字符串进行unicode编码
isNaN：检查某个值是否为NaN（Not a Number，非数字）
parseInt、parseFloat：将字符串解析为整数和浮点数
eval：计算JS字符串，并把它作为脚本代码来执行。
BOM（浏览器对象模型）
11、BOM（浏览器对象模型）
1）window对象：浏览器中打开的窗口
① 如果文档包含框架（frame 或 iframe 标签），浏览器会为 HTML 文档创建一个 window 对象，并为每个框架创建一个额外的 window 对象。
② window.frames 返回窗口中所有命名的框架
③parent是父窗口（如果窗口是顶级窗口，那么parent==self==top）
top是最顶级父窗口（有的窗口中套了好几层frameset或者iframe）
self是当前窗口（等价window）
opener是用open方法打开当前窗口的那个窗口
④与消息框有关的方法：alert(String)、confirm(String)、prompt(String)
⑤两种定时器：setTimeout(code,latency) 和 setInterval(code,period)
注：setTimeout只执行一次code，如果要多次调用，可以让code自身再次调用setTimeout()；setInteval()会不停地调用code，直到clearInterval()被调用。
2）location对象：包含当前URL信息。重点掌握location对象的href属性，用于设置或返回完整的URL。
3）history对象：主要是back()/forward()和go()方法，几乎用不到。
DOM（文档对象模型）
DOM是W3C组织制定的一套用于访问和操作XML和HTML文档的标准。W3C DOM被分为3个不同的部分 / 级别（parts / levels）：
核心DOM：用于任何结构化文档的标准模型（不作研究）
XML DOM：用于XML„„
HTML DOM：用于HTML„„
12、XML DOM和HTML DOM
1） XML DOM和HTML DOM分别定义了访问和操作XML和HTML文档的标准方法（接口）。
2）HTML文档符合XML语法标准，所以可以使用XML DOM API解析HTML
（比较麻烦），后面的例子会分别使用HTML DOM和XML DOM进行解析。
3）如果把HTML当做XML对待，不会忽略回车、空格和制表符。
13、DOM节点树模型（以HTML DOM树为例）
1）DOM模型将整个文档（XML文档和HTML文档）看成一个树形结构，并用document对象表示该文档。
2）DOM规定文档中的每个成分都是一个节点（Node）：
文档节点（Document）：代表整个文档
元素节点（Element）：文档中的一个标记
文本节点（Text）：标记中的文本
属性节点（Attr）：代表一个属性，元素才有属性
3）Node为所有节点的父接口，其定义了一组公共的属性和方法，如下：
javascriptjson解析器篇八
《JS对象之JSON详解》
JS对象之JSON详解
JavaScript对象与传统的面向对象中的对象几乎没有相似之处，传统的面向对象语言中，创建一个对象必须先有对象的模板：类，类中定义了对象的属性和操作这些属性的方法。通过实例化来构筑一个对象，然后使用对象间的协作来完成一项功能，通过功能的集合来完成整个工程。而Javascript中是没有类的概念的，借助JavaScript的动态性，我们完全可以创建一个空的对象(而不是类)，通过像对象动态的添加属性来完善对象的功能。
JSON是JavaScript中对象的字面量，是对象的表示方法，通过使用JSON，可以减少中间变量，使代码的结构更加清晰，也更加直观。使用JSON，可以动态的构建对象，而不必通过类来进行实例化，大大的提高了编码的效率。
Javascript对象
JavaScript对象其实就是属性的集合，这里的集合与数学上的集合是等价的，即具有确定性，无序性和互异性，也就是说，给定一个JavaScript对象，我们可以明确的知道一个属性是不是这个对象的属性，对象中的属性是无序的，并且是各不相同的(如果有同名的，则后声明的覆盖先声明的)。
一般来说，我们声明对象的时候对象往往只是一个空的集合，不包含任何的属性，通过不断的添加属性，使得该对象成为一个有完整功能的对象，而不用通过创建一个类，然后实例化该类这种模式，这样我们的代码具有更高的灵活性，我们可以任意的增删对象的属性。
如果读者有python或其他类似的动态语言的经验,就可以更好的理解JavaScript的对象，JavaScript对象的本身就是一个字典(dictionary)，或者Java语言中的Map，或者称为关联数组，即通过键来关联一个对象，这个对象本身又可以是一个对象，根据此定义，我们可以知道JavaScript对象可以表示任意复杂的数据结构。
对象的属性
属性是由键值对组成的，即属性的名字和属性的值。属性的名字是一个字符串，而值可以为任意的JavaScript对象(JavaScript中的一切皆对象，包括函数)。比如，声明一个对象：
//声明一个对象
var jack = new Object();
jack.name = "jack";
jack.age = 26;
jack.birthday = new Date(1984, 4, 5);
//声明另一个对象
var address = new Object();
address.street = "Huang Quan Road";
address.xno = "135";
//将addr属性赋值为对象address
jack.addr = address;
这种声明对象的方式与传统的OO语言是截然不同的，它给了我们极大的灵活性来定制一个对象的行为。
对象属性的读取方式是通过点操作符(.)来进行的，比如上例中jack对象的addr属性，可以通过下列方式取得：
varja = jack.addr;
ja = jack[addr];
后者是为了避免这种情况，设想对象有一个属性本身包含一个点(.)，这在JavaScript中是合法的，比如说名字为foo.bar，当使用jack.foo.bar的时候，解释器会误以为foo属性下有一个bar的字段，因此可以使用jack[foo.bar]来进行访问。通常来说，我们在开发通用的工具包时，应该对用户可能的输入不做任何假设，通过[属性名]这种形式则总是可以保证正确性的。
属性与变量
在第二章，我们讲解了变量的概念，在本章中，读者可能已经注意到，这二者的行为非常相似，事实上，对象的属性和我们之前所说的变量其实是一回事。
JavaScript引擎在初始化时，会构建一个全局对象，在客户端环境中，这个全局对象即为window。如果在其他的JavaScript环境中需要引用这个全局对象，只需要在顶级作用域(即所有函数声明之外的作用域)中声明：
var global = this;
我们在顶级作用域中声明的变量将作为全局对象的属性被保存，从这一点上来看，变量其实就是属性。比如，在客户端，经常会出现这样的代码：
var v = "global";
var array = ["hello", "world"];
function func(id){
var element = document.getElementByIdx_x(id);
//对elemen做一些操作
}
事实上相当于：
window.v = "global";
window.array = ["hello", "world"];
window.func = function(id){
var element = document.getElementByIdx_x(id);
//对elemen做一些操作
}
原型对象
原型(prototype)，是JavaScript特有的一个概念，通过使用原型，JavaScript可以建立其传统
OO语言中的继承，从而体现对象的层次关系。JavaScript本身是基于原型的，每个对象都有一个prototype的属性来，这个prototype本身也是一个对象，因此它本身也可以有自己的原型，这样就构成了一个链结构。
访问一个属性的时候，解析器需要从下向上的遍历这个链结构，直到遇到该属性，则返回属性对应的值，或者遇到原型为null的对象(JavaScript的基对象Object的prototype属性即为null)，如果此对象仍没有该属性，则返回undefined.
下面我们看一个具体的例子：
//声明一个对象base
function Base(name){
this.name = name;
this.getName = function(){
return this.name;
}
}
//声明一个对象child
function Child(id){
this.id = id;
this.getId = function(){
return this.id;
}
}
//将child的原型指向一个新的base对象
Child.prototype = new Base("base");
//实例化一个child对象
var c1 = new Child("child");
//c1本身具有getId方法
print(c1.getId());
//由于c1从原型链上"继承"到了getName方法，因此可以访问
print(c1.getName());
得出结果：
child
base
由于遍历原型链的时候，是有下而上的，所以最先遇到的属性值最先返回，通过这种机制可以完成重载的机制。
this指针
JavaScript中最容易使人迷惑的恐怕就数this指针了，this指针在传统OO语言中，是在类中声明的，表示对象本身，而在JavaScript中，this表示当前上下文，即调用者的引用。这里我们可以来看一个常见的例子：
//定义一个人，名字为jack
var jack = {
name : "jack",
age : 26
}
//定义另一个人，名字为abruzzi
varabruzzi = {
name : "abruzzi",
age : 26
}
//定义一个全局的函数对象
function printName(){
return this.name;
}
//设置printName的上下文为jack, 此时的this为jack
print(printName.call(jack));
//设置printName的上下文为abruzzi,此时的this为abruzzi
print(printName.call(abruzzi));
javascriptjson解析器篇九
《JSON 教程》
JSON 教程Next PageJSON：JavaScript 对象表示法（JavaScript Object Notation）。JSON 是存储和交换文本信息的语法。类似 XML。JSON 比 XML 更小、更快，更易解析。每一章中用到的实例{"employees": [{ "firstName":"Bill" , "lastName":"Gates" },{ "firstName":"George" , "lastName":"Bush" },{ "firstName":"Thomas" , "lastName":"Carter" }]}这个 employee 对象是包含 3 个员工记录（对象）的数组。什么是 JSON ？•JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation）•JSON 是轻量级的文本数据交换格式•JSON 独立于语言 *•JSON 具有自我描述性，更易理解* JSON 使用 JavaScript 语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言。JSON - 转换为 JavaScript 对象JSON 文本格式在语法上与创建 JavaScript 对象的代码相同。由于这种相似性，无需解析器，JavaScript 程序能够使用内建的 eval() 函数，用 JSON 数据来生成原生的 JavaScript 对象。=========================================JSON 简介Previous PageNext Page亲自试一试 - 实例通过我们的编辑器，您可以在线编辑 JavaScript 代码，然后通过点击一个按钮来查看结果：<html><body><h2>在 JavaScript 中创建 JSON 对象</h2><p>Name: <span id="jname"></span><br />Age: <span id="jage"></span><br />Address: <span id="jstreet"></span><br />Phone: <span id="jphone"></span><br /></p><script type="text/javascript">var JSONObject= {"name":"Bill Gates","street":"Fifth Avenue New York 666","age":56,"phone":"555 1234567"};document.getElementById("jname").innerHTML=JSONObject.namedocument.getElementById("jage").innerHTML=JSONObject.agedocument.getElementById("jstreet").innerHTML=JSONObject.streetdocument.getElementById("jphone").innerHTML=JSONObject.phone</script></body></html>亲自试一试------------------------------------------------------<html><body><h2>在 JavaScript 中创建 JSON 对象</h2><p>Name: <span id="jname"></span><br />Age: <span id="jage"></span><br />Address: <span id="jstreet"></span><br />Phone: <span id="jphone"></span><br /></p><script type="text/javascript">var JSONObject= {"name":"Bill Gates","street":"Fifth Avenue New York 666","age":56,"phone":"555 1234567"};document.getElementById("jname").innerHTML=JSONObject.namedocument.getElementById("jage").innerHTML=JSONObject.agedocument.getElementById("jstreet").innerHTML=JSONObject.streetdocument.getElementById("jphone").innerHTML=JSONObject.phone</script></body></html>-------------------------------------------------------类似 XML•JSON 是纯文本•JSON 具有“自我描述性”（人类可读）•JSON 具有层级结构（值中存在值）•JSON 可通过 JavaScript 进行解析•JSON 数据
可使用 AJAX 进行传输相比 XML 的不同之处•没有结束标签•更短•读写的速度更快•能够使用内建的 JavaScript eval() 方法进行解析•使用数组•不使用保留字为什么使用 JSON？对于 AJAX 应用程序来说，JSON 比 XML 更快更易使用：使用 XML•读取 XML 文档•使用 XML DOM 来循环遍历文档•读取值并存储在变量中使用 JSON•读取 JSON 字符串•用 eval() 处理 JSON 字符串===================================================JSON 语法Previous PageNext PageJSON 语法是 JavaScript 语法的子集。JSON 语法规则JSON 语法是 JavaScript 对象表示法语法的子集。•数据在名称/值对中•数据由逗号分隔•花括号保存对象•方括号保存数组JSON 名称/值对JSON 数据的书写格式是：名称/值对。名称/值对包括字段名称（在双引号中），后面写一个冒号，然后是值："firstName" : "John"这很容易理解，等价于这条 JavaScript 语句：firstName = "John"JSON 值JSON 值可以是：•数字（整数或浮点数）•字符串（在双引号中）•逻辑值（true 或 false）•数组（在方括号中）•对象（在花括号中）•nullJSON 对象JSON 对象在花括号中书写：对象可以包含多个名称/值对：{ "firstName":"John" , "lastName":"Doe" }这一点也容易理解，与这条 JavaScript 语句等价：firstName = "John"lastName = "Doe"JSON 数组JSON 数组在方括号中书写：数组可包含多个对象：{"employees": [{ "firstName":"John" , "lastName":"Doe" },{ "firstName":"Anna" , "lastName":"Smith" },{ "firstName":"Peter" , "lastName":"Jones" }]}在上面的例子中，对象 "employees" 是包含三个对象的数组。每个对象代表一条关于某人（有姓和名）的记录。JSON 使用 JavaScript 语法因为 JSON 使用 JavaScript 语法，所以无需额外的软件就能处理 JavaScript 中的 JSON。通过 JavaScript，您可以创建一个对象数组，并像这样进行赋值：例子var employees = [{ "firstName":"Bill" , "lastName":"Gates" },{ "firstName":"George" , "lastName":"Bush" },{ "firstName":"Thomas" , "lastName": "Carter" }];可以像这样访问 JavaScript 对象数组中的第一项：employees[0].lastName;返回的内容是：Gates可以像这样修改数据：employees[0].lastName = "Jobs";亲自试一试-------------------------------------------<html><body><h2>通过 JSON 字符串来创建对象</h3><p>First Name: <span id="fname"></span></p> <script type="text/javascript">var employees = [{ "firstName":"Bill" , "lastName":"Gates" },{ "firstName":"George" , "lastName":"Bush" },{ "firstName":"Thomas" , "lastName": "Carter" }];employees[1].firstName="Jobs";document.getElementById("fname").innerHTML=employees[1].firstName;</scr
ipt></body></html>-------------------------------------------在下面的章节，您将学到如何把 JSON 文本转换为 JavaScript 对象。JSON 文件•JSON 文件的文件类型是 ".json"•JSON 文本的 MIME 类型是 "application/json"================================================================JSON 使用Previous PageNext Page把 JSON 文本转换为 JavaScript 对象JSON 最常见的用法之一，是从 web 服务器上读取 JSON 数据（作为文件或作为 HttpRequest），将 JSON 数据转换为 JavaScript 对象，然后在网页中使用该数据。为了更简单地为您讲解，我们使用字符串作为输入进行演示（而不是文件）。JSON 实例 - 来自字符串的对象创建包含 JSON 语法的 JavaScript 字符串：var txt = '{ "employees" : [' +'{ "firstName":"Bill" , "lastName":"Gates" },' +'{ "firstName":"George" , "lastName":"Bush" },' +'{ "firstName":"Thomas" , "lastName":"Carter" } ]}';由于 JSON 语法是 JavaScript 语法的子集，JavaScript 函数 eval() 可用于将 JSON 文本转换为 JavaScript 对象。eval() 函数使用的是 JavaScript 编译器，可解析 JSON 文本，然后生成 JavaScript 对象。必须把文本包围在括号中，这样才能避免语法错误：var obj = eval ("(" + txt + ")");在网页中使用 JavaScript 对象：例子<p>First Name: <span id="fname"></span><br />Last Name: <span id="lname"></span><br /></p><script type="text/javascript">document.getElementById("fname").innerHTML = obj.employees[1].firstNamedocument.getElementById("lname").innerHTML = obj.employees[1].lastName</script>亲自试一试-------------------------------------------------------------<html><body><h2>通过 JSON 字符串来创建对象</h3><p>First Name: <span id="fname"></span><br /> Last Name: <span id="lname"></span><br /> </p> <script type="text/javascript">var txt = '{"employees":[' +'{"firstName":"Bill","lastName":"Gates" },' +'{"firstName":"George","lastName":"Bush" },' +'{"firstName":"Thomas","lastName":"Carter" }]}';var obj = eval ("(" + txt + ")");document.getElementById("fname").innerHTML=obj.employees[1].firstName document.getElementById("lname").innerHTML=obj.employees[1].lastName </script></body></html>------------------------------------------------------------------JSON 解析器提示：eval() 函数可编译并执行任何 JavaScript 代码。这隐藏了一个潜在的安全问题。使用 JSON 解析器将 JSON 转换为 JavaScript 对象是更安全的做法。JSON 解析器只能识别 JSON 文本，而不会编译脚本。在浏览器中，这提供了原生的 JSON 支持，而且 JSON 解析器的速度更快。较新的浏览器和最新的 ECMAScript (JavaScript) 标准中均包含了原生的对 JSON 的支持。Web 浏览器支持 Web 软件支持 •Firefox (Mozilla) 3.5•Internet Explorer 8•Ch
rome•Opera 10•Safari 4•jQuery•Yahoo UI•Prototype•Dojo•ECMAScript 1.5亲自试一试-------------------------------------------------------------<html><body><h2>通过 JSON 字符串来创建对象</h3><p>First Name: <span id="fname"></span><br /> Last Name: <span id="lname"></span><br /> </p> <script type="text/javascript">var txt = '{"employees":[' +'{"firstName":"Bill","lastName":"Gates" },' +'{"firstName":"George","lastName":"Bush" },' +'{"firstName":"Thomas","lastName":"Carter" }]}';obj = JSON.parse(txt);document.getElementById("fname").innerHTML=obj.employees[1].firstName document.getElementById("lname").innerHTML=obj.employees[1].lastName </script></body></html>---------------------------------------------------------------对于较老的浏览器，可使用 JavaScript 库： https://github.com/douglascrockford/JSON-jsJSON 格式最初是由 Douglas Crockford 制定的。
javascriptjson解析器篇十
《JSON入门详解》
JSON入门
快速浏览JSON与XML表现形式
假如有一个employee对象，它有“姓、名、员工编号、头衔”等信息，先看看JSON是如何来描述它的：
再来看看XML是如何表示的，请看：
从上面描述看，JSON表示法不正是JavaScript中对象描述的一种方式么？正确，这正是JavaScript中的对象构造的原生代码。既然是原生代码，我们把它转换成JavaScript中的对象，这样我们操作对象就比操作字符串方便多了。
把JSON字符串转换成JavaScript对象：
JSON优缺点
优点：
乍看上去，使用JSON的数据分隔符的优点可能并不那么明显，但存在一个根本性的缘由：它们简化了数据访问。使用这些数据分隔符时， JavaScript引擎对数据结构（如字符串、数组、对象）的内部表示恰好与这些符号相同。
JSON的另一个优点是它的非冗长性。在XML中，打开和关闭标记是必需的，这样才能满足标记的依从性；而在JSON中，所有这些要求只需通过一个简单的括号即可满足。在包含有数以百计字段的数据交换中，传统的XML标记将会延长数据交换时间
此外，JSON受到了擅长不同编程语言的开发人员的青睐。这是因为无论在Haskell中或 Lisp中，还是在更为主流的C#和Java中，开发都可以方便地生成JSON。
不足：
和许多好东西都具有两面性一样，JSON的非冗长性也不例外，为此JSON丢失了XML具有的一些特性。命名空间允许不同上下文中的相同的信息段彼此混合，然而，显然在JSON中已经找不到了命名空间。JSON与XML的另一个差别是属性的差异，由于JSON采用冒号赋值，这将导致当XML转化为 JSON时，在标识符（XML CDATA）与实际属性值之间很难区分谁应该被当作文本考虑。
另外，JSON片段的创建和验证过程比一般的XML稍显复杂。从这一点来看，XML在开发工具方面领先于JSON。
JSON实践
预备知识
动态脚本函数eval ()
eval() 函数可计算某个字符串，并执行其中的的 JavaScript 代码。它接收一个参数s，如果s不是字符串，则直接返回s。否则执行s语句。如果s语句执行结果是一个值，则直接返回此值，否则返回undefined。
另外，该方法只接受原始字符串作为参数，如果 string 参数不是原始字符串，那么该方法将不作任何改变地返回。因此请不要为 eval() 函数传递 String 对象来作为参数：
最后，需要特别注意的是对象声明语法“{}”并不能返回一个值，需要用括号括起来才会返回值(括号里的脚本是表达式，有返回值，而不是无返回值的逻辑式，因为大括号里的脚本又可能是表达式，又可能是普通的逻辑表达，所以用小括号括起来后明确的说明是值表达式)：
这样的对象声明语句，必须用括号括住，以将其转换为表达式，才能返回其值 。这也是使用JSON来进行Ajax开发的基本原理之一。
现来说说本节的重点，就是在应用eval时，，但很多时候我们可能在调用eval函数的外面使用生成的变量，eval不可能在全局空间内执行，这就给开发带来了不少问题，这该如何作？请看继续往下看吧。
我们先来证实一下eval产生的变量是局部性的，在调用eval函数外是不能访问到此变量的。
另外，eval生成的函数也是局部的，它只能在生成它的函数内使用，出函数域就不能调用的到。
现解释一下：
1、对于IE浏览器，默认已经提供了这样的函数：execScript，用于在全局空间执行代码。
2、对于Firefox浏览器，直接调用eval函数，则在调用者的空间执行；如果调用window.eval则在全局空间执行。
JavaScript中的JSON
我们知道，可以使用eval()方法调用JavaScript的编译器把JSON文本转变成对象。因为JSON是JavaScript的一个确切的子集，编译器可以正确地解析JSON文本，然后生成一个对象结构。
eval函数非常快速。它可以编译执行任何JavaScript程序，因此产生了安全性问题。当使用可信任与完善的源代码时才可以使用eval函数。这样可以更安全的使用JSON解析器。使用XMLHttpRequest的web应用，页面之间的通讯只允许同源，因此是可以信任的。但这却不是完善的。如果服务器没有严谨的JSON编码，或者没有严格的输入验证，那么可能传送包括危险脚本的无效JSON文本。eval函数将执行恶意的脚本。
如果关心安全的话，使用JSON解析器可以防止此类事件。JSON解析器只能辨识
JSON文本，拒绝所有脚本，因此它比较安全，JSON官方网站提供的一个开源的JSON解析器和字符串转换器()。
而JSON的字符串转换器（stringifier）则作相反的工作，它将JavaScript数据结构转换为JSON文本。JSON是不支持循环数据结构的，所以注意不能把循环的结构交给字符串转换器。
Java中的JSON
Java中的JSON解释器官方提供了好几种，我们这里使用的是 包，关于如何使用，请参见另一篇《JSON之org.json包测试》 ，它是基于官方包提供的测试改写而来的。
开始实战
本实例实现了客户端与服务器端通过JSON进行参数的传递与接收，而不是通过原来的XML方式进行通信。页面采用了Prototype的Ajax方式进行异步通信，并采用了官方 进行对象与JSON串的灵活互转。服务器端采用了官方提供 包进行JSON串与Java对象的互转。具体的细节请看代码注释。
客户端实现：