1、DOM简介。
当页面加载时，浏览器会创建页面的文档对象模型（Document Object Model）。文档对象模型定义访问和处理HTML文档的标准方法。DOM 将HTML文档呈现为带有元素、属性和文本的树结构，即节点树。通过DOM，JS可创建动态的HTML，可以使网页显示动态效果并实现与用户的交互功能。JS能够改变页面中所有的HTML元素、属性和CSS样式，并对页面中所有事件做出响应。所以学习JS的起点就是处理网页，处理网页就需要使用DOM进行操作。
2、DOM获取元素。
JS要想操作HTML元素，那么首先就必须先找到该元素。通常使用以下几种方法完成：
通过元素设置的id找到HTML元素。
通过标签名找到HTML元素。
通过元素设置的名称(name)找到HTML元素。
所谓的DOM，实际上就是document，获取元素就是操作document。
(1)、通过id找到元素
方法：document.getElementById('id');
网页是由标签将信息组合起来的，id属性值是唯一的，就像身份证一样，通过一个身份证可以找到相对应的人，所以通过该方法，可以获取到与之相对应的标签，而获取的元素在JS中是一个对象，若想对元素进行操作，则需要通过他的属性或方法。
(2)、通过标签名找到元素
方法：document.getElementsByTagName('Tagname');
通过该方法，返回的是带有指定标签名的对象的集合，也就是以数组的形式返回，返回的顺序是他们在文档中的顺序。
(3)、通过name找到元素
方法：document.getElementsByName('name');
该方法与getElementById()方法有点相似，都是通过设置的属性值找到元素，只不过该方法是通过设置的name属性值查找元素。name属性在文档中可能不唯一，所以该方法返回的也是元素的数组，而不是一个元素。
<body> <input name="txt" type="text" value="">
<input name="txt" type="text" value=""><br>
<input name="txt" type="text" value="">
<input name="txt" type="text" value=""><br>
<input name="txt" type="text" value="">
<input name="aaa" type="text" value="">
<script>
//获取所有name值为txt的元素
var oTxt=document.getElementsByName("txt");
//获取元素的个数
alert(oTxt.length); //返回：
//获取第二个元素的值
alert(oTxt[].value); //返回：
</script>
</body>
既然可以通过id找到元素，那么也就可以通过class找到元素。className属性用于设置或者返回元素的class类名。
语法：object.className = 'className'
该方法可以控制class类名，返回元素的class属性，作用是可以为网页中某个元素指定一个className来更改该元素的外观。
实例：简单的网页换肤效果
<html>
<head>
<meta charset="UTF-">
<title>网页换肤</title>
<style>
body{
background:lightgreen;
}
.col1{
background:lightgray;
}
.col2{
background:lightblue;
}
.col3{
background:violet;
}
.col4{
background:pink;
}
.col5{
background:#ffff99;
}
</style>
</head>
<body id="boy">
点击切换：<input type="button" value="灰色" onclick="gr()">
<input type="button" value="蓝色" onclick="bl()">
<input type="button" value="紫色" onclick="vi()">
<input type="button" value="粉色" onclick="pi()">
<input type="button" value="橘色" onclick="or()">
<script>
var x = document.getElementById('boy');
function gr(){
x.className='col1';
}
function bl(){
x.className='col2';
}
function vi(){
x.className='col3';
}
function pi(){
x.className='col4';
}
function or(){
x.className='col5';
}
</script>
</body>
</html>这只是一个简单的切换背景色效果，如果想切换网页的整体样式，可以使用外部CSS文件，通过JS改变link标签的href属性来完成。
如果想设置多个class类名相同的元素的样式，就需要借助数组的方法来完成，其实现原理也很简单，首先通过id获取其父元素，再获取父元素下所有子元素的标签名，获取标签名返回的是元素的数组，所以就可以和访问数组一样的方法来访问元素的数组，那么先使用循环遍历该元素数组，再做判断，如果这个元素的className等于我们设置的class属性值，就说明这是我们要找的元素。
实例：将有序列表中所有class属性值为"col"的元素背景颜色设置为绿色。
<html>
<head>
<meta charset="UTF-">
<title>封装getByClass函数</title>
<script>
//第一个参数为获取的父元素，第二个参数为class属性值。
function getByClass(oParent,aClass){
//空数组可以把找到的所有className都存放在里边，最后返回。
var aResult=[];
//通过标签名获取父元素下所有子元素。标签名不固定，所以设置为*，便于传入。
var aEle=oParent.getElementsByTagName('*');
//循环遍历返回的子元素数组
for(var i=0;i<aEle.length;i++){
//如果当前子元素的className等于传入的class属性值，则将其添加到数值中。
if(aEle[i].className==aClass) aResult.push(aEle[i]);
}
//最后将这个数组返回
return aResult;
}
</script>
</head>
<body>
<ol id="o">
<li>热点</li>
<li class="col">美食</li>
<li>数码</li>
<li class="col">科技</li>
<li>社会</li>
<li class="col">养生</li>
</ol>
<script>
//封装函数的使用：
//先通过id获取父元素
var aOl=document.getElementById('o');
//再调用封装好的函数传入参数，获取的父元素，子元素的class属性值
var oCol=getByClass(aOl,'col');
//最后循环遍历，设置样式
for(var i=0;i<oCol.length;i++){
oCol[i].style.background='green';
}
</script>
</body>
</html>
下面是一个通过class属性值获取元素的封装函数，方便以后使用。
<!DOCTYPE html><html><head> <meta charset="UTF-">
<title>封装getByClass函数</title>
<script> //第一个参数为获取的父元素，第二个参数为class属性值。
function getByClass(oParent,aClass){
//空数组可以把找到的所有className都存放在里边，最后返回。
var aResult=[];
//通过标签名获取父元素下所有子元素。标签名不固定，所以设置为*，便于传入。
var aEle=oParent.getElementsByTagName('*');
//循环遍历返回的子元素数组
for(var i=;i<aEle.length;i++){
//如果当前子元素的className等于传入的class属性值，则将其添加到数值中。
if(aEle[i].className==aClass) aResult.push(aEle[i]);
}
//最后将这个数组返回
return aResult;
}</script></head><body><ol id="o">
<li>热点</li>
<li class="col">美食</li>
<li>数码</li>
<li class="col">科技</li>
<li>社会</li>
<li class="col">养生</li>
</ol><script>//封装函数的使用：//先通过id获取父元素var aOl=document.getElementById('o');
//再调用封装好的函数传入参数，获取的父元素，子元素的class属性值var oCol=getByClass(aOl,'col');
//最后循环遍历，设置样式for(var i=;i<oCol.length;i++){
oCol[i].style.background='green';
}</script></body></html>3、DOM操作。
获取到HTML元素之后，就可以进行相应的操作。
(1)、改变HTML
修改HTML内容的最简单的方法时使用 innerHTML 属性。innerHTML顾名思义，inner就是内部的，既然是HTML，那么就可以给里边放HTML。该属性可用于获取和替换HTML元素的内容。
语法：document.getElementById(id).innerHTML = new HTM
<body> <h id="tit">原标题</h>
<script>
//改变原有标题
var aH=document.getElementById('tit');
aH.innerHTML='新标题';
</script>
<div id="div" style="width:px;height:px;border:px solid black;"></div>
<script>
//创建HTML内容
var oDiv=document.getElementById('div');
oDiv.innerHTML='<h>我是h标题</h><p>我是一个段落</p>';
</script>
</body>
(2)、操作元素属性
修改元素属性最简单的方法就是直接修改，语法：document.getElementById(id).属性名 = new value 比如修改图片src属性的指向路径。
此外还可以通过DOM方法获取、添加、删除元素的属性。
①、getAttribute()
getAttribute()方法通过元素节点的属性名获取属性的值。
语法：elementNode.getAttribute(name) name是想要获取的元素节点的属性名
②、setAttribute()
setAttribute()方法添加一个新属性并指定值，或者把一个现有的属性设定为指定的值。
语法：elementNode.setAttribute(name,value) name是属性名，value是属性值。
③、removeAttribute()
removeAttribute()方法可删除元素的属性。
语法：elementNode.removeAttribute(name) name是属性名。
<!DOCTYPE html> <html>
<head>
<meta charset="UTF-">
<title>JavaScript实例</title>
</head>
<body>
<input id="txt" type="text">
<input id="btn" type="button" value="按钮">
<script>
var oTxt=document.getElementById('txt');
var oBtn=document.getElementById('btn');
//获取按钮value属性的值
var a=oBtn.getAttribute('value');
alert(a); //返回：按钮
oBtn.onclick=function (){
//操作元素属性有三种方法：
//第一种方法
//oTxt.value='请输入文字';
//第二种方法
//oTxt['value']='请输入文字';
//第三种方法
//修改文本框value属性的值
oTxt.setAttribute('value','请输入文字');
//删除按钮type属性
oBtn.removeAttribute('type');
//删除后默认为文本框
};
</script>
</body>
</html>
(3)、改变CSS
改变HTML元素的CSS样式可直接使用该语法：document.getElementById(id).style.样式名 = new style
<!DOCTYPE html><html><head> <meta charset="UTF-">
<title>JavaScript实例</title>
<style>#div{ height:px;
width:px;
border:px solid black;
padding:px;
}p{ line-height:px;
text-indent:em;
}</style></head><body><h>HTML DOM</h><div id="div">
<h>JS可以使网页添加动态效果并实现与用户交互的功能。</h>
<p>. JS能够改变页面中所有的 HTML 元素。</p>
<p>. JS能够改变页面中所有的 HTML 属性。</p>
<p>. JS能够改变页面中所有的 HTML 元素的CSS样式。</p>
</div><input type="button" value="改变颜色" onclick="color()">
<input type="button" value="改变宽高" onclick="hig()">
<input type="button" value="隐藏内容" onclick="none()">
<input type="button" value="显示内容" onclick="block()">
<input type="button" value="取消设置" onclick="cancel()">
<script>var oDiv = document.getElementById('div');
function color(){
oDiv.style.color = 'white';
oDiv.style.fontFamily = 'Microsoft YaHei';
oDiv.style.backgroundColor = 'green';
}function hig(){
oDiv.style.width = 'px';
oDiv.style.height = 'px';
oDiv.style.border = 'px solid #ccc';
}function none(){
oDiv.style.display = 'none';
}function block(){
oDiv.style.display = 'block';
}//取消设置function cancel(){
var clean = confirm('确定取消所有设置？');
if(clean == true){
oDiv.removeAttribute('style');
}
}</script></body></html>上面的代码，通过style设置的样式，都是行间样式，可以使用火狐的Firebug点击相应的按钮，就能看到所有设置的CSS样式都出现在了行间。
可以直接通过style获取和设置CSS样式，那么有没有更简洁的方法呢？可以借助于函数使用JS的内置对象arguments完成，所谓arguments，就是可变参，不定参，参数的个数可变，是一个参数数组，无需指出参数名，就可访问他们，但是为了增强可读性，给参数取名，还是很有必要的。
<!DOCTYPE html><html><head> <meta charset="UTF-">
<title>JavaScript实例</title>
</head><body><div id="div" style="width:px;height:px;background:red"></div>
<script>//获取行间样式function css(){
//如果传入参数的个数等于
if(arguments.length==){
//则返回第二个参数样式名的值
return arguments[].style[arguments[]];
}
else{
//否则就是设置CSS样式
//第二个参数样式名的值就等于传入的第三个参数
arguments[].style[arguments[]]=arguments[];
}
}var oDiv=document.getElementById('div');
alert(css(oDiv,'width')); //获取对象的宽 返回：px
css(oDiv,'background','green'); //将对象的背景颜色改为绿色
</script></body></html><!DOCTYPE html><html><head> <meta charset="UTF-">
<title>获取行间样式</title>
<script>function css(obj, name, value){
if(arguments.length==){
return obj.style[name];
}
else{
obj.style[name]=value;
}
}</script></head><body><div id="div" style="width:px;height:px;background:red"></div>
<script>var oDiv=document.getElementById('div');
alert(css(oDiv,'width')); //获取div的宽
css(oDiv,'background','green'); //设置div的背景颜色
</script></body></html>我们都知道，在实际的WEB项目开发中，要遵循结果、表现、行为相分离的原则，以增强可读性，优化代码，便于后期维护。所以通常我们设置元素的样式，并非都是在行间设置。使用style方法获取的只是DOM元素style属性里的样式规则，对于通过class属性设置的外部样式表，style就显得力不从心了。那要如何获取元素的非行间样式呢？DOM标准中有个全局方法getComputedStyle，通过该方法可以获取当前对象的样式信息。比如：getComputedStyle(obj, false).paddingLeft，可以获取到对象的左内边距。这里需要注意：在获取元素的复合样式时，一定要使用精确的值，复合样式比如background、border，如果要获取元素的背景颜色，只使用background会出错，一定要写成backgroundColor。
JS只能修改元素的行间样式，并不能修改获取到的非行间样式。那么很多人可能会产生疑问，既然可以获取到又不能修改，那还获取有什么用。其实获取非行间样式是非常有必要的，如果是外部样式表，样式都是密密麻麻一片英文的存在，不可能一个个去找，到底该元素设置的什么样子，再回头修改，那岂不是太浪费精力了，所以该方法就显得尤为重要，而且返回的值都是精确值，通过获取的非行间样式信息，也有利于更精细的修改元素的当前样式，这是多么美妙的一件事，直接使用style设置元素的行间样式，因为行间样式的优先级最高，所以就覆盖掉了非行间样式，其实也就相当于跟修改了非行间样式一样，只是显示在了行间，我们目的反着是已经达到了。
<!DOCTYPE html><html><head> <meta charset="UTF-">
<title>获取非行间样式</title>
<style>#div{ width:px;
height:px;
background:red;
margin-top:px;
}</style><script>window.onload=function (){
var oDiv=document.getElementById('div');
alert(getComputedStyle(oDiv,false).width);
oDiv.style.width='px';
alert(getComputedStyle(oDiv,false).height);
oDiv.style.height='px';
//注意这里修改复合样式时，使用的background，可在FF下用Firebug查看具体的行间样式。
alert(getComputedStyle(oDiv,false).backgroundColor);
oDiv.style.background='green';
};</script></head><body><div id="div"></div>
</body></html>(4)、对事件做出响应
实例：全选和反选，输入对应的序号选中
<!DOCTYPE html> <html>
<head>
<meta charset="UTF-">
<title>JavaScript实例</title>
</head>
<body>
<form id="list">
请选择你的业余爱好:<br>
. 音乐<input type="checkbox" name="love" id="like">
. 阅读<input type="checkbox" name="love" id="like">
. 游泳<input type="checkbox" name="love" id="like">
. 篮球<input type="checkbox" name="love" id="like">
. 足球<input type="checkbox" name="love" id="like">
. 散步<input type="checkbox" name="love" id="like">
. 泡吧<input type="checkbox" name="love" id="like">
. 逛街<input type="checkbox" name="love" id="like"><br>
<input type="button" value = "全选" onclick="optAll()">
<input type="button" value = "反选" onclick="noAll()">
<p>输入-序号选择，每次只可以选择一项：</p>
<input id="txt" type="text">
<input id="btn" type="button" value="确定">
</form>
<script>
function optAll(){
//通过获取标签名设置全选
var oList = document.getElementById('list');
var aCheck = oList.getElementsByTagName('input');
for(var i=;i<aCheck.length;i++){
if(aCheck[i].type =='checkbox'){
aCheck[i].checked=true;
}
}
}
function noAll(){
//通过获取设置的name属性值设置反选
var aLove = document.getElementsByName('love');
for(var i=;i<aLove.length;i++){
if(aLove[i].type =='checkbox'){
aLove[i].checked=false;
}
}
}
var oBtn = document.getElementById('btn');
//给获取的按钮添加点击事件
oBtn.onclick = function (){
//获取文本框输入的值
var oTxt = document.getElementById("txt").value;
//定义的复选框id值为like-。括号中进行的是字符串连接，id+输入到文本框的值=该元素的id值
var oLike = document.getElementById('like' + oTxt);
oLike.checked = true;
}
</script>
</body>
</html>
3、DOM节点。
HTML文档可以说是由节点构成的集合，常见的DOM节点有三种，即元素节点、属性节点和文本节点。元素节点就是HTML标签，标签的属性就是属性节点，文本节点就是页面可以浏览的内容。
在文档对象模型中，每一个节点都是一个对象，DOM节点有三个重要的属性：节点的名称，节点的值和节点的类型。
(1)、nodeName：节点的名称
nodeName属性返回节点的名称。元素节点的名称与标签名相同(大写)，属性节点的名称是属性的名称，文本节点的名称永远都是#text，文档节点的名称永远都是#document。
(2)、nodeValue：节点的值
nodeValue属性返回节点的值。元素节点的值是undegined或null，属性节点的值是属性的值，文本节点的值是文本自身。
(3)、nodeType：节点的类型
nodeType属性返回节点的类型。以下是常见的节点类型：
<body><ul> <li>JS</li>
<li>DOM</li>
</ul><script>var nodes=document.getElementsByTagName('li');
for(var i=;i<nodes.length;i++){
document.write('第'+(i+)+'个节点的名称是'+nodes[i].nodeName+'<br>');
document.write('第'+(i+)+'个节点的值是'+nodes[i].nodeValue+'<br>');
document.write('第'+(i+)+'个节点的类型是'+nodes[i].nodeType+'<br>');
document.write('<br>');
} /*返回：第个节点的名称是LI第个节点的值是null第个节点的类型是第个节点的名称是LI第个节点的值是null第个节点的类型是*/</script></body>JS中函数可以嵌套使用，有父函数有子函数，HTML标签也可以嵌套使用，那么就说明存在着各种不同的节点关系，比如父节点、子节点和兄弟节点。为了方便操作，DOM定义了一些节点的公共属性。
(1)、子节点
childNodes属性返回节点的子节点集合，可使用length属性返回子节点的数量，然后就可以和数组一样获取需要的信息。
<body> <ul id="u">
<li></li>
<li></li>
<li></li>
<li></li>
<li></li>
</ul>
<script>
var oUl=document.getElementById('u');
alert(oUl.childNodes.length); //返回：
</script>
</body>
通过上面的代码，可以看到返回的是11。ul下明明只有5个li元素，怎么会返回11呢？其实是这么回事：
<ul id="u"> 第个节点（文本节点）
<li>第个节点（元素节点）</li> 第个节点（文本节点）
<li>第个节点（元素节点）</li> 第个节点（文本节点）
<li>第个节点（元素节点）</li> 第个节点（文本节点）
<li>第个节点（元素节点）</li> 第个节点（文本节点）
<li>第个节点（元素节点）</li> 第个节点（文本节点）
</ul>
因为通过childNodes属性返回的子节点集合，不仅包括元素节点，而且还包括文本节点，浏览会将标签之间的空白默认为文本节点，在空白处输入文字，会在浏览器显示。所以建议使用children属性，该属性只返回元素节点，不包括文本节点，并且不包括注释节点。
<body><ul id="u">
<li>
我是个文本节点
<span>我是span元素。</span>
</li>
<li></li> <!-- 注释 -->
<li></li>
<li></li>
<li></li>
</ul><script>var oUl=document.getElementById('u');
alert(oUl.children.length); //返回：
</script></body>上面的代码，ul下5个li元素，返回子节点个数为5。children属性要比childNodes属性好用太多了，只返回元素的子节点，还不包括孙子辈节点。
(2)、首尾子节点
firstElementChild属性返回children数组的第一个节点。
语法：node.firstElementChild 该方法相当于：element.children[0]
lastElementChild属性返回children数组的最后一个节点。
语法：node.lastElementChild 该方法相对于：element.children[element.children.length-1]
<body> <div style="border:px solid green" id="div">
空白节点
<p>JS</p>
<div>DOM</div>
<h>jQuery</h>
</div>
<script>
var x=document.getElementById('div');
document.write('第一个节点的名称：'+x.firstElementChild.nodeName+'<br>');
//返回：第一个子节点的名称：P
document.write('最后一个节点的名称：'+x.lastElementChild.nodeName)
//返回：最后一个子节点的名称：H
</script>
</body>
(3)、父节点
parentNode属性用于获取指定节点的父节点。注意：父节点只能有一个。通过使用两个获取父节点，可获取祖节点。
实例：点击子节点，隐藏父节点
<!DOCTYPE html> <html>
<head>
<meta charset="UTF-">
<title>JavaScript实例</title>
</head>
<body>
<ul id="u">
<li>aaa <a href="javascript:;">点击隐藏</a></li>
<li>bbb <a href="javascript:;">点击隐藏</a></li>
<li>ccc <a href="javascript:;">点击隐藏</a></li>
<li>ddd <a href="javascript:;">点击隐藏</a></li>
<li>eee <a href="javascript:;">点击隐藏</a></li>
</ul>
<script>
var oUl=document.getElementById('u');
//查看ul元素的父节点
alert(oUl.parentNode); //返回：[object HTMLBodyElement]
//通过标签名获取所有的a元素
var aA=document.getElementsByTagName('a');
for(var i=;i<aA.length;i++){
aA[i].onclick=function (){
//设置当前节点的父节点为隐藏
this.parentNode.style.display='none';
};
}
</script>
</body>
</html>
offsetParent属性可返回一个元素用于定位的父级。
<!DOCTYPE html><html><head> <meta charset="UTF-">
<title>JavaScript实例</title>
<style>#div{ width:px;
height:px;
background:green;
margin:px;
/*position:relative;*/
}#div{ width:px;
height:px;
background:red;
position:absolute;
left:px;
top:px;
}</style></head><body><div id="div">
<div id="div"></div>
</div><script>var oDiv=document.getElementById('div');
alert(oDiv.offsetParent);//返回：[object HTMLBodyElement]//div的父级是div,如果取消div相对定位的注释。则返回：[object HTMLDivElement]</script></body></html>(3)、兄弟节点
nextElementSibling属性返回同一树层级中某个节点之后紧跟的节点。
语法：element.nextElementSibling
previousElementSibling属性返回同一树层级中某个节点之前紧跟的节点。
语法：element.previousElementSibling
节点类型说明值元素节点每一个HTML标签都是一个元素节点，如 <div> 、 <p>、<ul>等1属性节点元素节点（HTML标签）的属性，如 id 、class 、name 等。2文本节点元素节点或属性节点中的文本内容。3注释节点表示文档注释，形式为<!-- text content -->。8文档节点表示整个文档（DOM 树的根节点，即 document ）。9
实例：获取li元素节点的兄弟节点
<body>
<ul> <li>HTML</li>
<li>CSS</li>
<li>JS</li>
</ul>
<script>
var aLi=document.getElementsByTagName('li');
//获取第二个子节点之后紧跟的节点
var x=aLi[].nextElementSibling;
alert(x.innerHTML); //返回：JS
//获取第二个子节点之前紧跟的节点
var x=aLi[].previousElementSibling;
alert(x.innerHTML); //返回：HTML
</script>
</body>
4、DOM应用。
DOM最实际的应用就是可以通过JS创建、插入和删除节点。
(1)、创建节点
createElement()方法可创建元素节点。
语法：document.createElement(tagName)
appendChild()方法可在指定节点的末尾插入一个新的子节点，每次都向末尾添加。
语法：父级.appendChild(new node)
实例：创建并添加li元素
<!DOCTYPE html> <html>
<head>
<meta charset="UTF-">
<title>JavaScript实例</title>
<script>
window.onload=function (){
var oBtn=document.getElementById('btn');
var oUl=document.getElementById('u');
var oTxt=document.getElementById('txt');
//文本框输入提示
oTxt.placeholder='请输入文字创建li元素';
oBtn.onclick=function (){
//创建li元素
var oLi=document.createElement('li');
//创建的li元素的HTML=文本框输入的值
oLi.innerHTML=oTxt.value;
//插入到oUl父级下，作为子节点，在每个创建的li末尾插入新创建的li元素
oUl.appendChild(oLi);
//父级.appendCild(子节点);
};
};
</script>
</head>
<body>
<input id="txt" type="text"value="">
<input id="btn" type="button"value="创建li">
<ul id="u"></ul>
</body>
</html>
(2)、插入节点
insertBefore()方法可在已有的子节点前插入一个新的子节点。
语法：父级.insertBefore(new node, node) 第一个参数为要插入的新子节点。第二个参数是原有节点，也就是在谁之前插入。
实例：创建并添加li元素，每个新创建的li元素都插入到之前插入的li元素之前
<!DOCTYPE html> <html>
<head>
<meta charset="UTF-">
<title>JavaScript实例</title>
<script>
window.onload=function (){
var oBtn=document.getElementById('btn');
var oUl=document.getElementById('u');
var oTxt=document.getElementById('txt');
oBtn.onclick=function (){
//创建li元素
var oLi=document.createElement('li');
//获取所有li元素
var aLi=oUl.getElementsByTagName('li');
oLi.innerHTML=oTxt.value;
//这里需要注意：页面中本没有li元素，li元素是通过JS创建的
//所以第一个li元素应该添加到父级下最后一个子节点
//然后基于这个节点，将之后再插入的子节点插入到上一个节点之前
//如果li元素本来不存在，则执行else，在父级插入一个子节点。
//如果li元素的个数>，说明已经创建了，则插入到这个子节点之前。
if(aLi.length>){
oUl.insertBefore(oLi,aLi[]);
}
else{
oUl.appendChild(oLi);
}
};
};
</script>
</head>
<body>
<input id="txt" type="text" value="">
<input id="btn" type="button" value="创建li">
<ul id="u"></ul>
</body>
</html>
(4)、删除节点
removeChild()方法用于删除一个节点
语法：父级.removeChild(node) 参数为要删除的子节点。
实例：简单的表格添加和删
<!DOCTYPE html> <html>
<head>
<meta charset="UTF-">
<title>JavaScript实例</title>
<script>
window.onload=function (){
var oTab=document.getElementById('tab');
var oName=document.getElementById('user');
var oAge=document.getElementById('age');
var oBtn=document.getElementById('btn');
//设置添加的ID项的值
var id=oTab.tBodies[].rows.length+;
oBtn.onclick=function (){
//创建一个tr
var oTr=document.createElement('tr');
//创建第一个td（ID项）
var oTd=document.createElement('td');
//获取ID，已经删除的ID号，不能再重用。
oTd.innerHTML=id++;
//将创建的td放入创建的tr中
oTr.appendChild(oTd);
//创建第二个td（姓名项）
var oTd = document.createElement('td');
oTd.innerHTML=oName.value;
oTr.appendChild(oTd);
//创建第三个td（年龄项）
var oTd = document.createElement('td');
oTd.innerHTML=oAge.value;
oTr.appendChild(oTd);
//创建第四个td（操作项）
var oTd = document.createElement('td');
oTd.innerHTML='<a href="javascript:;">删除</a>';
oTr.appendChild(oTd);
oTd.getElementsByTagName('a')[].onclick=function (){
//删除整行
oTab.tBodies[].removeChild(this.parentNode.parentNode);
};
//将创建好的tr放入tbody中
oTab.tBodies[].appendChild(oTr);
};
};
</script>
</head>
<body>
姓名：<input id="user"type="text">
年龄：<input id="age"type="text">
<input id="btn" type="button" value="添加">
<table id="tab" border="" width="px">
<caption>员工表</caption>
<thead>
<tr>
<th>ID</th>
<th>姓名</th>
<th>年龄</th>
<th>操作</th>
</tr>
</thead>
<tbody>
<tr>
<td></td>
<td>小白</td>
<td></td>
<td></td>
</tr>
<tr>
<td></td>
<td>小明</td>
<td></td>
<td></td>
</tr>
<tr>
<td></td>
<td>小红</td>
<td></td>
<td></td>
</tr>
<tr>
<td></td>
<td>张三</td>
<td></td>
<td></td>
</tr>
<tr>
<td></td>
<td>李四</td>
<td></td>
<td></td>
</tr>
</tbody>
</table>
</body>
</html>
这个实例只能很简单的完成添加和删除，并不对输入进行判断，如果想要做的完美，还需要做很多工作，可以对表格进行美化，设置背景色，鼠标移入高亮显示，鼠标移出恢复背景色，最关键的就是要对表单输入内容进行判断，以确保每次提交的信息都是有效信息，如果表格信息量大，还可以添加支持模糊搜素，多关键字搜索，以提高用户体验度，当然在实际的项目中，这样的情况几乎不会出现，但可以作为自己的实践，检验学习成果。
(5)、替换节点和创建文本节点
replaceChild()方法可用于替换元素节点。
语法：node.replaceChild (new node, node) 第一个参数为用于替换的节点。第二个参数为原有节点。
createTextNode()方法可创建新的文本节点，返回新创建的Text节点。
语法：document.createTextNode(txt)
这两种方法平时几乎用不到，但还是需要了解。
实例：点击按钮将span标签替换为b标签。再创建一个文本节点插入到创建的p元素下，并设置className。
<!DOCTYPE html><html><head> <meta charset="UTF-">
<title>JavaScript实例</title>
<style>.p{ width:px;
height:px;
background-color:#ccc;
} </style></head><body><p>创建一个P标签，设置<span id="s">className</span>属性，创建文本节点。</p>
<input type="button" value="点击替换" onclick="change()">
<script>function change(){
//获取span元素
var oS=document.getElementById('s');
//创建一个b元素
var newnode=document.createElement('b');
//要替换的文本节点
var txt = document.createTextNode('className');
//将文本节点插入到创建的b元素下
newnode.appendChild(txt);
//在span元素的父级下将span元素替换成新创建的b元素
oS.parentNode.replaceChild(newnode,oS);
}//创建一个p元素var oP=document.createElement('p');
//设置classNameoP.className='p';
//创建文本节点var txtNode=document.createTextNode('createTextNode用于创建文本节点!');
//将创建的文本节点插入到p元素下oP.appendChild(txtNode);//再将p元素插入到父级body下document.body.appendChild(oP);</script> </body></html>getElementById():获取有指定惟一ID属性值文档中的元素
getElementsByName(name):返回的是数组
getElementsByTagName():返回具有指定标签名的元素子元素集合
getAttribute():返回指定属性名的属性值
document.getElementsByTagName("a")[0].getAttribute("target");setAttribute():添加指定的属性，并为其赋指定的值。
document.getElementsByTagName("INPUT")[0].setAttribute("type","button");节点属性:
节点名称(只读):nodeName
节点值: nodeValue
节点类型(只读):nodeType
子节点：
ele.childNodes 返回数组
firstChild
lastChild
父节点
parentNode 只有一个
兄弟节点
nextSibling 某节点之后紧跟的节点
previousSibling
插入节点
appendChild() 插入在最后
insertBefore(newnode,node)在node节点之前
删除节点
removeChild(node) 成功返回被删除的节点 失败返回null
替换元素节点
replaceChild(newnode,oldnode) 实现子节点对象的替换
创建元素节点
createElement()
创建文本节点
createTextNode()
复制节点
需要被复制的节点.cloneNode(true/false)
true复制当前节点极其所以子节点，false仅复制当前节点
�
