java解析xml的几种方式
DOM
DOM的全称是Document ObjectModel，也即文档对象模型。在应用程序中，基于DOM的XML分析器将一个XML文档转换成一个对象模型的集合（通常称DOM树），应用程序正是通过对这个对象模型的操作，来实现对XML文档数据的操作。通过DOM接口，应用程序可以在任何时候访问XML文档中的任何一部分数据，因此，这种利用DOM接口的机制也被称作随机访问机制。
DOM接口提供了一种通过分层对象模型来访问XML文档信息的方式，这些分层对象模型依据XML的文档结构形成了一棵节点树。无论XML文档中所描述的是什么类型的信息，即便是制表数据、项目列表或一个文档，利用DOM所生成的模型都是节点树的形式。也就是说，DOM强制使用树模型来访问XML文档中的信息。由于XML本质上就是一种分层结构，所以这种描述方法是相当有效的。
DOM树所提供的随机访问方式给应用程序的开发带来了很大的灵活性，它可以任意地控制整个XML文档中的内容。然而，由于DOM分析器把整个XML文档转化成DOM树放在了内存中，因此，当文档比较大或者结构比较复杂时，对内存的需求就比较高。而且，对于结构复杂的树的遍历也是一项耗时的操作。所以，DOM分析器对机器性能的要求比较高，实现效率不十分理想。不过，由于DOM分析器所采用的树结构的思想与XML文档的结构相吻合，同时鉴于随机访问所带来的方便，因此，DOM分析器还是有很广泛的使用价值的。
Java代码
1. import java.io.File;
2.
3. import javax.xml.parsers.DocumentBuilder;
4. import javax.xml.parsers.DocumentBuilderFactory;
5.
6. import org.w3c.dom.Document;
7. import org.w3c.dom.Element;
8. import org.w3c.dom.NodeList;
9.
10. public class DomTest1
11. {
12. public static void main(String[] args) throws Exception
13. {
14. // step 1: 获得dom解析器工厂（工作的作用是用于创建具体的解析器）
15. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
16.
17. // System.out.println("class name: " + dbf.getClass().getName());
18.
19. // step 2:获得具体的dom解析器
20. DocumentBuilder db = dbf.newDocumentBuilder();
21.
22. // System.out.println("class name: " + db.getClass().getName());
23.
24. // step3: 解析一个xml文档，获得Document对象（根结点）
25. Document document = db.parse(new File("candidate.xml"));
26.
27. NodeList list = document.getElementsByTagName("PERSON");
28.
; i < list.getLength(); i++)
30. {
31. Element element = (Element)list.item(i);
32.
).getFirstChild().getNodeValue();
34.
35. System.out.println("name:" + content);
36.
).getFirstChild().getNodeValue();
38.
39. System.out.println("address:" + content);
40.
).getFirstChild().getNodeValue();
42.
43. System.out.println("tel:" + content);
44.
).getFirstChild().getNodeValue();
46.
47. System.out.println("fax:" + content);
48.
).getFirstChild().getNodeValue();
50.
51. System.out.println("email:" + content);
52.
53. System.out.println("--------------------------------------");
54. }
55. }
56. }
Java代码
1. import java.io.File;
2.
3. import javax.xml.parsers.DocumentBuilder;
4. import javax.xml.parsers.DocumentBuilderFactory;
5.
6. import org.w3c.dom.Attr;
7. import org.w3c.dom.Comment;
8. import org.w3c.dom.Document;
9. import org.w3c.dom.Element;
10. import org.w3c.dom.NamedNodeMap;
11. import org.w3c.dom.Node;
12. import org.w3c.dom.NodeList;
13.
14. /**
15. * 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上
16. * @author zhanglong
17. *
18. */
19. public class DomTest3
20. {
21. public static void main(String[] args) throws Exception
22. {
23. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
24. DocumentBuilder db = dbf.newDocumentBuilder();
25.
26. Document doc = db.parse(new File("student.xml"));
27. //获得根元素结点
28. Element root = doc.getDocumentElement();
29.
30. parseElement(root);
31. }
32.
33. private static void parseElement(Element element)
34. {
35. String tagName = element.getNodeName();
36.
37. NodeList children = element.getChildNodes();
38.
39. System.out.print("<" + tagName);
40.
41. //element元素的所有属性所构成的NamedNodeMap对象，需要对其进行判断
42. NamedNodeMap map = element.getAttributes();
43.
44. //如果该元素存在属性
45. if(null != map)
46. {
; i < map.getLength(); i++)
48. {
49. //获得该元素的每一个属性
50. Attr attr = (Attr)map.item(i);
51.
52. String attrName = attr.getName();
53. String attrValue = attr.getValue();
54.
55. System.out.print(" " + attrName + "=\"" + attrValue + "\"");
56. }
57. }
58.
59. System.out.print(">");
60.
; i < children.getLength(); i++)
62. {
63. Node node = children.item(i);
64. //获得结点的类型
65. short nodeType = node.getNodeType();
66.
67. if(nodeType == Node.ELEMENT_NODE)
68. {
69. //是元素，继续递归
70. parseElement((Element)node);
71. }
72. else if(nodeType == Node.TEXT_NODE)
73. {
74. //递归出口
75. System.out.print(node.getNodeValue());
76. }
77. else if(nodeType == Node.COMMENT_NODE)
78. {
79. System.out.print("<!--");
80.
81. Comment comment = (Comment)node;
82.
83. //注释内容
84. String data = comment.getData();
85.
86. System.out.print(data);
87.
88. System.out.print("-->");
89. }
90. }
91.
92. System.out.print("</" + tagName + ">");
93. }
94. }
SAX：
SAX的全称是Simple APIs for XML，也即XML简单应用程序接口。与DOM不同，SAX提供的访问模式是一种顺序模式，这是一种快速读写XML数据的方式。当使用SAX分析器对XML文档进行分析时，会触发一系列事件，并激活相应的事件处理函数，应用程序通过这些事件处理函数实现对XML文档的访问，因而SAX接口也被称作事件驱动接口。
SAX 解析器采用了基于事件的模型，它在解析 XML 文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX 对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时，SAX 这种扩展能力得到了更好的体现。但用 SAX 解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据
Java代码
1. import java.io.File;
2.
3. import javax.xml.parsers.SAXParser;
4. import javax.xml.parsers.SAXParserFactory;
5.
6. import org.xml.sax.Attributes;
7. import org.xml.sax.SAXException;
8. import org.xml.sax.helpers.DefaultHandler;
9.
10. public class SaxTest1
11. {
12. public static void main(String[] args) throws Exception
13. {
14. //step1： 获得SAX解析器工厂实例
15. SAXParserFactory factory = SAXParserFactory.newInstance();
16.
17. //step2: 获得SAX解析器实例
18. SAXParser parser = factory.newSAXParser();
19.
20. //step3: 开始进行解析
21. parser.parse(new File("student.xml"), new MyHandler());
22.
23. }
24. }
25.
26. class MyHandler extends DefaultHandler
27. {
28. @Override
29. public void startDocument() throws SAXException
30. {
31. System.out.println("parse began");
32. }
33.
34. @Override
35. public void endDocument() throws SAXException
36. {
37. System.out.println("parse finished");
38. }
39.
40. @Override
41. public void startElement(String uri, String localName, String qName,
42. Attributes attributes) throws SAXException
43. {
44. System.out.println("start element");
45. }
46.
47. @Override
48. public void endElement(String uri, String localName, String qName)
49. throws SAXException
50. {
51. System.out.println("finish element");
52. }
53. }
Java代码
1. import java.io.File;
2. import java.util.Stack;
3.
4. import javax.xml.parsers.SAXParser;
5. import javax.xml.parsers.SAXParserFactory;
6.
7. import org.xml.sax.Attributes;
8. import org.xml.sax.SAXException;
9. import org.xml.sax.helpers.DefaultHandler;
10.
11. public class SaxTest2
12. {
13. public static void main(String[] args) throws Exception
14. {
15. SAXParserFactory factory = SAXParserFactory.newInstance();
16.
17. SAXParser parser = factory.newSAXParser();
18.
19. parser.parse(new File("student.xml"), new MyHandler2());
20. }
21. }
22.
23. class MyHandler2 extends DefaultHandler
24. {
25. private Stack<String> stack = new Stack<String>();
26.
27. private String name;
28.
29. private String gender;
30.
31. private String age;
32.
33. @Override
34. public void startElement(String uri, String localName, String qName,
35. Attributes attributes) throws SAXException
36. {
37. stack.push(qName);
38.
; i < attributes.getLength(); i++)
40. {
41. String attrName = attributes.getQName(i);
42. String attrValue = attributes.getValue(i);
43.
44. System.out.println(attrName + "=" + attrValue);
45. }
46. }
47.
48. @Override
49. public void characters(char[] ch, int start, int length)
50. throws SAXException
51. {
52. String tag = stack.peek();
53.
54. if("姓名".equals(tag))
55. {
56. name = new String(ch, start,length);
57. }
58. else if("性别".equals(tag))
59. {
60. gender = new String(ch, start, length);
61. }
62. else if("年龄".equals(tag))
63. {
64. age = new String(ch, start, length);
65. }
66. }
67.
68. @Override
69. public void endElement(String uri, String localName, String qName)
70. throws SAXException
71. {
72. stack.pop(); //表示该元素已经解析完毕，需要从栈中弹出
73.
74. if("学生".equals(qName))
75. {
76. System.out.println("姓名：" + name);
77. System.out.println("性别：" + gender);
78. System.out.println("年龄：" + age);
79.
80. System.out.println();
81. }
82.
83. }
84. }
JDOM:
JDOM是一个开源项目，它基于树型结构，利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。（http://jdom.org）
•JDOM 直接为JAVA编程服务。它利用更为强有力的JAVA语言的诸多特性（方法重载、集合概念等），把SAX和DOM的功能有效地结合起来。
•JDOM是用Java语言读、写、操作XML的新API函数。在直接、简单和高效的前提下，这些API函数被最大限度的优化。
JDOM 与 DOM 主要有两方面不同。首先，JDOM 仅使用具体类而不使用接口。这在某些方面简化了 API，但是也限制了灵活性。第二，API 大量使用了 Collections 类，简化了那些已经熟悉这些类的 Java 开发者的使用。
JDOM 文档声明其目的是“使用 20%（或更少）的精力解决 80%（或更多）Java/XML 问题”（根据学习曲线假定为 20%）。JDOM 对于大多数 Java/XML 应用程序来说当然是有用的，并且大多数开发者发现 API 比 DOM 容易理解得多。JDOM 还包括对程序行为的相当广泛检查以防止用户做任何在 XML 中无意义的事。然而，它仍需要您充分理解 XML 以便做一些超出基本的工作（或者甚至理解某些情况下的错误）。这也许是比学习 DOM 或 JDOM 接口都更有意义的工作。
JDOM 自身不包含解析器。它通常使用 SAX2 解析器来解析和验证输入 XML 文档（尽管它还可以将以前构造的 DOM 表示作为输入）。它包含一些转换器以将 JDOM 表示输出成 SAX2 事件流、DOM 模型或 XML 文本文档。JDOM 是在 Apache 许可证变体下发布的开放源码。
jdom创建xml
Java代码
1. import java.io.FileWriter;
2.
3. import org.jdom.Attribute;
4. import org.jdom.Comment;
5. import org.jdom.Document;
6. import org.jdom.Element;
7. import org.jdom.output.Format;
8. import org.jdom.output.XMLOutputter;
9.
10. public class JDomTest1
11. {
12. public static void main(String[] args) throws Exception
13. {
14. Document document = new Document();
15.
16. Element root = new Element("root");
17.
18. document.addContent(root);
19.
20. Comment comment = new Comment("This is my comments");
21.
22. root.addContent(comment);
23.
24. Element e = new Element("hello");
25.
26. e.setAttribute("sohu", "www.sohu.com");
27.
28. root.addContent(e);
29.
30. Element e2 = new Element("world");
31.
32. Attribute attr = new Attribute("test", "hehe");
33.
34. e2.setAttribute(attr);
35.
36. e.addContent(e2);
37.
38. e2.addContent(new Element("aaa").setAttribute("a", "b")
39. .setAttribute("x", "y").setAttribute("gg", "hh").setText("text content"));
40.
41.
42. Format format = Format.getPrettyFormat();
43.
44. format.setIndent(" ");
45. // format.setEncoding("gbk");
46.
47. XMLOutputter out = new XMLOutputter(format);
48.
49. out.output(document, new FileWriter("jdom.xml"));
50.
51. }
52. }
JDOM解析xml
Java代码
1. import java.io.File;
2. import java.io.FileOutputStream;
3. import java.util.List;
4.
5. import org.jdom.Attribute;
6. import org.jdom.Document;
7. import org.jdom.Element;
8. import org.jdom.input.SAXBuilder;
9. import org.jdom.output.Format;
10. import org.jdom.output.XMLOutputter;
11.
12. public class JDomTest2
13. {
14. public static void main(String[] args) throws Exception
15. {
16. SAXBuilder builder = new SAXBuilder();
17.
18. Document doc = builder.build(new File("jdom.xml"));
19.
20. Element element = doc.getRootElement();
21.
22. System.out.println(element.getName());
23.
24. Element hello = element.getChild("hello");
25.
26. System.out.println(hello.getText());
27.
28. List list = hello.getAttributes();
29.
;i < list.size(); i++)
31. {
32. Attribute attr = (Attribute)list.get(i);
33.
34. String attrName = attr.getName();
35. String attrValue = attr.getValue();
36.
37. System.out.println(attrName + "=" + attrValue);
38. }
39.
40. hello.removeChild("world");
41.
42. XMLOutputter out = new XMLOutputter(Format.getPrettyFormat().setIndent(" "));
43.
44.
45. out.output(doc, new FileOutputStream("jdom2.xml"));
46.
47. }
48. }
Dom4j
官网：DOM4Jhttp://dom4j.sourceforge.net/
虽然 DOM4J 代表了完全独立的开发结果，但最初，它是 JDOM 的一种智能分支。它合并了许多超出基本 XML 文档表示的功能，包括集成的 XPath 支持、XML Schema 支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项，它通过 DOM4J API 和标准 DOM 接口具有并行访问功能。从 2000 下半年开始，它就一直处于开发之中。
为支持所有这些功能，DOM4J 使用接口和抽象基本类方法。DOM4J 大量使用了 API 中的 Collections 类，但是在许多情况下，它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是，虽然 DOM4J 付出了更复杂的 API 的代价，但是它提供了比 JDOM 大得多的灵活性。
在添加灵活性、XPath 集成和对大文档处理的目标时，DOM4J 的目标与 JDOM 是一样的：针对 Java 开发者的易用性和直观操作。它还致力于成为比 JDOM 更完整的解决方案，实现在本质上处理所有 Java/XML 问题的目标。在完成该目标时，它比 JDOM 更少强调防止不正确的应用程序行为。
DOM4J 是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。
Java代码
1. import java.io.FileOutputStream;
2. import java.io.FileWriter;
3.
4. import org.dom4j.Document;
5. import org.dom4j.DocumentHelper;
6. import org.dom4j.Element;
7. import org.dom4j.io.OutputFormat;
8. import org.dom4j.io.XMLWriter;
9.
10. public class Test1
11. {
12. public static void main(String[] args) throws Exception
13. {
14. // 创建文档并设置文档的根元素节点 ：第一种方式
15. // Document document = DocumentHelper.createDocument();
16. //
17. // Element root = DocumentHelper.createElement("student");
18. //
19. // document.setRootElement(root);
20.
21. // 创建文档并设置文档的根元素节点 ：第二种方式
22. Element root = DocumentHelper.createElement("student");
23. Document document = DocumentHelper.createDocument(root);
24.
25. root.addAttribute("name", "zhangsan");
26.
27. Element helloElement = root.addElement("hello");
28. Element worldElement = root.addElement("world");
29.
30. helloElement.setText("hello");
31. worldElement.setText("world");
32.
33. helloElement.addAttribute("age", "20");
34.
35. XMLWriter xmlWriter = new XMLWriter();
36. xmlWriter.write(document);
37.
38. OutputFormat format = new OutputFormat(" ", true);
39.
40. XMLWriter xmlWriter2 = new XMLWriter(new FileOutputStream("student2.xml"), format);
41. xmlWriter2.write(document);
42.
43. XMLWriter xmlWriter3 = new XMLWriter(new FileWriter("student3.xml"), format);
44.
45. xmlWriter3.write(document);
46. xmlWriter3.close();
47.
48. }
49. }
Java代码
1. import java.io.File;
2. import java.util.Iterator;
3. import java.util.List;
4.
5. import javax.xml.parsers.DocumentBuilder;
6. import javax.xml.parsers.DocumentBuilderFactory;
7.
8. import org.dom4j.Document;
9. import org.dom4j.Element;
10. import org.dom4j.io.DOMReader;
11. import org.dom4j.io.SAXReader;
12.
13. public class Test2
14. {
15. public static void main(String[] args) throws Exception
16. {
17. SAXReader saxReader = new SAXReader();
18.
19. Document doc = saxReader.read(new File("student2.xml"));
20.
21. Element root = doc.getRootElement();
22.
23. System.out.println("root element: " + root.getName());
24.
25. List childList = root.elements();
26.
27. System.out.println(childList.size());
28.
29. List childList2 = root.elements("hello");
30.
31. System.out.println(childList2.size());
32.
33. Element first = root.element("hello");
34.
35. System.out.println(first.attributeValue("age"));
36.
37. for(Iterator iter = root.elementIterator(); iter.hasNext();)
38. {
39. Element e = (Element)iter.next();
40.
41. System.out.println(e.attributeValue("age"));
42. }
43.
44. System.out.println("---------------------------");
45.
46. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
47. DocumentBuilder db = dbf.newDocumentBuilder();
48. org.w3c.dom.Document document = db.parse(new File("student2.xml"));
49.
50. DOMReader domReader = new DOMReader();
51.
52. //将JAXP的Document转换为dom4j的Document
53. Document d = domReader.read(document);
54.
55. Element rootElement = d.getRootElement();
56.
57. System.out.println(rootElement.getName());
58.
59. }
60. }
Java代码
1. import java.io.FileWriter;
2.
3. import org.jdom.Attribute;
4. import org.jdom.Document;
5. import org.jdom.Element;
6. import org.jdom.output.Format;
7. import org.jdom.output.XMLOutputter;
8.
9. public class Test3
10. {
11. public static void main(String[] args) throws Exception
12. {
13. Document document = new Document();
14.
15. Element root = new Element("联系人列表").setAttribute(new Attribute("公司",
16. "A集团"));
17.
18. document.addContent(root);
19.
20. Element contactPerson = new Element("联系人");
21.
22. root.addContent(contactPerson);
23.
24. contactPerson
25. .addContent(new Element("姓名").setText("张三"))
26. .addContent(new Element("公司").setText("A公司"))
27. .addContent(new Element("电话").setText("021-55556666"))
28. .addContent(
29. new Element("地址")
30. .addContent(new Element("街道").setText("5街"))
31. .addContent(new Element("城市").setText("上海"))
32. .addContent(new Element("省份").setText("上海市")));
33.
34. XMLOutputter output = new XMLOutputter(Format.getPrettyFormat()
35. .setIndent(" ").setEncoding("gbk"));
36.
37. output.output(document, new FileWriter("contact.xml"));
38.
39. }
40. }
参考文献：http://inotgaoshou.iteye.com/blog/1012188
java解析xml的几种方式的更多相关文章
-
JAVA解析XML的四种方式
java解析xml文件四种方式 1.介绍 1)DOM(JAXP Crimson解析器) DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准.DOM是以层次结构组织的节点或信息片断的集合.这 ...
-
JAVA解析xml的五种方式比较
1)DOM解析 DOM是html和xml的应用程序接口(API),以层次结构(类似于树型)来组织节点和信息片段,映射XML文档的结构,允许获取 和操作文档的任意部分,是W3C的官方标准 [优点] ① ...
-
java解析xml文件四种方式
1.介绍 1)DOM(JAXP Crimson解析器) DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准.DOM是以层次结构组织的节点或信息片断的集合.这个层次结构允许开发人员在树中寻找 ...
-
JAVA解析xml的四种方式比较
1)DOM解析 DOM是html和xml的应用程序接口(API),以层次结构(类似于树型)来组织节点和信息片段,映射XML文档的结构,允许获取 和操作文档的任意部分,是W3C的官方标准 [优点] ①允 ...
-
【Java】详解Java解析XML的四种方法
XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML.本文将详细介绍用Java解析XML的四种方法. AD: XML现在已经成为一种通用的数据交换格式,它的平台无关性,语 ...
-
Java解析XML的四种方法详解 - 转载
XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML.本文将详细介绍用Java解析XML的四种方法 在做一般的XML数据交换过程中,我更乐意传递XML字符串,而不是格式化 ...
-
java解析xml的三种方法
java解析XML的三种方法 1.SAX事件解析 package com.wzh.sax; import org.xml.sax.Attributes; import org.xml.sax.SAXE ...
-
横向对比分析Python解析XML的四种方式
横向对比分析Python解析XML的四种方式 在最初学习PYTHON的时候,只知道有DOM和SAX两种解析方法,但是其效率都不够理想,由于需要处理的文件数量太大,这两种方式耗时太高无法接受. 在网络搜 ...
-
Java 解析XML的几种方法
XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便. XML在不同的语言里解析方式都是一样的,只不过实现的语法不同而已. 基本的解析方式 ...
随机推荐
-
安装mysql odbc遇到error 1918.errror installing ODBC driver mysql ODBC 5.3 ANSI Drive
环境:Windows server2008r2 安装mysql-connector-odbc-5.3.6-win32 报错 相信错误信息:Error 1918.errror installing OD ...
-
php获取当前毫秒时间戳
最近在做一个智能家居项目的后台,需要实时上传用户对智能设备的配置信息到服务器,以便实现同步,因此对于时间的精确度要求比较高,最开始直接是用php的time()函数来获取时间戳,获取的时间精确到秒级别, ...
-
linux python pip包安装
python -m pip install --trusted-host pypi.python.org
-
servlet 文件上传简易版
package cn.itcast.servlet; import java.io.File;import java.io.IOException;import java.util.List; imp ...
-
ERROR 1045 (28000): Access denied for user root@localhost (using password:
错误描述: Mysql中添加用户之后可能出现登录时提示ERROR 1045 (28000): Access denied for user的错误.删除user.user中值为NULL的,或更新NULL ...
-
Chrome的Postman的使用
Chrome提供了一个很好的Web App 名为 Postman 使用这个web app,你可以输入一个url,然后可以很清楚的看到返回的各种结果 直接在Google中输入Postman, 找到它 ...
-
NOIP2012模拟试题 121105【奶牛排队(tahort)
3.奶牛排队(tahort) [ 问题描述] 奶牛在熊大妈的带领下排成了一条直队. 显然,不同的奶牛身高不一定相同…… 现在,奶牛们想知道,如果找出一些连续的奶牛,要求最左边的奶牛A是最矮的,最右边的 ...
-
解决Agent admitted failure to sign using the kye with ssh
之前如果建立 ssh 连接,只要將公匙复制到~/.ssh/authorized_keys就可以直接登录而不需要建立密碼. 如果在使用时候出现如下信息: Agent admitted failure t ...
-
ural1439 Battle with You-Know-Who
Battle with You-Know-Who Time limit: 2.0 secondMemory limit: 64 MB Rooms of the Ministry of Magic ar ...
-
javscript eval()的优缺点与web安全防范
要说JavaScript中最为强大的一个方法便是eval()方法呢,为何如此说呢?因为它就像是一个JavaScript解析器,也就是说它的参数就是一段js代码所构成的字符串,当执行这个函数的时候,会把 ...