你所不了解的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代码如下：
<div id="test"> <p>aaaaaap> <p>bbbbbbp> <p>ccccccp> div>
JS如下：
var test = document.getElementById("test"); if(test.nodeType === Node.ELEMENT_NODE) { alert(1) }
如上代码在IE8及以下下是不行的，会报错，如下：
因为IE没有公开Node类型的构造函数，因此在IE8-下会有错误，但是我们可以通过数值来比较，比如上面的要比较元素节点的话，我们可以使用1来比较，同理属性节点是2，文本节点是3；如下代码：
var test = document.getElementById("test"); // 下面的所有的浏览器都支持 if(test.nodeType == 1) { alert(1) }
理解nodeName与nodeValue
nodeName保存的是元素的标签名，而nodeValue一般都是null；我们可以看如下代码，没有特殊的说明，HTML代码都是上面的，因此这边就不贴代码了；如下JS代码测试：
var test = document.getElementById("test"); if(test.nodeType == 1) { console.log(test.nodeName); // 打印DIV console.log(test.nodeValue); // 打印null }
理解节点关系
doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Documenttitle>
head>
<body>
body>
html>
如上代码，我们可以把head和body是html的子元素，同理html是他们的父级元素，那么head和body就是兄弟元素了，那么head及body里面的就是子元素了，我们需要明白的是每个节点都有一个childNodes属性，其保存的是类似数组的元素，其也有length属性，但是他不是数组Array的实例，比如我们可以看看如下测试代码即可：
<div id="test"> <p>aaaaaap> <p>bbbbbbp> <p>ccccccp> div>
JS代码如下：
var test = document.getElementById("test"); if(test.nodeType == 1) { console.log(test.childNodes); console.log(test.childNodes.length); }
如上代码，在标准浏览器下及IE9+下 第一行打印如下：
[text, p, text, p, text, p, text, item: function]
第二行打印7 长度为7，因为他们把文本节点那个空格也包括进去了，但是在IE8及以下，长度为3，他们不包括文本空格的节点，因此想要统一的话，我们可以编写HTML代码去掉空格，如下HTML代码即可；
aaaaaa bbbbbb cccccc
这个问题稍后在仔细考虑，我们现在来看看如何取得子元素，我们可以使用2种方法，第一种是使用中括号[index]索引，第二种是使用item[index]索引，如下代码：
console.log(test.childNodes[1]); //bbbbbb
console.log(test.childNodes.item(1)); //bbbbbb
但是他们并不是数组，我们可以测试下代码即可，如下代码：
console.log(Object.prototype.toString.call(test.childNodes) === "[object Array]"); // false
但是我们使其转换为数组，如下代码：
//在IE8 及之前版本中无效 var arrayOfNodes = Array.prototype.slice.call(test.childNodes,0); console.log(arrayOfNodes instanceof Array); // true
不过在IE8及之前不生效；由于IE8及更早版本将NodeList实现为一个COM对象，而我们不能像使用JScript对象那样使用对象，要想在IE低版本中转换为Array的形式，我们可以像下面一样封装一个方法即可；
function convertToArray(nodes){ var array = null; try { array = Array.prototype.slice.call(nodes, 0); //针对非IE 浏览器 } catch (ex) { array = new Array(); for (var i=0, len=nodes.length; i < len; i++){ array.push(nodes[i]); } } return array; } var test = document.getElementById("test"); var testArray = convertToArray(test.childNodes); console.log(testArray instanceof Array); // true
理解parentNode（父节点），previousSibling(上一个兄弟节点)，nextSibling（下一个兄弟节点）;
每个节点都有一个parentNode属性，该属性指向文档中父节点，previousSibling是指当前节点的上一个同胞节点，nextSibling是指当前节点的下一个同胞节点，比如如下代码：
var test = document.getElementById("test"); if(test.nodeType == 1) { var secodeChild = test.childNodes[1]; console.log(secodeChild); //aaaaaa
bbbbbb
cccccc
bbbbbb
console.log(secodeChild.previousSibling); //aaaaaa
console.log(secodeChild.nextSibling); //cccccc
}
如果该节点列表中只有一个节点的话，那么该节点的previousSibling和nextSibling都为null；父节点的firstChild指向了父节点中第一个节点；如下代码：
<div id="test"><p class="a">aaaaaap><p class="b">bbbbbbp><p class="c">ccccccp>div>
JS如下：
var test = document.getElementById("test"); if(test.nodeType == 1) { console.log(test.firstChild); //aaaaaa
console.log(test.lastChild); //cccccc
}
父节点的firstChild始终等于父节点的.childNodes[0],父节点的lastChild始终等于父节点的.childNodes[父节点的.childNodes.length - 1]; 如下代码：
console.log(test.firstChild === test.childNodes[0]); // true console.log(test.lastChild === test.childNodes[test.childNodes.length - 1]); // true
如果没有子节点的话，那么firstChild和lastChild都指向为空null;
hasChildNodes()：如果需要判断该父节点有没有子节点的话，可以使用该方法判断，返回的是一个布尔型，有返回true，没有返回false，如下代码：
<div id="test"><p class="a">aaaaaap><p class="b">bbbbbbp><p class="c">ccccccp>div>
JS代码如下：
var test = document.getElementById("test"); console.log(test.hasChildNodes()); // true
如果是如下的 就返回false；如下代码：
var test = document.getElementById("test");
console.log(test.hasChildNodes()); // false
ownerDocument: 所有节点都有最后一个属性是ownerDocument，该属性指向表示整个文档的文档节点，这种关系表示的任何节点都属于它所在的文档，任何节点都不能同时存在两个或更多文档中，通过这个属性，我们可以不必在节点层次中通过层层回溯到达顶端，而是可以直接访问文档节点；如下测试代码：
<div id="test"> <p class="a">11p> div> var test = document.getElementById("test"); console.log(test.ownerDocument); // document var p = test.ownerDocument.getElementsByTagName("p"); console.log(p); // <p class="a">11p>
appendChild(): 用于向childNodes列表的末尾添加一个节点；返回的是新增加的节点；如下代码：
<div id="test"> <p class="a">11p> div>
JS代码如下：
var test = document.getElementById("test"); var newNode = document.createElement("p"); var returnNode = test.appendChild(newNode); console.log(returnNode); // console.log(returnNode === newNode); // true console.log(test.lastChild === newNode); // true
insertBefore(): 该方法是将新节点插入到指定的节点的前面去，该方法接收2个参数，要插入的节点和作为参照的节点；插入节点后，被插入的节点会变成参照节点的前一个同胞节点，同时被方法返回，如下代码：
<div id="test"> <p class="a">11p> div>
JS代码如下：
var test = document.getElementById("test"); var newNode = document.createElement("div"); var returnNode = test.insertBefore(newNode,test.childNodes[0]); console.log(returnNode); // console.log(returnNode === newNode); // true
插入节点后，结构变成如下：
<div id="test"> <div>div> <p class="a">11p> div>
但是如果参照节点为null的话，那么就会把新节点插入到最后面去了，如下代码：
var test = document.getElementById("test"); var newNode = document.createElement("div"); var returnNode = test.insertBefore(newNode,null);
插入后HTML结构如下：
<div id="test"> <p class="a">11p> <div>div> div>
我们还可以更深入的看下如下测试代码：
var test = document.getElementById("test"); var newNode = document.createElement("div"); // 插入后成为最后一个节点 var returnNode = test.insertBefore(newNode,null); console.log(returnNode === test.lastChild); // true // 插入后成为第一个节点 var returnNode = test.insertBefore(newNode,test.firstChild); console.log(returnNode === newNode); // true console.log(newNode === test.firstChild); // true // 插入到最后一个子节点的前面 var returnNode = test.insertBefore(newNode,test.lastChild); console.log(returnNode === test.childNodes[test.childNodes.length - 2]); // true
replaceChild(); 该方法接收2个参数，要插入的节点和要替换的节点，要替换的节点将由这个方法返回并从文档树中被移除，同时由插入的节点占据其位置，如下代码：
<div id="test"><p class="a">11p><p class="b">22p>div>
JS代码如下：
var test = document.getElementById("test"); var newNode = document.createElement("div"); // 替换第一个节点 var returnNode = test.replaceChild(newNode,test.firstChild); console.log(returnNode); //11
替换后html代码结构变为如下：
<div id="test"><div>div><p class="b">22p>div>
替换最后一个节点代码如下：
var test = document.getElementById("test"); var newNode = document.createElement("div"); // 替换最后一个节点 var returnNode = test.replaceChild(newNode,test.lastChild); console.log(returnNode); //22
替换后的代码如下：
<div id="test"><p class="a">11p><div>div>div>
removeChild()：移除节点，该方法接收一个参数，即要移除的节点；
被移除的节点将成为返回值，如下代码：
var test = document.getElementById("test"); var newNode = document.createElement("div"); // 移除第一个节点 var returnNode = test.removeChild(test.firstChild); console.log(returnNode); //11
移除后的代码结构变为如下：
<div id="test"><p class="b">22p>div>
移除最后一个节点的代码如下：
// 移除最后一个节点 var returnNode = test.removeChild(test.lastChild); console.log(returnNode); //22
移除后的代码结构变为如下：
<div id="test"><p class="a">11p>div>
cloneNode(): 克隆一个相同的副本，该方法接收一个布尔值参数，如果为true的话，说明是深复制，复制该节点及整个子节点书，如果为false的话，只复制该节点本身，比如如下代码：
var test = document.getElementById("test"); var deeplist = test.cloneNode(true); console.log(deeplist); //如果是浅复制的如下代码： var test = document.getElementById("test"); var deeplist = test.cloneNode(false); console.log(deeplist);//11
22
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列表访问文档元素；如下测试代码：
console.log(document.documentElement); // 指向html的引用 console.log(document.childNodes[0]); // console.log(document.firstChild); // console.log(document.firstChild === document.childNodes[0]); // true console.log(document.body); // 指向body的引用
所有的浏览器都支持document.documentElement 和 document.body属性;
title: 通过这个属性可以取得网页的标题，如下测试代码：
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代码如下：
<input name="aa"/> <input name="bb"/>
JS代码如下：
var inputs = document.getElementsByTagName("input"); console.log(inputs.namedItem("aa")); //
我们还可以通过方括号的语法来访问，如下代码：
console.log(inputs["aa"]); //
要想取得文档中所有的元素，可以向getElementsByTagName()中传入”*”; 星号表示全部的意思；
getElementsByName(); 该方法也是HTMLDocument类型才有的方法，这个方法会返回带有给定name特性的所有元素，如下测试代码：
<input name="aa" type="radio"/> <input name="aa" type="radio"/> var aa = document.getElementsByName("aa"); console.log(aa); // object console.log(aa.length); // 2
该方法也会返回一个HTMLCollection.
浏览器支持程度IE，firefox，chrome都支持；
Element类型
Element节点有以下特征：
nodeType的值为1；
nodeName的值为元素的标签名；
nodeValue的值为null；
parentNode可能是Document或Element
要访问元素的标签名，可以使用nodeName属性，也可以使用tagName属性，这两个属性会返回相同的值，如下代码：
<div id="test">div> var test = document.getElementById("test"); console.log(test.tagName); // DIV console.log(test.nodeName); // DIV console.log(test.nodeValue); // null; console.log(test.parentNode); // body console.log(test.nodeType); // 1
理解HTML元素中的获取属性的方法
所有HTML元素都由HTMLElement类型表示，HTMLElement类型直接继承Element；如果想要取得HTML元素的特性的话，有下面几个方法：
getAttribute(); 获取元素的属性的方法；如下测试代码：
<div id="test" class="testName" title="aa">div> var test = document.getElementById("test"); console.log(test.getAttribute("id")); // test console.log(test.getAttribute("class")); // testName console.log(test.getAttribute("title")); // aa
注意：上面的获取类名在IE8+及标准浏览器下都是使用获取属性class来取得类名，上面的如果在IE7下会返回null, 但是在IE7及以下是使用className这个属性来获取的；如下代码：在IE7下测试：
console.log(test.getAttribute("className")); // testName
当然也可以取得自定义的属性；如下代码：
console.log(test.getAttribute("data-value")); // test1
setAttribute() 设置元素的属性；该方法接收2个参数，第一个参数是属性名称，第二个参数是对应的值；如果该值存在，则会以现在的值替换之前的值，如果属性名不存在，则会创建该属性，并指定该属性的值；如下代码：
<div id="test">div> // JS代码如下： var test = document.getElementById("test"); test.setAttribute("id",'test'); test.setAttribute("class","testName"); test.setAttribute("title","aa"); test.setAttribute("data-value","test1");
生成HTML结构如下：
removeAttribute(); 删除元素的特性；如下代码：
<div id="test" class="testName" title="aa" data-value="test1">div>
JS代码如下：
var test = document.getElementById("test"); test.removeAttribute("id"); test.removeAttribute("class"); test.removeAttribute("title"); test.removeAttribute("data-value");
IE7及以下删除类名需要使用className;
attributes属性
Element类型是使用attributes属性的唯一一个dom节点类型，attributes属性包含一个NamedNodeMap集合；该对象有以下方法：
getNamedItem(name): 返回nodeName属性等于name的节点；
attributes属性中包含一系列节点，每个节点的nodeName就是特性的名称，而节点的nodeValue就是节点值，要取得元素id的特性，如下代码：
<div id="test" class="testName" title="aa" data-value="test1">div>
JS代码如下：
var div = document.getElementById("test"); var id = div.attributes.getNamedItem("id").nodeValue; console.log(id); // test
我们也可以通过中括号的语法来获取的，如下代码：
var id = div.attributes['id'].nodeValue; 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()方法返回表示被删除特性的节点；
如下代码：
JS代码如下：
var div = document.getElementById("test"); var oldAttr = div.attributes.removeNamedItem("id"); console.log(oldAttr); // 返回是被删除的节点 id="test"
现在的html结构变成如下：
如上方法：目前IE，firefox，chrome浏览器都支持；
但是上面我们有getAttribute,setAttribute(),removeAttribute()方法，我们可以使用这些方法足够代替上面介绍的几个方法，但是如果想遍历一个元素上有多少个属性时，attributes这个就可以派上用上了，如下代码：
HTML代码如下：
<div id="test" class="testName" title="aa" data-value="test1">div>
JS代码如下：
var div = document.getElementById("test"); function outputAttributes(element) { var arrs = new Array(); var attrName, attrValue, i, len; for(i = 0, len = element.attributes.length; i < len; i++) { attrName = element.attributes[i].nodeName; attrValue = element.attributes[i].nodeValue; arrs.push(attrName + "='" + attrValue + "'"); } return arrs.join(" "); } console.log(outputAttributes(div));
结果打印如下：
id='test' class='testName' title='aa' data-value='test1'
上面的函数使用一个数组来保存名值对，最后再以空格为分隔符将它们拼接起来，但是上面的代码我们需要注意两点：
- 针对attributes对象中的特性，不同的浏览器返回的顺序不同。
- IE7及更早的版本会返回HTML元素中所有可能的特性，包括没有指定的特性；
针对IE7的问题我们可以进行改进，我们都知道，每个特性节点都有一个名为specified的属性，这个属性值如果为true，则意味着要么在HTML中指定了相应的特性，要么通过setAttribute方法设置了该特性，在IE中，所有为设置过的特性该属性的之都为false；如下代码：
var div = document.getElementById("test"); function outputAttributes(element) { var arrs = new Array(); var attrName, attrValue, i, len; for(i = 0, len = element.attributes.length; i < len; i++) { attrName = element.attributes[i].nodeName; attrValue = element.attributes[i].nodeValue; if(element.attributes[i].specified) { arrs.push(attrName + "='" + attrValue + "'"); } } return arrs.join(" "); } console.log(outputAttributes(div));
理解元素的子节点
元素可以有任意数目的子节点和后代节点，元素的childNodes属性中它包含了它的所有子节点，这些子节点可能是元素，文本节点，注释或处理指令；不同的浏览器子节点的个数不一样，下面我们来看看demo如下：
<ul id="list"> <li>11li> <li>22li> <li>33li> ul>
JS代码如下：
var list = document.getElementById("list"); console.log(list.childNodes); console.log(list.childNodes.length);
我们之前在上面讲过，在标准浏览器下(IE9+,firefox,chrome)下，打印的长度是7个，因为他们把空格也包含上去，在IE8-及以下的浏览器返回的是3个子元素，这是表现的正常情况下，但是如果我现在把html元素的空格都去掉的话，那么所有的浏览器都会返回3个子元素，如下代码：
<ul id="list"><li>11li><li>22li><li>33li>ul>
JS代码如下：
var list = document.getElementById("list"); console.log(list.childNodes); console.log(list.childNodes.length);
那么平时我们不可能都这样小心小意的编写html代码的，因为一步小心就有一个空格产生，因此我们可以如下判断下是不是元素节点；如下代码演示：
<ul id="list"> <li>11li> <li>22li> <li>33li> ul>
JS代码如下：
var list = document.getElementById("list"); var arrs = []; for(var i = 0, ilen = list.childNodes.length; i < ilen; i++) { var curElement = list.childNodes[i]; if(curElement.nodeType === 1){ arrs.push(curElement); } } console.log(arrs); console.log(arrs.length); // 3
如上代码在所有的浏览器都支持，通过判断该元素是不是元素节点，然后在执行后续操作；不是元素节点都会过滤掉，因此返回的长度都为3；
理解Text类型
Text节点具有以下特征：
nodeType的值为3；
nodeName的值为”#text”;
nodeValue的值为节点所包含的文本；
parentNode是一个Element；
没有子节点；
- 创建文本节点；
可以使用document.createTextNode()创建新文本节点，这个方法需要一个参数，即要插入的文本，如下代码：
var element = document.createElement("div"); var text = document.createTextNode("aa"); element.appendChild(text); document.body.appendChild(element);
2. 分割文本节点splitText(offset); 从offset指定的位置将当前的文本节点分成2个文本节点；如下代码：
var element = document.createElement("div"); var text = document.createTextNode("aabbbccc"); element.appendChild(text); document.body.appendChild(element); var newNode = element.firstChild.splitText(5); console.log(element.firstChild.nodeValue); // aabbb console.log(newNode.nodeValue); // ccc
console.log(element.childNodes.length); // 2
浏览器支持的程度有IE，firefox,chrome都支持；
理解DOM操作—动态插入脚本
我们动态插入JS脚本，常见的写法有如下代码即可插入：
var script = document.createElement("script"); script.type ="text/javascript"; script.src = 'a.js'; document.body.appendChild(script);
即可在body最后面动态插如a.js，此动态插入不会堵塞浏览器加载；我们为了更加扩张性，我们也可以封装一个函数，如下代码：
function loadScript(url) { var script = document.createElement("script"); script.type = "text/javascript"; script.src = url; document.body.appendChild(script); } loadScript("a.js");
当页面有多个js需要动态插入的话，可以依次调用loadScript函数即可；
但是假如我们现在有这么一个需求，动态加载JS完后，我想在这后面做点事情，我们都知道，动态加载也可以理解为异步加载，不会堵塞浏览器，但是我们需要如何知道动态JS已经加载完了呢？
我们之前讲过一篇文章是 “Javascript事件总结”中有判断JS动态加载完后使用load事件来监听js是否动态加载完，现在我们再来复习下load事件；
Javascript中最常用的一个事件是load，当页面加载完后(包括所有的图片，javascript文件，css文件等外部资源)。就会触发window上面的load事件；目前可以有2种触发load事件，一种是直接放在body上面触发；比如如下代码：
第二种是通过JS来触发，如下代码：
EventUtil.addHandler(window,’load’,function(event){ alert(1); });
上面的EventUtil.addHandler 是我们之前在javascript事件总结中封装的JS函数，现在我们直接拿过来使用，如下代码：
var EventUtil = { addHandler: function(element,type,handler) { if(element.addEventListener) { element.addEventListener(type,handler,false); }else if(element.attachEvent) { element.attachEvent("on"+type,handler); }else { element["on" +type] = handler; } }, removeHandler: function(element,type,handler){ if(element.removeEventListener) { element.removeEventListener(type,handler,false); }else if(element.detachEvent) { element.detachEvent("on"+type,handler); }else { element["on" +type] = null; } }, getEvent: function(event) { return event ? event : window.event; }, getTarget: function(event) { return event.target || event.srcElement; }, preventDefault: function(event){ if(event.preventDefault) { event.preventDefault(); }else { event.returnValue = false; } }, stopPropagation: function(event) { if(event.stopPropagation) { event.stopPropagation(); }else { event.cancelBubble = true; } } };
下面我们来看看如何使用JS事件来判断JS是否加载完成的代码，我们可以使用load事件来监听，如下代码：
EventUtil.addHandler(window,'load',function(){ var script = document.createElement("script"); EventUtil.addHandler(script,'load',function(event){ console.log(script.src); }); script.src = 'a.js'; document.body.appendChild(script); });
如上代码，script元素也会触发load事件，以便可以确定动态加载jS是否加载完成，上面的代码指定src属性和指定的事件处理程序的事件可以调换位置，先后顺序不重要，如上代码，我们也可以这样写，如下代码：
EventUtil.addHandler(window,'load',function(){ var script = document.createElement("script"); script.src = 'a.js'; document.body.appendChild(script); EventUtil.addHandler(script,'load',function(event){ console.log(script.src); }); });
目前只有IE9+，Firefox，opera，chrome和safari3+支持，IE8及以下不支持该load事件，因此我们需要针对IE8及以下做处理；
理解readystatechange事件
IE为DOM文档中的某些部分提供了readystatechange事件，这个事件的目的提供与文档或元素的加载的状态有关信息，此事件提供了下面5个值中的一个；
uninitialized（未初始化）：对象存在但尚未初始化；
loading(正在加载)：对象正在加载数据；
loaded(加载完毕): 对象加载数据完成；
interactive(交互)： 可以操作对象了，但没有完全加载；
complete(完成)：对象已经加载完成；
