你所不了解的javascript操作DOM的细节知识点(一)

一：Node类型

DOM1级定义了一个Node接口，该接口是由DOM中的所有节点类型实现。每个节点都有一个nodeType属性，用于表明节点的类型，节点类型在Node类型中有以下几种：

Node.ELEMENT_NODE(1);  元素节点

Node.ATTRIBUTE_NODE(2); 属性节点

Node.TEXT_NODE(3);  文本节点

Node.DOCUMENT_NODE(9); 文档节点

其实还有很多种，但是那些都不是很常用，所以就来理解这其中4种就可以了，我们先来看看节点类型，比如如下代码：

HTML代码如下：

  1. <div id="test">
  2.     <p>aaaaaa</p>
  3.     <p>bbbbbb</p>
  4.     <p>cccccc</p>
  5. </div>

JS如下：

  1. var test = document.getElementById("test");
  2. if(test.nodeType === Node.ELEMENT_NODE) {
  3.     alert(1)
  4. }

如上代码在IE8及以下下是不行的，会报错，如下：

因为IE没有公开Node类型的构造函数，因此在IE8-下会有错误，但是我们可以通过数值来比较，比如上面的要比较元素节点的话，我们可以使用1来比较，同理属性节点是2，文本节点是3；如下代码：

  1. var test = document.getElementById("test");
  2. //  下面的所有的浏览器都支持
  3. if(test.nodeType == 1) {
  4.       alert(1)
  5. }

理解nodeName与nodeValue

nodeName保存的是元素的标签名，而nodeValue一般都是null；我们可以看如下代码，没有特殊的说明，HTML代码都是上面的，因此这边就不贴代码了；如下JS代码测试：

  1. var test = document.getElementById("test");
  2. if(test.nodeType == 1) {
  3.     console.log(test.nodeName);  // 打印DIV
  4.     console.log(test.nodeValue); // 打印null
  5. }

理解节点关系

  1. <!doctype html>
  2. <html lang="en">
  3.  <head>
  4.   <meta charset="UTF-8">
  5.   <title>Document</title>
  6.  </head>
  7.  <body>
  8. </body>
  9. </html>

如上代码，我们可以把head和body是html的子元素，同理html是他们的父级元素，那么head和body就是兄弟元素了，那么head及body里面的就是子元素了，我们需要明白的是每个节点都有一个childNodes属性，其保存的是类似数组的元素，其也有length属性，但是他不是数组Array的实例，比如我们可以看看如下测试代码即可：

  1. <div id="test">
  2.     <p>aaaaaa</p>
  3.     <p>bbbbbb</p>
  4.     <p>cccccc</p>
  5. </div>

JS代码如下：

  1. var test = document.getElementById("test");
  2. if(test.nodeType == 1) {
  3.     console.log(test.childNodes);
  4.     console.log(test.childNodes.length);
  5. }

如上代码，在标准浏览器下及IE9+下 第一行打印如下：

[text, p, text, p, text, p, text, item: function]

第二行打印7 长度为7，因为他们把文本节点那个空格也包括进去了，但是在IE8及以下，长度为3，他们不包括文本空格的节点，因此想要统一的话，我们可以编写HTML代码去掉空格，如下HTML代码即可；

<div id="test"><p>aaaaaa</p><p>bbbbbb</p><p>cccccc</p></div>

这个问题稍后在仔细考虑，我们现在来看看如何取得子元素，我们可以使用2种方法，第一种是使用中括号[index]索引，第二种是使用item[index]索引，如下代码：

  1. console.log(test.childNodes[1]); //  <p>bbbbbb</p>
  2. console.log(test.childNodes.item(1)); //  <p>bbbbbb</p>

但是他们并不是数组，我们可以测试下代码即可，如下代码：

  1. console.log(Object.prototype.toString.call(test.childNodes) === "[object Array]"); // false

但是我们使其转换为数组，如下代码：

  1. //在IE8 及之前版本中无效
  2. var arrayOfNodes = Array.prototype.slice.call(test.childNodes,0);
  3. console.log(arrayOfNodes instanceof Array); // true

不过在IE8及之前不生效；由于IE8及更早版本将NodeList实现为一个COM对象，而我们不能像使用JScript对象那样使用对象，要想在IE低版本中转换为Array的形式，我们可以像下面一样封装一个方法即可；

  1. function convertToArray(nodes){
  2.     var array = null;
  3.     try {
  4.         array = Array.prototype.slice.call(nodes, 0); //针对非IE 浏览器
  5.     } catch (ex) {
  6.         array = new Array();
  7.         for (var i=0, len=nodes.length; i < len; i++){
  8.             array.push(nodes[i]);
  9.         }
  10.     }
  11.     return array;
  12. }
  13. var test = document.getElementById("test");
  14. var testArray = convertToArray(test.childNodes);
  15. console.log(testArray instanceof Array); // true

理解parentNode（父节点），previousSibling(上一个兄弟节点)，nextSibling（下一个兄弟节点）;

每个节点都有一个parentNode属性，该属性指向文档中父节点，previousSibling是指当前节点的上一个同胞节点，nextSibling是指当前节点的下一个同胞节点，比如如下代码：

  1. <div id="test"><p>aaaaaa</p><p>bbbbbb</p><p>cccccc</p></div>
  2. var test = document.getElementById("test");
  3. if(test.nodeType == 1) {
  4.     var secodeChild = test.childNodes[1];
  5.     console.log(secodeChild); // <p>bbbbbb</p>
  6.     console.log(secodeChild.previousSibling); // <p>aaaaaa</p>
  7.     console.log(secodeChild.nextSibling); // <p>cccccc</p>
  8. }

如果该节点列表中只有一个节点的话，那么该节点的previousSibling和nextSibling都为null；父节点的firstChild指向了父节点中第一个节点；如下代码：

  1. <div id="test"><p class="a">aaaaaa</p><p class="b">bbbbbb</p><p class="c">cccccc</p></div>

JS如下：

  1. var test = document.getElementById("test");
  2. if(test.nodeType == 1) {
  3.     console.log(test.firstChild); // <p class="a">aaaaaa</p>
  4.     console.log(test.lastChild);  // <p class="c">cccccc</p>
  5. }

父节点的firstChild始终等于父节点的.childNodes[0],父节点的lastChild始终等于父节点的.childNodes[父节点的.childNodes.length - 1]; 如下代码：

  1. console.log(test.firstChild === test.childNodes[0]); // true
  2. console.log(test.lastChild === test.childNodes[test.childNodes.length - 1]); // true

如果没有子节点的话，那么firstChild和lastChild都指向为空null;

hasChildNodes()：如果需要判断该父节点有没有子节点的话，可以使用该方法判断，返回的是一个布尔型，有返回true，没有返回false，如下代码：

  1. <div id="test"><p class="a">aaaaaa</p><p class="b">bbbbbb</p><p class="c">cccccc</p></div>

JS代码如下：

  1. var test = document.getElementById("test");
  2. console.log(test.hasChildNodes());  // true

如果是如下的 就返回false；如下代码：

<div id="test"></div>

var test = document.getElementById("test");

console.log(test.hasChildNodes());  // false

ownerDocument: 所有节点都有最后一个属性是ownerDocument，该属性指向表示整个文档的文档节点，这种关系表示的任何节点都属于它所在的文档，任何节点都不能同时存在两个或更多文档中，通过这个属性，我们可以不必在节点层次中通过层层回溯到达顶端，而是可以直接访问文档节点；如下测试代码：

  1. <div id="test">
  2.     <p class="a">11</p>
  3. </div>
  4. var test = document.getElementById("test");
  5. console.log(test.ownerDocument); // document
  6. var p = test.ownerDocument.getElementsByTagName("p");
  7. console.log(p);  // <p class="a">11</p>

appendChild(): 用于向childNodes列表的末尾添加一个节点；返回的是新增加的节点；如下代码：

  1. <div id="test">
  2.     <p class="a">11</p>
  3. </div>

JS代码如下：

  1. var test = document.getElementById("test");
  2. var newNode = document.createElement("p");
  3. var returnNode = test.appendChild(newNode);
  4. console.log(returnNode); // <p></p>
  5. console.log(returnNode === newNode); // true
  6. console.log(test.lastChild === newNode); // true

insertBefore(): 该方法是将新节点插入到指定的节点的前面去，该方法接收2个参数，要插入的节点和作为参照的节点；插入节点后，被插入的节点会变成参照节点的前一个同胞节点，同时被方法返回，如下代码：

  1. <div id="test">
  2.     <p class="a">11</p>
  3. </div>

JS代码如下：

  1. var test = document.getElementById("test");
  2. var newNode = document.createElement("div");
  3. var returnNode = test.insertBefore(newNode,test.childNodes[0]);
  4. console.log(returnNode); // <div></div>
  5. console.log(returnNode === newNode); // true

插入节点后，结构变成如下：

  1. <div id="test">
  2.     <div></div>
  3.     <p class="a">11</p>
  4. </div>

但是如果参照节点为null的话，那么就会把新节点插入到最后面去了，如下代码：

  1. var test = document.getElementById("test");
  2. var newNode = document.createElement("div");
  3. var returnNode = test.insertBefore(newNode,null);

插入后HTML结构如下：

  1. <div id="test">
  2.     <p class="a">11</p>
  3.     <div></div>
  4. </div>

我们还可以更深入的看下如下测试代码：

  1. var test = document.getElementById("test");
  2. var newNode = document.createElement("div");
  3. // 插入后成为最后一个节点
  4. var returnNode = test.insertBefore(newNode,null);
  5. console.log(returnNode === test.lastChild); // true
  6. // 插入后成为第一个节点
  7. var returnNode = test.insertBefore(newNode,test.firstChild);
  8. console.log(returnNode === newNode); // true
  9. console.log(newNode === test.firstChild); // true
  10. // 插入到最后一个子节点的前面
  11. var returnNode = test.insertBefore(newNode,test.lastChild);
  12. console.log(returnNode === test.childNodes[test.childNodes.length - 2]); // true

replaceChild(); 该方法接收2个参数，要插入的节点和要替换的节点，要替换的节点将由这个方法返回并从文档树中被移除，同时由插入的节点占据其位置，如下代码：

  1. <div id="test"><p class="a">11</p><p class="b">22</p></div>

JS代码如下：

  1. var test = document.getElementById("test");
  2. var newNode = document.createElement("div");
  3. // 替换第一个节点
  4. var returnNode = test.replaceChild(newNode,test.firstChild);
  5. console.log(returnNode); // <p class="a">11</p>

替换后html代码结构变为如下：

  1. <div id="test"><div></div><p class="b">22</p></div>

替换最后一个节点代码如下：

  1. var test = document.getElementById("test");
  2. var newNode = document.createElement("div");
  3. // 替换最后一个节点
  4. var returnNode = test.replaceChild(newNode,test.lastChild);
  5. console.log(returnNode); // <p class="b">22</p>

替换后的代码如下：

  1. <div id="test"><p class="a">11</p><div></div></div>

removeChild()：移除节点，该方法接收一个参数，即要移除的节点；

被移除的节点将成为返回值，如下代码：

  1. var test = document.getElementById("test");
  2. var newNode = document.createElement("div");
  3. // 移除第一个节点
  4. var returnNode = test.removeChild(test.firstChild);
  5. console.log(returnNode); // <p class="a">11</p>

移除后的代码结构变为如下：

  1. <div id="test"><p class="b">22</p></div>

移除最后一个节点的代码如下：

  1. // 移除最后一个节点
  2. var returnNode = test.removeChild(test.lastChild);
  3. console.log(returnNode); // <p class="b">22</p>

移除后的代码结构变为如下：

  1. <div id="test"><p class="a">11</p></div>

cloneNode(): 克隆一个相同的副本，该方法接收一个布尔值参数，如果为true的话，说明是深复制，复制该节点及整个子节点书，如果为false的话，只复制该节点本身，比如如下代码：

  1. var test = document.getElementById("test");
  2. var deeplist = test.cloneNode(true);
  3. console.log(deeplist);
  4. // <div id="test"><p class="a">11</p><p class="b">22</p></div>
  5. 如果是浅复制的如下代码：
  6. var test = document.getElementById("test");
  7. var deeplist = test.cloneNode(false);
  8. console.log(deeplist);// <div id="test"></div>

Document类型

JS通过Document类型表示文档，document继承HTMLDocument(继承自Document)类型的一个实例，表示整个HTML页面。document对象是window的一个属性，所以可以通过全局对象来访问，document对象有如下特点：

nodeType值为9，

nodeName值为”#document”,

nodeValue值为null，

parentNode值为null，

ownerDocument值为null

理解文档document的子节点

documentElement: 该属性始终指向html元素，如下代码：

console.log(document.documentElement); // 指向html的引用

如果需要直接访问html元素的引用可以直接使用该元素更快，更方便。

childNodes:  通过childNodes列表访问文档元素；如下测试代码：

  1. console.log(document.documentElement); // 指向html的引用
  2. console.log(document.childNodes[0]);  // <!doctype html>
  3. console.log(document.firstChild);  // <!doctype html>
  4. console.log(document.firstChild === document.childNodes[0]); // true
  5. console.log(document.body); // 指向body的引用

所有的浏览器都支持document.documentElement 和 document.body属性;

title:  通过这个属性可以取得网页的标题，如下测试代码：

  1. console.log(document.title);

也可以该方法设置网页的标题；如下代码：

document.title = “我是龙恩”;

URL:  取得页面中完整的url，如下代码测试：

console.log(document.URL); // http://127.0.0.1/dom/dom.html

domain: 该属性包含页面的域名；如下测试代码：

console.log(document.domain); // 127.0.0.1

域名也可以设置的，比如常见的跨子域的情况下，我们需要设置相同的父域即可完成跨域；

namedItem(): 该方法可以通过元素的name特性取得集合中的项，比如现在页面上有很多input的框，我想通过他们的name属性取得自己想要的哪一项，测试代码如下：

HTML代码如下：

  1. <input name="aa"/>
  2. <input name="bb"/>

JS代码如下：

  1. var inputs = document.getElementsByTagName("input");
  2. console.log(inputs.namedItem("aa")); // <input name="aa"/>

我们还可以通过方括号的语法来访问，如下代码：

  1. console.log(inputs["aa"]); // <input name="aa"/>

要想取得文档中所有的元素，可以向getElementsByTagName()中传入”*”; 星号表示全部的意思；

getElementsByName(); 该方法也是HTMLDocument类型才有的方法，这个方法会返回带有给定name特性的所有元素，如下测试代码：

  1. <input name="aa" type="radio"/>
  2. <input name="aa" type="radio"/>
  3. var aa = document.getElementsByName("aa");
  4. console.log(aa);  // object
  5. console.log(aa.length); // 2

该方法也会返回一个HTMLCollection.

浏览器支持程度IE，firefox，chrome都支持；

Element类型

Element节点有以下特征：

nodeType的值为1；

nodeName的值为元素的标签名；

nodeValue的值为null；

parentNode可能是Document或Element

要访问元素的标签名，可以使用nodeName属性，也可以使用tagName属性，这两个属性会返回相同的值，如下代码：

  1. <div id="test"></div>
  2. var test = document.getElementById("test");
  3. console.log(test.tagName);   // DIV
  4. console.log(test.nodeName);  // DIV
  5. console.log(test.nodeValue); // null;
  6. console.log(test.parentNode); // body
  7. console.log(test.nodeType);  // 1

理解HTML元素中的获取属性的方法

所有HTML元素都由HTMLElement类型表示，HTMLElement类型直接继承Element；如果想要取得HTML元素的特性的话，有下面几个方法：

getAttribute(); 获取元素的属性的方法；如下测试代码：

  1. <div id="test" class="testName" title="aa"></div>
  2. var test = document.getElementById("test");
  3. console.log(test.getAttribute("id"));  // test
  4. console.log(test.getAttribute("class")); // testName
  5. console.log(test.getAttribute("title"));  // aa

注意：上面的获取类名在IE8+及标准浏览器下都是使用获取属性class来取得类名，上面的如果在IE7下会返回null, 但是在IE7及以下是使用className这个属性来获取的；如下代码：在IE7下测试：

console.log(test.getAttribute("className")); // testName

当然也可以取得自定义的属性；如下代码：

<div id="test" data-value="test1"></div>

console.log(test.getAttribute("data-value")); // test1

setAttribute() 设置元素的属性；该方法接收2个参数，第一个参数是属性名称，第二个参数是对应的值；如果该值存在，则会以现在的值替换之前的值，如果属性名不存在，则会创建该属性，并指定该属性的值；如下代码：

  1. <div id="test"></div>
  2. // JS代码如下：
  3. var test = document.getElementById("test");
  4. test.setAttribute("id",'test');
  5. test.setAttribute("class","testName");
  6. test.setAttribute("title","aa");
  7. test.setAttribute("data-value","test1");

生成HTML结构如下：

<div id="test" class="testName" title="aa" data-value="test1"></div>

removeAttribute(); 删除元素的特性；如下代码：

  1. <div id="test" class="testName" title="aa" data-value="test1"></div>

JS代码如下：

  1. var test = document.getElementById("test");
  2. test.removeAttribute("id");
  3. test.removeAttribute("class");
  4. test.removeAttribute("title");
  5. test.removeAttribute("data-value");

IE7及以下删除类名需要使用className;

attributes属性

Element类型是使用attributes属性的唯一一个dom节点类型，attributes属性包含一个NamedNodeMap集合；该对象有以下方法：

getNamedItem(name): 返回nodeName属性等于name的节点；

attributes属性中包含一系列节点，每个节点的nodeName就是特性的名称，而节点的nodeValue就是节点值，要取得元素id的特性，如下代码：

  1. <div id="test" class="testName" title="aa" data-value="test1"></div>

JS代码如下：

  1. var div = document.getElementById("test");
  2. var id = div.attributes.getNamedItem("id").nodeValue;
  3. console.log(id);  // test

我们也可以通过中括号的语法来获取的，如下代码：

  1. var id = div.attributes['id'].nodeValue;
  2. console.log(id); // test

同样我们也可以通过上面介绍的getAttribute(“id”)方法来获取元素，如下代码：

console.log(div.getAttribute("id")); // test

也可以通过以下方法给元素设置id，如下方法：

div.attributes["id"].nodeValue = "aa";

removeNamedItem(name): 从列表中移除nodeName属性等于name的节点;

调用removeNamedItem()方法与在元素上调用removeAttribute()方法的效果相同，是直接删除具有给定名称的特性。他们之间的区别是：removeNamedItem()方法返回表示被删除特性的节点；

如下代码：

  1. <div id="test" class="testName" title="aa" data-value="test1"></div>
    JS代码如下：
  1. var div = document.getElementById("test");
  2. var oldAttr = div.attributes.removeNamedItem("id");
  3. console.log(oldAttr); // 返回是被删除的节点  id="test"

现在的html结构变成如下：

<div class="testName" title="aa" data-value="test1"></div>

如上方法：目前IE，firefox，chrome浏览器都支持；

但是上面我们有getAttribute,setAttribute(),removeAttribute()方法，我们可以使用这些方法足够代替上面介绍的几个方法，但是如果想遍历一个元素上有多少个属性时，attributes这个就可以派上用上了，如下代码：

HTML代码如下：

  1. <div id="test" class="testName" title="aa" data-value="test1"></div>

JS代码如下：

  1. var div = document.getElementById("test");
  2. function outputAttributes(element) {
  3.     var arrs = new Array();
  4.     var attrName,
  5.           attrValue,
  6.         i,
  7.         len;
  8.     for(i = 0, len = element.attributes.length; i < len; i++) {
  9.         attrName = element.attributes[i].nodeName;
  10.         attrValue = element.attributes[i].nodeValue;
  11.         arrs.push(attrName + "='" + attrValue + "'");
  12.     }
  13.     return arrs.join(" ");
  14. }
  15. console.log(outputAttributes(div));

结果打印如下：

id='test' class='testName' title='aa' data-value='test1'

上面的函数使用一个数组来保存名值对，最后再以空格为分隔符将它们拼接起来，但是上面的代码我们需要注意两点：

  1. 针对attributes对象中的特性，不同的浏览器返回的顺序不同。
  2. IE7及更早的版本会返回HTML元素中所有可能的特性，包括没有指定的特性；

针对IE7的问题我们可以进行改进，我们都知道，每个特性节点都有一个名为specified的属性，这个属性值如果为true，则意味着要么在HTML中指定了相应的特性，要么通过setAttribute方法设置了该特性，在IE中，所有为设置过的特性该属性的之都为false；如下代码：

  1. var div = document.getElementById("test");
  2. function outputAttributes(element) {
  3.     var arrs = new Array();
  4.     var attrName,
  5.      attrValue,
  6.     i,
  7.     len;
  8.     for(i = 0, len = element.attributes.length; i < len; i++) {
  9.         attrName = element.attributes[i].nodeName;
  10.         attrValue = element.attributes[i].nodeValue;
  11.         if(element.attributes[i].specified) {
  12.              arrs.push(attrName + "='" + attrValue + "'");
  13.         }
  14.     }
  15.     return arrs.join(" ");
  16. }
  17. console.log(outputAttributes(div));

理解元素的子节点

元素可以有任意数目的子节点和后代节点，元素的childNodes属性中它包含了它的所有子节点，这些子节点可能是元素，文本节点，注释或处理指令；不同的浏览器子节点的个数不一样，下面我们来看看demo如下：

  1. <ul id="list">
  2.     <li>11</li>
  3.     <li>22</li>
  4.     <li>33</li>
  5. </ul>

JS代码如下：

  1. var list = document.getElementById("list");
  2. console.log(list.childNodes);
  3. console.log(list.childNodes.length);

我们之前在上面讲过，在标准浏览器下(IE9+,firefox,chrome)下，打印的长度是7个，因为他们把空格也包含上去，在IE8-及以下的浏览器返回的是3个子元素，这是表现的正常情况下，但是如果我现在把html元素的空格都去掉的话，那么所有的浏览器都会返回3个子元素，如下代码：

  1. <ul id="list"><li>11</li><li>22</li><li>33</li></ul>

JS代码如下：

  1. var list = document.getElementById("list");
  2. console.log(list.childNodes);
  3. console.log(list.childNodes.length);

那么平时我们不可能都这样小心小意的编写html代码的，因为一步小心就有一个空格产生，因此我们可以如下判断下是不是元素节点；如下代码演示：

  1. <ul id="list">
  2.     <li>11</li>
  3.     <li>22</li>
  4.     <li>33</li>
  5. </ul>

JS代码如下：

  1. var list = document.getElementById("list");
  2. var arrs = [];
  3. for(var i = 0, ilen = list.childNodes.length; i < ilen; i++) {
  4.     var curElement = list.childNodes[i];
  5.     if(curElement.nodeType === 1){
  6.          arrs.push(curElement);
  7.     }
  8. }
  9. console.log(arrs);
  10. console.log(arrs.length); //

如上代码在所有的浏览器都支持，通过判断该元素是不是元素节点，然后在执行后续操作；不是元素节点都会过滤掉，因此返回的长度都为3；

理解Text类型

Text节点具有以下特征：

nodeType的值为3；

nodeName的值为”#text”;

nodeValue的值为节点所包含的文本；

parentNode是一个Element；

没有子节点；

  1. 创建文本节点；

可以使用document.createTextNode()创建新文本节点，这个方法需要一个参数，即要插入的文本，如下代码：

  1. var element = document.createElement("div");
  2. var text = document.createTextNode("aa");
  3. element.appendChild(text);
  4. document.body.appendChild(element);

2. 分割文本节点splitText(offset); 从offset指定的位置将当前的文本节点分成2个文本节点；如下代码：

  1. var element = document.createElement("div");
  2. var text = document.createTextNode("aabbbccc");
  3. element.appendChild(text);
  4. document.body.appendChild(element);
  5.  
  6. var newNode = element.firstChild.splitText(5);
  7. console.log(element.firstChild.nodeValue); // aabbb
  8. console.log(newNode.nodeValue); // ccc 
    console.log(element.childNodes.length); // 2

浏览器支持的程度有IE，firefox,chrome都支持；

理解DOM操作—动态插入脚本

我们动态插入JS脚本，常见的写法有如下代码即可插入：

  1. var script = document.createElement("script");
  2. script.type ="text/javascript";
  3. script.src = 'a.js';
  4. document.body.appendChild(script);

即可在body最后面动态插如a.js，此动态插入不会堵塞浏览器加载；我们为了更加扩张性，我们也可以封装一个函数，如下代码：

  1. function loadScript(url) {
  2.     var script = document.createElement("script");
  3.     script.type = "text/javascript";
  4.     script.src = url;
  5.     document.body.appendChild(script);
  6. }
  7. loadScript("a.js");

当页面有多个js需要动态插入的话，可以依次调用loadScript函数即可；

但是假如我们现在有这么一个需求，动态加载JS完后，我想在这后面做点事情，我们都知道，动态加载也可以理解为异步加载，不会堵塞浏览器，但是我们需要如何知道动态JS已经加载完了呢？

我们之前讲过一篇文章是 “Javascript事件总结”中有判断JS动态加载完后使用load事件来监听js是否动态加载完，现在我们再来复习下load事件；

Javascript中最常用的一个事件是load，当页面加载完后(包括所有的图片，javascript文件，css文件等外部资源)。就会触发window上面的load事件；目前可以有2种触发load事件，一种是直接放在body上面触发；比如如下代码：

<body onload=”a()”></body>

第二种是通过JS来触发，如下代码：

  1. EventUtil.addHandler(window,’load’,function(event){
  2.       alert(1);
  3. });

上面的EventUtil.addHandler 是我们之前在javascript事件总结中封装的JS函数，现在我们直接拿过来使用，如下代码：

  1. var EventUtil = {
  2.     addHandler: function(element,type,handler) {
  3.         if(element.addEventListener) {
  4.                 element.addEventListener(type,handler,false);
  5.         }else if(element.attachEvent) {
  6.             element.attachEvent("on"+type,handler);
  7.         }else {
  8.             element["on" +type] = handler;
  9.         }
  10.     },
  11.     removeHandler: function(element,type,handler){
  12.         if(element.removeEventListener) {
  13.                 element.removeEventListener(type,handler,false);
  14.         }else if(element.detachEvent) {
  15.             element.detachEvent("on"+type,handler);
  16.         }else {
  17.             element["on" +type] = null;
  18.         }
  19.     },
  20.     getEvent: function(event) {
  21.         return event ? event : window.event;
  22.     },
  23.     getTarget: function(event) {
  24.         return event.target || event.srcElement;
  25.     },
  26.     preventDefault: function(event){
  27.         if(event.preventDefault) {
  28.             event.preventDefault();
  29.         }else {
  30.             event.returnValue = false;
  31.         }
  32.     },
  33.     stopPropagation: function(event) {
  34.         if(event.stopPropagation) {
  35.             event.stopPropagation();
  36.         }else {
  37.             event.cancelBubble = true;
  38.         }
  39.     }
  40. };

下面我们来看看如何使用JS事件来判断JS是否加载完成的代码，我们可以使用load事件来监听，如下代码：

  1. EventUtil.addHandler(window,'load',function(){
  2.     var script = document.createElement("script");
  3.     EventUtil.addHandler(script,'load',function(event){
  4.         console.log(script.src);
  5.     });
  6.     script.src = 'a.js';
  7.     document.body.appendChild(script);
  8. });

如上代码，script元素也会触发load事件，以便可以确定动态加载jS是否加载完成，上面的代码指定src属性和指定的事件处理程序的事件可以调换位置，先后顺序不重要，如上代码，我们也可以这样写，如下代码：

  1. EventUtil.addHandler(window,'load',function(){
  2.     var script = document.createElement("script");
  3.     script.src = 'a.js';
  4.     document.body.appendChild(script);
  5.     EventUtil.addHandler(script,'load',function(event){
  6.         console.log(script.src);
  7.     });
  8. });

目前只有IE9+，Firefox，opera，chrome和safari3+支持，IE8及以下不支持该load事件，因此我们需要针对IE8及以下做处理；

理解readystatechange事件

IE为DOM文档中的某些部分提供了readystatechange事件，这个事件的目的提供与文档或元素的加载的状态有关信息，此事件提供了下面5个值中的一个；

uninitialized（未初始化）：对象存在但尚未初始化；

loading(正在加载)：对象正在加载数据；

loaded(加载完毕): 对象加载数据完成；

interactive(交互)： 可以操作对象了，但没有完全加载；

complete(完成)：对象已经加载完成；

<script>（在IE和opera）中和<link>(仅IE中)元素也会触发readystatechange事件，可以用来确定外部的javascript和css文件是否已经加载完成，基于元素触发的readystatechange事件，即readyState属性无论等于”loaded”还是”complete”都可以表示资源已经可用；如下针对IE的判断javascript是否已经加载完成的方案：

  1. EventUtil.addHandler(window,'load',function(){
  2.     var script = document.createElement("script");
  3.     EventUtil.addHandler(script,'readystatechange',function(event){
  4.         event = EventUtil.getEvent(event);
  5.         var target = EventUtil.getTarget(event);
  6.         if (target.readyState == "loaded" || target.readyState == "complete"){
  7.             EventUtil.removeHandler(target, "readystatechange", arguments. callee);
  8.             alert(script.src);
  9.         }
  10.     });
  11.     script.src = 'a.js';
  12.     document.body.appendChild(script);
  13. });

下面我们可以使用javascript客户端检测技术来判断是否是IE和其他标准浏览器做一个简单的封装；如下代码：

  1. var ua = navigator.userAgent.toLowerCase();
  2. EventUtil.addHandler(window,'load',function(){
  3.     var script = document.createElement("script");
  4.     if(/msie ([^;]+)/.test(ua) || "ActiveXObject" in window) {
  5.         // IE 浏览器
  6.         EventUtil.addHandler(script,'readystatechange',function(event){
  7.             event = EventUtil.getEvent(event);
  8.             var target = EventUtil.getTarget(event);
  9.             if (target.readyState == "loaded" || target.readyState == "complete"){
  10.                 EventUtil.removeHandler(target, "readystatechange", arguments. callee);
  11.                 console.log("javascript已经加载完成");
  12.             }
  13.         });
  14.     }else {
  15.         // 除IE之外的标准浏览器
  16.         EventUtil.addHandler(script,'load',function(event){
  17.             console.log("javascript已经加载完成");
  18.         });
  19.     }
  20.     script.src = 'a.js';
  21.     document.body.appendChild(script);
  22. });

上面的是针对所有的主要的浏览器进行封装来判断动态加载的JS是否已经加载完成！

理解动态加载行内JS方式

另一种加载javascript代码的方式是行内方式，如下代码：

  1. <script src=”text/javascript”>
  2.        function sayHi(){alert(1);}
  3. </script>

从理论来讲，下面的代码应该是有效的；

  1. var script = document.createElement('script');
  2. script.type = 'text/javascript';
  3. script.appendChild(document.createTextNode("function sayHi(){alert(1);} sayHi()"));
  4. document.body.appendChild(script);

如上代码在firefox，IE9+，chrome和opera中，都是正常的，可以运行的，但是在IE8及以下会报错，如下：

IE8及以下将script视为一个特殊的元素，不允许dom访问其子节点；但是我们可以使用script元素的text属性来指定javascript代码，如下代码：

  1. var script = document.createElement('script');
  2. script.type = 'text/javascript';
  3. script.text = "function sayHi(){alert(1);} sayHi()";
  4. document.body.appendChild(script);

现在在所有的主流的浏览器都是正常的，在IE8及以下也是正常的；但是在safari3.0之前的版本不能正确的支持text属性，但可以允许使用文本节点来指定代码；如下代码：

  1. var script = document.createElement('script');
  2. script.type = 'text/javascript';
  3. var code = "function sayHi(){alert(1);} sayHi()";
  4. try{
  5.     script.appendChild(document.createTextNode(code));
  6. }catch(e){
  7.     script.text = code;
  8. }
  9. document.body.appendChild(script);

下面我们可以使用一个函数来封装下；如下代码：

  1. function loadScriptString(code) {
  2.     var script = document.createElement('script');
  3.     script.type = 'text/javascript';
  4.     try{
  5.         script.appendChild(document.createTextNode(code));
  6.     }catch(e){
  7.         script.text = code;
  8.     }
  9.     document.body.appendChild(script);
  10. }
  11. loadScriptString("function sayHi(){alert(1);} sayHi()");

理解动态加载css样式

与动态脚本类似，所谓动态样式是指在页面刚载入时不存在的样式，动态样式是在页面加载完成后动态添加到页面中的；

动态加载样式如下代码：

  1. var link = document.createElement("link");
  2. link.rel = "stylesheet";
  3. link.type = "text/css";
  4. link.href = "style.css";
  5. var head = document.getElementsByTagName("head")[0];
  6. head.appendChild(link);

如上代码即可动态生成css样式；

我们也可以像JS一样先封装一个函数，为了调用更加方便；如下代码：

  1. function loadStyles(url) {
  2.     var link = document.createElement("link");
  3.     link.rel = "stylesheet";
  4.     link.type = "text/css";
  5.     link.href = url;
  6.     var head = document.getElementsByTagName("head")[0];
  7.     head.appendChild(link);
  8. }
  9. loadStyles("style.css");

我们也可以使用事件的方式来判断css动态加载是否已经加载完成~

  1. EventUtil.addHandler(window,'load',function(){
  2.     var link = document.createElement("link");
  3.     link.rel = "stylesheet";
  4.     link.type = "text/css";
  5.     EventUtil.addHandler(link, "load", function(event){
  6.         console.log("css loaded");
  7.     });
  8.     link.href = "style.css";
  9.     document.getElementsByTagName("head")[0].appendChild(link);
  10. });

注意：如上代码：不仅在标准浏览器下chrome，firefox，opera下支持，而且IE7-10都支持这种加载；但是safari不支持这种加载；

或者和javascript一样，我们也可以针对IE下做一种这样的处理；代码如下，也可以支持所有的IE下：

  1. EventUtil.addHandler(window, "load", function(){
  2.     var link = document.createElement("link");
  3.     link.type = "text/css";
  4.     link.rel= "stylesheet";
  5.     EventUtil.addHandler(link, "readystatechange", function(event){
  6.         event = EventUtil.getEvent(event);
  7.         var target = EventUtil.getTarget(event);
  8.         if (target.readyState == "loaded" || target.readyState == "complete"){
  9.             EventUtil.removeHandler(target, "readystatechange", arguments. callee);
  10.             alert("CSS Loaded");
  11.         }
  12.     });
  13.     link.href = "style.css";
  14.     document.getElementsByTagName("head")[0].appendChild(link);
  15. });

我们也可以像Javascript一样，为了判断所有的浏览器下支持可以封装一个所有都支持的代码；当然除safari浏览器除外，好像safari浏览器没有生效；

如下代码：

  1. var ua = navigator.userAgent.toLowerCase();
  2. EventUtil.addHandler(window,'load',function(){
  3.     var link = document.createElement("link");
  4.     link.type = "text/css";
  5.     link.rel= "stylesheet";
  6.     if(/msie ([^;]+)/.test(ua) || "ActiveXObject" in window) {
  7.         // IE 浏览器
  8.         EventUtil.addHandler(link,'readystatechange',function(event){
  9.             event = EventUtil.getEvent(event);
  10.             var target = EventUtil.getTarget(event);
  11.             if (target.readyState == "loaded" || target.readyState == "complete"){
  12.             EventUtil.removeHandler(target, "readystatechange", arguments. callee);
  13.                 alert("css已经加载完成");
  14.             }
  15.         });
  16.     }else {
  17.         // 除IE之外的标准浏览器
  18.         EventUtil.addHandler(link,'load',function(event){
  19.             alert("css已经加载完成");
  20.         });
  21.     }
  22.     link.href = "style.css";
  23.     document.getElementsByTagName("head")[0].appendChild(link);
  24. });

另一种定义样式的方式是使用<style>元素来包含嵌入式的css

如下所示代码：

<style>

body {background-color:red;}

</style>

按照相同的原理，下面的代码除了IE8及以下不支持，其他浏览器下都支持；如下代码：

  1. var style = document.createElement("style");
  2. style.type = "text/css";
  3. style.appendChild(document.createTextNode("body{background-color:red}"));
  4. var head = document.getElementsByTagName("head")[0];
  5. head.appendChild(style);

因此我们也可以像JS一样封装一个全兼容的css样式；如下代码所示：

  1. var style = document.createElement("style");
  2. style.type = "text/css";
  3. try{
  4.     style.appendChild(document.createTextNode("body{background-color:red}"));
  5. } catch (ex){
  6.     style.styleSheet.cssText = "body{background-color:red}";
  7. }
  8. var head = document.getElementsByTagName("head")[0];
  9. head.appendChild(style);

为了更方便调用，因此我们也可以封装一个函数来；如下代码：

  1. function loadStyleString(css) {
  2.     var style = document.createElement("style");
  3.     style.type = "text/css";
  4.     try{
  5.         style.appendChild(document.createTextNode(css));
  6.     } catch (ex){
  7.         style.styleSheet.cssText = css;
  8.     }
  9.     var head = document.getElementsByTagName("head")[0];
  10.     head.appendChild(style);
  11. }
  12. // 调用方式如下：
  13. loadStyleString("body{background-color:red}");

DOM的扩展

 1.   querySelector()方法

querySelector()方法接收一个css选择符，返回与该模式匹配的第一个元素，如果没有找到匹配元素，则返回null；如下代码：

  1. <div id="test">test</div>
  2. <div class="cls">1111</div>
  3. <div class="cls">2222</div>
  4. <div class="cls">2222</div>

JS代码如下：

  1. // 取得body
  2. var body = document.querySelector('body');
  3. console.log(body);  // body的引用
  4. // 取得id为test的元素
  5. var test = document.querySelector("#test");
  6. console.log(test); // <div id="test">test</div>
  7. // 取得类为cls的第一个元素
  8. var cls = document.querySelector(".cls");
  9. console.log(cls);  // <div class="cls">1111</div>

同理我们也可以通过Element类型调用querySelector()方法时，只会在该元素后代范围内查找匹配的元素，如下代码：

  1. <div class="testParent">
  2.    <p>1111</p>
  3.    <p>2222</p>
  4. </div>

我想通过先取得div中的testParent，然后再取得p元素(通过querySelector方法)；如下代码：

  1. var testParent = document.querySelector('.testParent');
  2. var pfirst = testParent.querySelector("p");
  3. console.log(pfirst); // <p>1111</p>

浏览器支持程度：IE8+，firefox，chrome，safari3.1+，opera10+

 2.  querySelectorAll()方法

querySelectorAll()方法接收的参数与querySelector()方法一样，都是一个css选择符，但是返回的是所有匹配的元素，这个方法返回的是一个NodeList的实例。

如下代码演示：

  1. <div id="test">
  2.    <em class="selected">11111</em>
  3.     <em class="selected">22222</em>
  4.     <em>33333</em>
  5.     <em>44444</em>
  6. </div>

JS代码如下：

  1. // 取得div中所有em元素
  2. var em = document.getElementById("test").querySelectorAll('em');
  3. console.log(em); // NodeList
  4. console.log(em.length); //
  5.  
  6. // 第二种方式 也可以先使用querySelector
  7. var test = document.querySelector("#test");
  8. var em2 = test.querySelectorAll('em');
  9. console.log(em2); // NodeList
  10. console.log(em2.length); //
  11.  
  12. // 取得类为selected的所有元素
  13. var selected = document.querySelectorAll('.selected');
  14. console.log(selected); // <em class="selected">11111</em>
  15.               // <em class="selected">22222</em>
  16. // 也可以通过以下的方式获得所有的em元素
  17. var em = document.querySelectorAll('div em');
  18. console.log(em); // NodeList
  19. console.log(em.length); //

要取得返回的NodeList中的每一个元素，可以使用item()方法，也可以使用方括号的语法；

  1. var ems = document.querySelectorAll('#test em');
  2. for(var i = 0, ilen = ems.length; i < ilen; i++) {
  3.     console.log(ems[i]); // 取得每一项em
  4.     console.log(ems.item(i)); // 取得每一项em
  5. }

浏览器支持程度：IE8+，firefox，chrome，safari3.1+，opera10+

 3. matchesSelector()方法

这个方法接收一个参数，即css选择符，如果调用元素与该选择符匹配，返回true，否则，返回false；

如下代码：

  1. console.log(document.body.webkitMatchesSelector("body")); // true

IE9+通过msMatchesSelector()支持该方法，Firefox3.6+通过mozMatchesSelector()支持该方法；safari5+和chrome通过webkitMatchesSelector()支持该方法；因此我们可以包装一个函数，如下代码：

  1. function matchesSelector(element,selector) {
  2. if(element.MatchesSelector) {
  3.     return element.MatchesSelector(selector);
  4. }else if(element.msMatchesSelector) {
  5.     return element.msMatchesSelector(selector);
  6. }else if(element.webkitMatchesSelector) {
  7.     return element.webkitMatchesSelector(selector);
  8. }else if(element.mozMatchesSelector) {
  9.     return element.mozMatchesSelector(selector);
  10. }else {
  11.         throw new Error("Not supported");
  12.     }
  13. }
  14. console.log(matchesSelector(document.body,'body')); // true
  15. var test = document.querySelector('#test');
  16. console.log(matchesSelector(test,'#test')); // true

 4.   getElementsByClassName() 方法

该方法接收一个参数，即包含一个或者多个类名的字符串，返回带有指定类的所有元素的NodeList；传入多个类名时，类名的先后顺序不重要。

  1. <p class="p1">111</p>
  2. <p class="p1">222</p>
  3. <p class="p1">333</p>

console.log(document.getElementsByClassName("p1")); // 返回NodeList

支持getElementsByClassName()方法的浏览器有IE9+，firefox3+，safari3.1+,chrome和opera9.5+；

5.   classList属性

如下代码：

  1. <div class="aa bb cc" id="div">aaa</div>

我想删除aa这个类名的时候，以前需要如下写代码：

  1. var div = document.getElementById("div");
  2. // 首先，取得类名字符串并拆分成数组
  3. var classNames = div.className.split(/\s+/);
  4. var pos = -1,
  5.      i,
  6.     len;
  7. for(i = 0,len = classNames.length; i < len; i+=1) {
  8.     if(classNames[i] == 'aa') {
  9.         pos = i;
  10.         break;
  11.     }
  12. }
  13. // 删除类名
  14. classNames.splice(i,1);
  15. // 把剩下的类名拼成字符串并重新设置
  16. div.className = classNames.join(" ");
  17. // <div class="bb cc" id="div">aaa</div>

但是现在HTML5新增了一种操作类名的方式，可以让操作更简单也更方便，那就是所有元素添加classList属性。这个classList属性是新集合类型DOMTokenList的实例；DOMTokenList有一个表示自己包含多少元素的length属性，而要取得每个元素可以使用item()方法，也可以使用中括号；

还有以下方法：

add(value)：将给定的字符串值添加到列表中。如果值已经存在，就不添加了。

contains(value)：表示列表中是否存在给定的值，如果存在则返回true，否则返回false。

remove(value)：从列表中删除给定的字符串。

toggle(value)：如果列表中已经存在给定的值，删除它；如果列表中没有给定的值，添加它。

现在我们可以来看看使用上面的方法的优点如下，我们可以来做个demo，代码如下：

  1. <div class="aa bb cc" id="div">aaa</div>

JS如下：

  1. var div = document.getElementById("div");
  2. // 删除类名aa，如下方法即可
  3. div.classList.remove("aa");
  4. // html结构如下： <div class="bb cc" id="div">aaa</div>
  5. // 添加类名current，如下方法即可
  6. div.classList.add("current");
  7. // html结构变为如下 <div class="bb cc current" id="div">aaa</div>
  8.  
  9. // 切换aa类名
  10. div.classList.toggle("aa");
  11. // html结构变为如下 <div class="aa bb cc current" id="div">aaa</div>
  12. // 确定元素是否包含类名；
  13. console.log(div.classList.contains("aa")); // true

支持classList属性的浏览器有IE10+，firefox3.6+和chrome

HTML5新增自定义数据属性

HTML5中规定可以为元素添加非标准的属性，但要添加前缀data-,比如如下代码：

  1. <div id="myDiv" data-appId="12345" data-myname="Nicholas"></div>

添加了自定义属性之后，可以通过元素的dataset属性来访问自定义属性的值，dataset属性的值是DOMStringMap的一个实例，也就是一个名值对的映射；比如如下代码：

  1. //本例中使用的方法仅用于演示
  2. var div = document.getElementById("myDiv");
  3. console.log(div.dataset); // DOMStringMap {value: "12345", name: "Nicholas"}
  4. //取得自定义属性的值
  5. var value1 = div.dataset.value;
  6. console.log(value1); //
  7. var name1 = div.dataset.name;
  8. console.log(name1); // Nicholas
  9. //设置值
  10. div.dataset.value = 23456;
  11. div.dataset.name = "Michael";
  12. //有没有"myname"值呢？
  13. if (div.dataset.name){
  14.     console.log("Hello, " + div.dataset.name); // Hello, Michael
  15. }

浏览器支持的程度有；firefox6+和chrome浏览器；

你所不了解的javascript操作DOM的细节知识点(一)的更多相关文章

  1. JavaScript 操作 DOM 常用 API 总结

    文本整理了javascript操作DOM的一些常用的api,根据其作用整理成为创建,修改,查询等多种类型的api,主要用于复习基础知识,加深对原生js的认识. 基本概念 在讲解操作DOM的api之前, ...

  2. 使用原生 JavaScript 操作 DOM

    原文:https://www.sitepoint.com/dom-manipulation-vanilla-javascript-no-jquery/ 微软官方放弃了 IE10-,所以现在可以放心使用 ...

  3. Python javascript操作DOM

    文档对象模型(Document Object Model,DOM)是一种用于HTML和XML文档的编程接口.它给文档提供了一种结构化的表示方法,可以改变文档的内容和呈现方式.我们最为关心的是,DOM把 ...

  4. javaScript操作DOM对象（看三遍，敲三遍，写三遍！ 不会你找我）！！

    DOM是Document Object Model的缩写,即文档对象模型,是基于文档编程的一套API 使用javaScript操作DOM对象通常分为三类:1.DOM CORE        2.HTM ...

  5. 第四章 JavaScript操作DOM对象

    第四章   JavaScript操作DOM对象 一.DOM操作 DOM是Document Object Model的缩写,即文档对象模型,是基于文档编程的一套API接口,1988年,W3C发布了第一级 ...

  6. JavaScript 操作DOM对象

    1)JavaScript  操作DOM對象 1.DOM:是Document  Object  Model 的缩写,及文档对象模型 2.DOM通常分为三类:DOM Core(核心).HTML-DOM 和 ...

  7. 【repost】Javascript操作DOM常用API总结

    Javascript操作DOM常用API总结 文本整理了javascript操作DOM的一些常用的api,根据其作用整理成为创建,修改,查询等多种类型的api,主要用于复习基础知识,加深对原生js的认 ...

  8. JQuery制作网页—— 第三章 JavaScript操作DOM对象

    1. DOM:Document Object Model(文档对象模型):          DOM操作:                   ●DOM是Document Object Model的缩 ...

  9. 使用jQuery快速高效制作网页交互特效-----JavaScript操作DOM对象

    一.DOM操作分类 使用JavaScript操作DOM时通常分为三类:DOM    Core.HTMl--DOM和CSS-DOM 二.访问节点 节点属性 三.节点信息 四.操作节点的属性 语法: ge ...

随机推荐

  1. SSM(Spring+SpringMvc+Mybatis)整合笔记

    1.使用开发工具 jdk1.8 eclipse Tomcat7.0 MySql 2.创建数据库和表,由于重点是整合,所以数据库就随意加几条数据. 3.创建动态Web项目(推荐使用Maven可以用配置来 ...

  2. JavaScript中的window对象的属性和方法；JavaScript中如何选取文档元素

    一.window对象的属性和方法 ①setTimeout()方法用来实现一个函数在指定毫秒之后运行,该方法返回一个值,这个值可以传递给clearTimeout()用于取消这个函数的执行. ②setIn ...

  3. csharp: FTP Client Library using System.Net.FtpClient and FluentFTP,测试中存在的BUG修正

    https://netftp.codeplex.com/ /// <summary> /// Gets a file listing from the server. Each FtpLi ...

  4. Push notification - Caused by java.io.IOException toDerInputStream rejects tag

    苹果推送 : 文件不是P12文件当生成一个P12,需要选择两个,在钥匙串访问的私钥和证书.

  5. Maven 环境搭建及使用（win10）

    最近由于公司项目需要,学习了一下Maven 环境的配置.这里把配置步骤和简单的操作做一个汇总. 一.Maven环境的搭建 1.配置java环境(这里不详述过程,可参考:http://www.cnblo ...

  6. 【BI学习笔记】适合集成到项目里的BI：Wyn Enterprise

    近日,我收到葡萄城的邮件,讲葡萄城开始进军BI领域,发布了一套BI和报表工具,叫Wyn Enterprise. 之前了解过PowerBI等面向终端用户的BI工具,我发现BI工具与Wyn Enterpr ...

  7. js,H5本地存储

    //存储本地存储----setItem(存储名称,数据名称) var c={name:"man",sex:"woman"}; localStorage.setI ...

  8. 三. Redis 主从复制

    特点 1. Master可以拥有多个Slave 2. 多个Slave除可以连接一个Master外,还可以连接多个Salve(避免Master挂掉不能同步,当Master挂掉,其中一个Slave会立即变 ...

  9. (后端)出现org.hibernate.NonUniqueResultException的原因即解决办法

    百度出来的资料解决问题: 一个问题,事务处理完毕以后页面没有刷新.刚开始以为是前台js的问题,后来检查js没有任何问题,跟踪到后台发现后台报错了,错误信息如下:org.hibernate.NonUni ...

  10. JavaWeb:jsp

    本文内容: JSP的介绍 jsp的使用 EL表达式 JSTL的使用 首发日期:2018-06-18 JSP的介绍: JSP全称Java Server Pages. 与静态网页格式的html不同的是,j ...