【亚洲必赢官网】你所不打听的javascript操作DOM的底细知识点,Element节点类型详解

DOM Element节点类型详解

2015/09/21 · HTML5 ·
DOM

本文小编: 伯乐在线 –
韩子迟
。未经小编许可,禁止转载!
欢迎参预伯乐在线 专辑小编。

上文中大家讲课了 DOM
中最要紧的节点类型之一的 Document 节点类型,本文我们延续深切,谈谈另一个重大的节点类型 Element 。

一:Node类型

DOM元素的attribute和property很简单混倄在联合,分不清楚,两者是见仁见智的东西,可是两者又联系紧密。很多新手朋友,也囊括从前的我,平常会搞不清楚。

您所不明白的javascript操作DOM的细节知识点(一),javascriptdom

一: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>aaaaaa</p>
 <p>bbbbbb</p>
 <p>cccccc</p>
</div>

JS如下:

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

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

亚洲必赢官网 1

因为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>Document</title>
 </head>
 <body>
</body>
</html>

如上代码,大家可以把head和body是html的子元素,同理html是他俩的父级元素,那么head和body就是兄弟元素了,那么head及body里面的就是子元素了,大家需求驾驭的是各类节点都有一个childNodes属性,其保存的是近乎数组的因素,其也有length属性,但是她不是数组Array的实例,比如我们可以看看如下测试代码即可:

<div id="test">
 <p>aaaaaa</p>
 <p>bbbbbb</p>
 <p>cccccc</p>
</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代码即可;

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

本条题材稍后在仔细考虑,大家明天来看望哪些取得子元素,大家可以选取2种格局,第一种是选用中括号[index]目录,第二种是使用item[index]目录,如下代码:

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

而是她们并不是数组,大家可以测试下代码即可,如下代码:

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是指当前节点的下一个亲生节点,比如如下代码:

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

假诺该节点列表中只有一个节点的话,那么该节点的previousSibling和nextSibling都为null;父节点的firstChild指向了父节点中第三个节点;如下代码:

<div id=”test”><p class=”a”>aaaaaa</p><p
class=”b”>bbbbbb</p><p
class=”c”>cccccc</p></div>

JS如下:

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

父节点的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”>aaaaaa</p><p
class=”b”>bbbbbb</p><p
class=”c”>cccccc</p></div>

JS代码如下:

var test = document.getElementById(“test”);
console.log(test.hasChildNodes());

// true假使是之类的 就回来false;如下代码:

<div id=”test”></div>
var test = document.getElementById(“test”);
console.log(test.hasChildNodes()); // false

ownerDocument:
所有节点都有最终一个性能是ownerDocument,该属性指向表示所有文档的文档节点,那种涉及表示的别样节点都属于它所在的文档,任何节点都无法而且存在多少个或更多文档中,通过这一个特性,我们可以不必在节点层次中经过层层回溯到达顶端,而是可以直接访问文档节点;如下测试代码:

<div id="test">
 <p class="a">11</p>
</div>
var test = document.getElementById("test");
console.log(test.ownerDocument); // document
var p = test.ownerDocument.getElementsByTagName("p");
console.log(p); // <p class="a">11</p>

appendChild():
用于向childNodes列表的尾声添加一个节点;再次来到的是新扩充的节点;如下代码:

<div id=”test”>
<p class=”a”>11</p>
</div>

JS代码如下:

var test = document.getElementById("test");
var newNode = document.createElement("p");
var returnNode = test.appendChild(newNode);
console.log(returnNode); // <p></p>
console.log(returnNode === newNode); // true
console.log(test.lastChild === newNode); // true

insertBefore():
该措施是将新节点插入到指定的节点的眼前去,该方法接收2个参数,要插入的节点和作为参考的节点;插入节点后,被插入的节点会成为参照节点的前一个亲生节点,同时被艺术重临,如下代码:

<div id=”test”>
<p class=”a”>11</p>
</div>

JS代码如下:

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

布置节点后,结构变成如下:

复制代码 代码如下:
<div id=”test”>
<div></div>
<p class=”a”>11</p>
</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”>11</p>
    <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”>11</p><p
class=”b”>22</p></div>

JS代码如下:

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

轮换后html代码结构变成如下:

<div id=”test”><div></div><p
class=”b”>22</p></div>

轮换最终一个节点代码如下:

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

轮换后的代码如下:

<div id=”test”><p
class=”a”>11</p><div></div></div>removeChild():移除节点,该方法接收一个参数,即要移除的节点;

【亚洲必赢官网】你所不打听的javascript操作DOM的底细知识点,Element节点类型详解。被移除的节点将成为再次回到值,如下代码:

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

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

<div id=”test”><p class=”b”>22</p></div>

移除最终一个节点的代码如下:

// 移除最终一个节点
var returnNode = test.removeChild(test.lastChild);
console.log(returnNode); // <p class=”b”>22</p>
移除后的代码结构变为如下:

<div id=”test”><p
class=”a”>11</p></div>cloneNode():

仿造一个一律的副本,该方式接收一个布尔值参数,假若为true的话,表明是深复制,复制该节点及成套子节点书,假设为false的话,只复制该节点本身,比如如下代码:

var test = document.getElementById("test");
var deeplist = test.cloneNode(true);
console.log(deeplist);
// <div id="test"><p class="a">11</p><p class="b">22</p></div>
如果是浅复制的如下代码:
var test = document.getElementById("test");
var deeplist = test.cloneNode(false);
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列表访问文档元素;如下测试代码:

console.log(document.documentElement); // 指向html的引用
console.log(document.childNodes[0]); // <!doctype html>
console.log(document.firstChild); // <!doctype html>
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); //

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”)); // <input name=”aa”/>

俺们还足以由此方括号的语法来走访,如下代码:

console.log(inputs[“aa”]); // <input name=”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

本来也得以收获自定义的性质;如下代码:

<div id=”test” data-value=”test1″></div>

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结构如下:

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

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()方法再次来到表示被去除特性的节点;

一般来说代码:

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

JS代码如下:

复制代码 代码如下:
var div = document.getElementById(“test”);
var oldAttr = div.attributes.removeNamedItem(“id”);
console.log(oldAttr); // 重返是被去除的节点  id=”test”

现在的html结构变成如下:

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

如上艺术:方今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′

上边的函数使用一个数组来保存名值对,最终再以空格为分隔符将它们拼接起来,可是上面的代码我们需求专注两点:

1.针对性attributes对象中的特性,差别的浏览器再次回到的相继分化。
2.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>11</li>
 <li>22</li>
 <li>33</li>
</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>11</li><li>22</li><li>33</li></ul>

JS代码如下:

复制代码 代码如下:
var list = document.getElementById(“list”);
console.log(list.childNodes);
console.log(list.childNodes.length);

那就是说平常我们不能都如此小心小意的编辑html代码的,因为一步小心就有一个空格暴发,因而大家得以如下判断下是否因素节点;如下代码演示:

<ul id="list">
 <li>11</li>
 <li>22</li>
 <li>33</li>
</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;

未曾子节点;

1.创立文本节点;
可以利用document.createTextNode()创制新文本节点,这么些点子要求一个参数,即要插入的文件,如下代码:

var element = document.createElement("div");
var text = document.createTextNode("aa");
element.appendChild(text); 
document.body.appendChild(element); 
  1. 细分文本节点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上面触发;比如如下代码:

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

其次种是经过JS来触发,如下代码:

复制代码 代码如下:
EventUtil.addHandler(window,’load’,function(event){
      alert(1);
});

地点的伊芙ntUtil.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(完成):对象已经加载成功;

<script>(在IE和opera)中和<link>(仅IE中)元素也会触发readystatechange事件,可以用来确定外部的javascript和css文件是还是不是业已加载成功,基于元素触发的readystatechange事件,即readyState属性无论等于”loaded”如故”complete”都足以代表资源已经可用;如下针对IE的判断javascript是或不是曾经加载成功的方案:

EventUtil.addHandler(window,'load',function(){
 var script = document.createElement("script");
 EventUtil.addHandler(script,'readystatechange',function(event){
  event = EventUtil.getEvent(event);
  var target = EventUtil.getTarget(event);
  if (target.readyState == "loaded" || target.readyState == "complete"){
   EventUtil.removeHandler(target, "readystatechange", arguments. callee);
   alert(script.src);
  }
 });
 script.src = 'a.js';
 document.body.appendChild(script); 
});

上边我们可以动用javascript客户端检测技术来判定是或不是是IE和其余专业浏览器做一个粗略的包装;如下代码:

var ua = navigator.userAgent.toLowerCase();
EventUtil.addHandler(window,'load',function(){
 var script = document.createElement("script");
 if(/msie ([^;]+)/.test(ua) || "ActiveXObject" in window) {
  // IE 浏览器
  EventUtil.addHandler(script,'readystatechange',function(event){
   event = EventUtil.getEvent(event);
   var target = EventUtil.getTarget(event);
   if (target.readyState == "loaded" || target.readyState == "complete"){
    EventUtil.removeHandler(target, "readystatechange", arguments. callee);
    console.log("javascript已经加载完成");
   }
  });
 }else {
  // 除IE之外的标准浏览器
  EventUtil.addHandler(script,'load',function(event){
   console.log("javascript已经加载完成");
  });
 }
 script.src = 'a.js';
 document.body.appendChild(script);
});

地点的是指向具有的重中之重的浏览器进行包装来判断动态加载的JS是不是曾经加载成功!

略知一二动态加载行内JS格局

另一种加载javascript代码的艺术是行内方式,如下代码:

复制代码 代码如下:
<script src=”text/javascript”>
       function sayHi(){alert(1);}
</script>

从理论来讲,上边的代码应该是行得通的;

复制代码 代码如下:
var script = document.createElement(‘script’);
script.type = ‘text/javascript’;
script.appendChild(document.createTextNode(“function sayHi(){alert(1);}
sayHi()”));
document.body.appendChild(script);

如上代码在firefox,IE9+,chrome和opera中,都是例行的,可以运行的,可是在IE8及以下会报错,如下:

亚洲必赢官网 2

IE8及以下将script视为一个例外的元素,分化意dom访问其子节点;不过大家可以应用script元素的text属性来指定javascript代码,如下代码:

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

近来在具备的主流的浏览器都是健康的,在IE8及以下也是常规的;但是在safari3.0之前的本子无法科学的支撑text属性,但可以允许使用文本节点来指定代码;如下代码:

var script = document.createElement('script');
script.type = 'text/javascript';
var code = "function sayHi(){alert(1);} sayHi()";
try{
 script.appendChild(document.createTextNode(code));
}catch(e){
 script.text = code;
}
document.body.appendChild(script);

上面大家可以应用一个函数来封装下;如下代码:

function loadScriptString(code) {
 var script = document.createElement('script');
 script.type = 'text/javascript';
 try{
  script.appendChild(document.createTextNode(code));
 }catch(e){
  script.text = code;
 }
 document.body.appendChild(script);
}
loadScriptString("function sayHi(){alert(1);} sayHi()");

知情动态加载css样式

与动态脚本类似,所谓动态样式是指在页面刚载入时不设有的体制,动态样式是在页面加载成功后动态拉长到页面中的;

动态加载样式如下代码:

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

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

俺们也得以像JS一样先封装一个函数,为了调用尤其便利;如下代码:

function loadStyles(url) {
 var link = document.createElement("link");
 link.rel = "stylesheet";
 link.type = "text/css";
 link.href = url;
 var head = document.getElementsByTagName("head")[0];
 head.appendChild(link);
}
loadStyles("style.css");

俺们也足以动用事件的办法来判定css动态加载是或不是早已加载成功~

EventUtil.addHandler(window,'load',function(){
 var link = document.createElement("link");
 link.rel = "stylesheet";
 link.type = "text/css";
 EventUtil.addHandler(link, "load", function(event){
  console.log("css loaded");
 });
 link.href = "style.css";
 document.getElementsByTagName("head")[0].appendChild(link);
});

在意:如上代码:不仅在业内浏览器下chrome,firefox,opera下辅助,而且IE7-10都支持那种加载;不过safari不帮忙那种加载;

或者和javascript一样,大家也得以本着IE下做一种那样的拍卖;代码如下,也足以协理所有的IE下:

EventUtil.addHandler(window, "load", function(){
 var link = document.createElement("link");
 link.type = "text/css";
 link.rel= "stylesheet";
 EventUtil.addHandler(link, "readystatechange", function(event){
  event = EventUtil.getEvent(event);
  var target = EventUtil.getTarget(event);
  if (target.readyState == "loaded" || target.readyState == "complete"){
   EventUtil.removeHandler(target, "readystatechange", arguments. callee);
   alert("CSS Loaded");
  }
 });
 link.href = "style.css";
 document.getElementsByTagName("head")[0].appendChild(link);
});

俺们也可以像Javascript一样,为了认清所有的浏览器下协助能够打包一个拥有都帮衬的代码;当然除safari浏览器除外,好像safari浏览器没有奏效;

正如代码:

var ua = navigator.userAgent.toLowerCase();
EventUtil.addHandler(window,'load',function(){
 var link = document.createElement("link");
 link.type = "text/css";
 link.rel= "stylesheet";
 if(/msie ([^;]+)/.test(ua) || "ActiveXObject" in window) {
  // IE 浏览器
  EventUtil.addHandler(link,'readystatechange',function(event){
   event = EventUtil.getEvent(event);
   var target = EventUtil.getTarget(event);
   if (target.readyState == "loaded" || target.readyState == "complete"){
   EventUtil.removeHandler(target, "readystatechange", arguments. callee);
    alert("css已经加载完成");
   }
  });
 }else {
  // 除IE之外的标准浏览器
  EventUtil.addHandler(link,'load',function(event){
   alert("css已经加载完成");
  });
 }
 link.href = "style.css";
 document.getElementsByTagName("head")[0].appendChild(link);
});

另一种概念样式的点子是运用<style>元从来含有嵌入式的css

一般来说所示代码:

<style>

body {background-color:red;}

</style>

安份守己同样的法则,上面的代码除了IE8及以下不帮忙,其他浏览器下都扶助;如下代码:

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

因而大家也足以像JS一样包裹一个全包容的css样式;如下代码所示:

var style = document.createElement("style");
style.type = "text/css";
try{
 style.appendChild(document.createTextNode("body{background-color:red}"));
} catch (ex){
 style.styleSheet.cssText = "body{background-color:red}";
}
var head = document.getElementsByTagName("head")[0];
head.appendChild(style);

为了更便利调用,由此大家也可以打包一个函数来;如下代码:

function loadStyleString(css) {
 var style = document.createElement("style");
 style.type = "text/css";
 try{
  style.appendChild(document.createTextNode(css));
 } catch (ex){
  style.styleSheet.cssText = css;
 }
 var head = document.getElementsByTagName("head")[0];
 head.appendChild(style);
}
// 调用方式如下:
loadStyleString("body{background-color:red}");

DOM的扩展

  1. querySelector()方法

querySelector()方法接收一个css选取符,再次来到与该情势匹配的首个因素,即使没有找到匹配元素,则赶回null;如下代码:

复制代码 代码如下:
<div id=”test”>test</div>
<div class=”cls”>1111</div>
<div class=”cls”>2222</div>
<div class=”cls”>2222</div>

JS代码如下:

// 取得body
var body = document.querySelector('body');
console.log(body); // body的引用
// 取得id为test的元素
var test = document.querySelector("#test");
console.log(test); // <div id="test">test</div>
// 取得类为cls的第一个元素
var cls = document.querySelector(".cls");
console.log(cls); // <div class="cls">1111</div>

同理大家也得以通过Element类型调用querySelector()方法时,只会在该因素后代范围内寻找匹配的要素,如下代码:

复制代码 代码如下:
<div class=”testParent”>
<p>1111</p>
<p>2222</p>
</div>

自身想透过先拿走div中的testParent,然后再拿走p元素(通过querySelector方法);如下代码:

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

浏览器扶助程度:IE8+,firefox,chrome,safari3.1+,opera10+

2. querySelectorAll()方法

querySelectorAll()方法接收的参数与querySelector()方法同样,都是一个css选取符,然则回到的是所有匹配的因素,这一个办法再次来到的是一个NodeList的实例。

如下代码演示:

<div id="test">
 <em class="selected">11111</em>
 <em class="selected">22222</em>
 <em>33333</em>
 <em>44444</em>
</div>

JS代码如下:

// 取得div中所有em元素
var em = document.getElementById("test").querySelectorAll('em');
console.log(em); // NodeList
console.log(em.length); // 4

// 第二种方式 也可以先使用querySelector
var test = document.querySelector("#test");
var em2 = test.querySelectorAll('em');
console.log(em2); // NodeList
console.log(em2.length); // 4

// 取得类为selected的所有元素
var selected = document.querySelectorAll('.selected');
console.log(selected); // <em class="selected">11111</em>
    // <em class="selected">22222</em>
// 也可以通过以下的方式获得所有的em元素
var em = document.querySelectorAll('div em');
console.log(em); // NodeList
console.log(em.length); // 4

要得到重返的NodeList中的每一个要素,可以应用item()方法,也能够利用方括号的语法;

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

浏览器协理程度:IE8+,firefox,chrome,safari3.1+,opera10+

3. matchesSelector()方法

以此办法接收一个参数,即css选拔符,借使调用元素与该拔取符匹配,再次来到true,否则,重临false;

一般来说代码:

console.log(document.body.webkitMatchesSelector(“body”)); // true

IE9+通过msMatchesSelector()支持该方法,Firefox3.6+通过mozMatchesSelector()帮助该办法;safari5+和chrome通过webkitMatchesSelector()支持该措施;因而大家得以打包一个函数,如下代码:

function matchesSelector(element,selector) {
if(element.MatchesSelector) {
 return element.MatchesSelector(selector);
}else if(element.msMatchesSelector) {
 return element.msMatchesSelector(selector);
}else if(element.webkitMatchesSelector) {
 return element.webkitMatchesSelector(selector);
}else if(element.mozMatchesSelector) {
 return element.mozMatchesSelector(selector);
}else {
  throw new Error("Not supported");
 }
}
console.log(matchesSelector(document.body,'body')); // true
var test = document.querySelector('#test');
console.log(matchesSelector(test,'#test')); // true

4. getElementsByClassName() 方法

该形式接收一个参数,即含有一个要么八个类名的字符串,重回带有指定类的有着因素的NodeList;传入三个类名时,类名的先后顺序不重大。

复制代码 代码如下:
<p class=”p1″>111</p>
<p class=”p1″>222</p>
<p class=”p1″>333</p>

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

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

5. classList属性

如下代码:

<div class=”aa bb cc” id=”div”>aaa</div>

自我想删除aa这么些类名的时候,以前要求如下写代码:

var div = document.getElementById("div");
// 首先,取得类名字符串并拆分成数组
var classNames = div.className.split(/\s+/);
var pos = -1,
  i, 
 len;
for(i = 0,len = classNames.length; i < len; i+=1) {
 if(classNames[i] == 'aa') {
  pos = i;
  break;
 }
}
// 删除类名
classNames.splice(i,1);
// 把剩下的类名拼成字符串并重新设置
div.className = classNames.join(" "); 
// <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,代码如下:

<div class=”aa bb cc” id=”div”>aaa</div>

JS如下:

var div = document.getElementById("div");
// 删除类名aa,如下方法即可
div.classList.remove("aa");
// html结构如下: <div class="bb cc" id="div">aaa</div>
// 添加类名current,如下方法即可
div.classList.add("current");
// html结构变为如下 <div class="bb cc current" id="div">aaa</div>

// 切换aa类名
div.classList.toggle("aa");
// html结构变为如下 <div class="aa bb cc current" id="div">aaa</div>
// 确定元素是否包含类名;
console.log(div.classList.contains("aa")); // true

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

HTML5新增自定义数据属性

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

<div id=”myDiv” data-appId=”12345″
data-myname=”Nicholas”></div>

添加了自定义属性之后,可以透过元素的dataset属性来访问自定义属性的值,dataset属性的值是DOMStringMap的一个实例,也就是一个名值对的照射;比如如下代码:

//本例中使用的方法仅用于演示
var div = document.getElementById("myDiv");
console.log(div.dataset); // DOMStringMap {value: "12345", name: "Nicholas"}
//取得自定义属性的值
var value1 = div.dataset.value;
console.log(value1); // 12345
var name1 = div.dataset.name;
console.log(name1); // Nicholas
//设置值
div.dataset.value = 23456;
div.dataset.name = "Michael";
//有没有"myname"值呢?
if (div.dataset.name){
 console.log("Hello, " + div.dataset.name); // Hello, Michael
}

亚洲必赢官网 3

浏览器援救的水准有;firefox6+和chrome浏览器;

一:Node类型
DOM1级定义了一个Node接口,该接口是由DOM中的所有节点类型已毕。每…

1、概况


Element 类型用于表现 HTML 或 XML
元素,提供了对元素标签名、子节点及特点的走访。 Element
节点有所以下特点:

  1. nodeType 的值为 1
  2. nodeName 的值为因素的标签名
  3. nodeValue 的值为null
  4. parentNode 可能是 Document 或者 Element
  5. 其子节点可能是 ElementTextCommentProcessingInstructionCDATASection 或者 EntityReference

要访问元素的标签名,能够用 nodeName 属性,也足以用 tagName 属性;这三个属性会再次回到相同的值。
HTML 中,标签名始终都以一切大写表示,而在 XML(有时候也包蕴XHTML)中,标签名始终和源代码中保持一致。
假如你不确定自己的本子将会在
HTML 依然 XML
文档中执行,最好仍旧在比较前边将标签名转换成相同的大小写格局:

JavaScript

var myDiv = document.querySelector(‘div’); console.log(myDiv.tagName);
// DIV console.log(myDiv.nodeName); // DIV if
(myDiv.tagName.toLowerCase() === ‘div’) { // 那样最好,适用于其他文档 //
… }

1
2
3
4
5
6
7
var myDiv = document.querySelector(‘div’);
console.log(myDiv.tagName);  // DIV
console.log(myDiv.nodeName);  // DIV
 
if (myDiv.tagName.toLowerCase() === ‘div’) { // 这样最好,适用于任何文档
  // …
}

DOM1级定义了一个Node接口,该接口是由DOM中的所有节点类型完结。每个节点都有一个nodeType属性,用于注脚节点的项目,节点类型在Node类型中有以下两种:

attribute翻译成汉语术语为“特性”,property翻译成汉语术语为“属性”,从中文的字面意思来看,确实是有点分别了,先来说说attribute。

2、HTML 元素


持有 HTML 元素都由 HTMLElement
类型表示,不是直接通过这一个类型,也是经过它的子类型来代表。 HTMLElement
类型直接接轨自 Element 并添加了一些性能。每个 HTML
元素中都设有下列标准属性:

  1. id 元素在文档中的唯一标识符
  2. title 有关因素的叠加表达新闻,一般通过工具提示条突显出来
  3. lang 元素内容的言语代码,很少使用
  4. dir 语言的可行性,值为 ltr 或者 rtl,也很少使用
  5. className 与元素的 class 特性对应

Node.ELEMENT_NODE(1); 元素节点
Node.ATTRIBUTE_NODE(2); 属性节点
Node.TEXT_NODE(3); 文本节点
Node.DOCUMENT_NODE(9); 文档节点

attribute是一个特征节点,每个DOM元素都有一个遥相呼应的attributes属性来存放在所有的attribute节点,attributes是一个类数组的器皿,说得准确点就是NameNodeMap,不问可知就是一个近乎数组但又和数组不太雷同的器皿。attributes的各样数字索引以名值对(name=”value”)的花样存放了一个attribute节点。

3、特性的获取和装置


每个元素都有一个或八个特点,这个特色的用处是交给相应元素或其情节的附加信息。操作特性的
DOM
方法紧要有多少个,分别是getAttribute() setAttribute() removeAttribute()

注意,传递给 getAttribute() 的风味名与事实上的表征名相同,因而要想赢得 class 特性值,应该传入 class 而不是 className,后者唯有在通过对象属性(property)访问特性时才用。若是给定称号的表征不存在,getAttribute() 返回
null。

<div id=’myDiv’ title=’hanzichi’> </div> <script> var
myDiv = document.querySelector(‘div’); // attribute
console.log(myDiv.getAttribute(‘id’)); // myDiv
console.log(myDiv.getAttribute(‘class’)); // null
console.log(myDiv.getAttribute(‘title’)); // hanzichi
console.log(myDiv.getAttribute(‘lang’)); // null
console.log(myDiv.getAttribute(‘dir’)); // null // property
console.log(myDiv.id); // myDiv console.log(myDiv.className); // ”
console.log(myDiv.title); // hanzichi console.log(myDiv.lang); // ”
console.log(myDiv.dir); // ” </script>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<div id=’myDiv’ title=’hanzichi’> </div>
<script>
  var myDiv = document.querySelector(‘div’);
 
  // attribute
  console.log(myDiv.getAttribute(‘id’)); // myDiv
  console.log(myDiv.getAttribute(‘class’)); // null
  console.log(myDiv.getAttribute(‘title’)); // hanzichi
  console.log(myDiv.getAttribute(‘lang’)); // null
  console.log(myDiv.getAttribute(‘dir’)); // null
 
  // property
  console.log(myDiv.id); // myDiv
  console.log(myDiv.className); // ”
  console.log(myDiv.title); // hanzichi
  console.log(myDiv.lang); // ”
  console.log(myDiv.dir); // ”
</script>

通过 getAttribute() 方法也得以获取自定义特性。

在骨子里支出中,开发人员不常用 getAttribute(),而是只利用对象的性质(property)。唯有在得到自定义特性值的场馆下,才使用getAttribute() 方法。为何吗?比如说 style,在通过 getAttribute() 访问时,返回的 style 特性值包蕴的是
css
文本,而通过属性来访问会回来一个目的。再譬如 onclick 那样的事件处理程序,当在要素上利用时,onclick 特性包罗的是
Javascript
代码,即使经过 getAttribute() 访问,将会重临相应代码的字符串,而在访问 onclick 属性时,则会再次回到Javascript 函数。

与 getAttribute() 对应的是 setAttribute(),那些主意接受四个参数:要设置的性状名和值。如果特性已经存在,setAttribute()会以指定的值替换现有的值;假使特性不设有,setAttribute() 则成立该属性并设置相应的值。

而 removeAttitude() 方法用于彻底删除元素的特性。调用这么些方法不但会去掉特性的值,而且也会从要素中全然除去特性。

JavaScript

div.setAttribute(‘id’, ‘someOtherId’); div.setAttribute(‘title’, ‘some
other text’); div.removeAttribute(‘class’)

1
2
3
4
div.setAttribute(‘id’, ‘someOtherId’);
div.setAttribute(‘title’, ‘some other text’);
 
div.removeAttribute(‘class’)

实质上还有很多种,可是那些都不是很常用,所以就来了解那之中4种就足以了,大家先来探望节点类型,比如如下代码:

复制代码 代码如下:

4、attributes 属性


Element 类型是采纳 attributes 属性的绝无仅有一个 DOM
节点类型。 attributes 属性中含有一个 NamedNodeMap,与 NodeList
类似,也是一个“动态”的集纳。元素的每一个特色都由一个 Attr
节点表示,每个节点都封存在 NamedNodeMap 对象中。NamedNodeMap 对象拥有下列方式:

  1. getNamedItem(name): 返回 nodeName 属性等于 name 的节点
  2. removeNamedItem(name):
    从列表移除 nodeName 属性等于 name 的节点
  3. setNamedItem(node):
    向列表中添加节点,以节点的 nodeName 属性为索引
  4. item(pos): 重返位于数字 pos 地点处的节点

attributes 属性中带有一多重的节点,每个节点的 nodeName 就是特点的名称,而节点的 nodeValue 就是特点的值。

JavaScript

// 取得元素的特色值 var id =
element.attributes.getNamedItem(‘id’).nodeValue; var id =
element.attributes[‘id’].nodeValue; // getAttribute() 也能促成均等功能var id = element.getAttribute(‘id’); // 与removeAttribute()
方法比较,唯一的分别是能回去表示被删去特性的节点 var oldAttr =
element.attributes.removeNamedItem(‘id’); // 添加新特点 //
要求传入一个表征节点 element.attributes.setNamedItem(newAttr);

1
2
3
4
5
6
7
8
9
10
11
12
13
// 取得元素的特性值
var id = element.attributes.getNamedItem(‘id’).nodeValue;
var id = element.attributes[‘id’].nodeValue;
 
// getAttribute() 也能实现一样功能
var id = element.getAttribute(‘id’);
 
// 与removeAttribute() 方法相比,唯一的区别是能返回表示被删除特性的节点
var oldAttr = element.attributes.removeNamedItem(‘id’);
 
// 添加新特性
// 需要传入一个特性节点
element.attributes.setNamedItem(newAttr);

貌似的话,由于前边介绍的 attributes
方法不够方便,因而开发人士愈多的会利用 getAttribute() removeAttribute() 以及setAttribute() 方法。

然则假如想要遍历元素的风味,attributes 属性倒是可以派上用场:

<div id=’myDiv’ title=’hanzichi’ class=’fish’> </div>
<script> var myDiv = document.querySelector(‘div’); for (var i =
0, len = myDiv.attributes.length; i < len; i++) { var attrName =
myDiv.attributes[i].nodeName , attrValue =
myDiv.attributes[i].nodeValue; console.log(attrName, attrValue); } //
id myDiv // title hanzichi // class fish </script>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<div id=’myDiv’ title=’hanzichi’ class=’fish’> </div>
<script>
  var myDiv = document.querySelector(‘div’);
  for (var i = 0, len = myDiv.attributes.length; i < len; i++) {
    var attrName = myDiv.attributes[i].nodeName
      , attrValue = myDiv.attributes[i].nodeValue;
 
    console.log(attrName, attrValue);
  }
 
  // id myDiv
  // title hanzichi
  // class fish
</script>

HTML代码如下:

<div class=”box” id=”box” gameid=”880″>hello</div>

5、元素的子节点


<ul id=’myUl’> <li> Item 1 </li> <li> Item 2
</li> <li> Item 3 </li> </ul> <script> var
myUl = document.getElementById(‘myUl’);
console.log(myUl.childNodes.length); // IE: 3 其余浏览器: 7
</script>

1
2
3
4
5
6
7
8
9
10
<ul id=’myUl’>
  <li> Item 1 </li>
  <li> Item 2 </li>
  <li> Item 3 </li>
</ul>
 
<script>
  var myUl = document.getElementById(‘myUl’);
  console.log(myUl.childNodes.length); // IE: 3   其他浏览器: 7
</script>

上述代码,假诺是 IE 来分析,那么 <ul> 元素会有 3 个子节点,分别是 3
个 <li> 元素;而只即使任何浏览器解析,则会有 7 个子节点,包罗 3
个 <li> 元素 和 4 个公文节点。

只要像上边那样将元素之间的空白符删除,那么所有浏览器都会回到相同数量的子节点:

<ul id=’myUl’><li> Item 1 </li><li> Item 2
</li><li> Item 3 </li></ul> <script> var
myUl = document.getElementById(‘myUl’);
console.log(myUl.childNodes.length); // 所有浏览器: 3 </script>

1
2
3
4
5
6
<ul id=’myUl’><li> Item 1 </li><li> Item 2 </li><li> Item 3 </li></ul>
 
<script>
  var myUl = document.getElementById(‘myUl’);
  console.log(myUl.childNodes.length); // 所有浏览器: 3
</script>

 

打赏辅助自己写出更加多好小说,谢谢!

打赏小编

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

上边的div元素的HTML代码中有class、id还有自定义的gameid,那么些特点都存放在attributes中,类似上面的格局:

打赏扶助自己写出越多好小说,谢谢!

亚洲必赢官网 4

1 赞 1 收藏
评论

JS如下:

复制代码 代码如下:

至于小编:韩子迟

亚洲必赢官网 5

a JavaScript beginner
个人主页 ·
我的稿子 ·
9 ·
   

亚洲必赢官网 6

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

[ class=”box”, id=”box”, gameid=”880″ ]

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

可以那样来做客attribute节点:

亚洲必赢官网 7

复制代码 代码如下:

因为IE没有公开Node类型的构造函数,由此在IE8-下会有不当,然则我们可以通过数值来比较,比如上边的要相比元素节点的话,我们可以动用1来比较,同理属性节点是2,文本节点是3;如下代码:

var elem = document.getElementById( ‘box’ );
console.log( elem.attributes[0].name ); // class
console.log( elem.attributes[0].value ); // box

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

但是IE6-7将过多东西都存放在attributes中,上面的访问方法和业内浏览器的回到结果又不一致。日常要取得一个attribute节点直接用getAttribute方法:

理解nodeName与nodeValue

复制代码 代码如下:

nodeName保存的是因素的标签名,而nodeValue一般都是null;大家得以看如下代码,没有新鲜的求证,HTML代码都是地方的,因而那边就不贴代码了;如下JS代码测试:

console.log( elem.getAttribute(‘gameid’) ); // 880

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

要设置一个attribute节点使用setAttribute方法,要删减就用removeAttribute:

精晓节点关系

复制代码 代码如下:

<!doctype html>
<html lang="en">
 <head>
 <meta charset="UTF-8">
 <title>Document</title>
 </head>
 <body>
</body>
</html>

elem.setAttribute(‘testAttr’, ‘testVal’);
console.log( elem.removeAttribute(‘gameid’) ); // undefined

如上代码,大家可以把head和body是html的子元素,同理html是他俩的父级元素,那么head和body就是兄弟元素了,那么head及body里面的就是子元素了,大家须要掌握的是每个节点都有一个childNodes属性,其保存的是类似数组的因素,其也有length属性,可是她不是数组Array的实例,比如大家得以看看如下测试代码即可:

attributes是会随着拉长或删除attribute节点动态更新的。
property就是一个性能,假使把DOM元素看成是一个平时的Object对象,那么property就是一个以名值对(name=”value”)的花样存放在Object中的属性。要抬高和删除property也大约多了,和普通的对象没啥分别:

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

复制代码 代码如下:

JS代码如下:

elem.gameid = 880; // 添加
console.log( elem.gameid ) // 获取
delete elem.gameid // 删除

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

为此attribute和property不难混倄在一道的来头是,很多attribute节点还有一个相对应的property属性,比如上边的div元素的id和class既是attribute,也有对应的property,不管选取哪一种方法都可以访问和改动。

如上代码,在规范浏览器下及IE9+下 第一行打印如下:

复制代码 代码如下:

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

console.log( elem.getAttribute(‘id’) ); // box
console.log( elem.id ); // box
elem.id = ‘hello’;
console.log( elem.getAttribute(‘id’) ); // hello

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

不过对于自定义的attribute节点,或者自定义property,两者就从未涉嫌了。

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

复制代码 代码如下:

以此题材稍后在条分缕析考虑,大家现在来探望怎样获取子元素,大家得以应用2种办法,第一种是选择中括号[index]目录,第三种是利用item[index]目录,如下代码:

console.log( elem.getAttribute(‘gameid’) ); // 880
console.log( elem.gameid ); // undefined
elem.areaid = ‘900’;
console.log( elem.getAttribute(‘areaid’) ) // null

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

对此IE6-7来说,没有分别attribute和property:

不过她们并不是数组,咱们可以测试下代码即可,如下代码:

复制代码 代码如下:

console.log(Object.prototype.toString.call(test.childNodes) ===
“[object Array]”);
// false然则大家使其转移为数组,如下代码:

console.log( elem.getAttribute(‘gameid’) ); // 880
console.log( elem.gameid ); // 880
elem.areaid = ‘900’;
console.log( elem.getAttribute(‘areaid’) ) // 900

//在IE8 及之前版本中没用
var arrayOfNodes = Array.prototype.slice.call(test.childNodes,0);
console.log(arrayOfNodes instanceof Array);

洋洋新手朋友估算都很不难掉进那一个坑中。
DOM元素一些默许常见的attribute节点都有与之相应的property属性,相比较特殊的是有些值为Boolean类型的property,如有些表单元素:

//
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

<input type=”radio” checked=”checked” id=”raido”>
var radio = document.getElementById( ‘radio’ );
console.log( radio.getAttribute(‘checked’) ); // checked
console.log( radio.checked ); // true

知晓parentNode(父节点),previousSibling(上一个哥们节点),nextSibling(下一个兄弟节点);

对于这一个新鲜的attribute节点,唯有存在该节点,对应的property的值就为true,如:

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

复制代码 代码如下:

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

<input type=”radio” checked=”anything” id=”raido”>
var radio = document.getElementById( ‘radio’ );
console.log( radio.getAttribute(‘checked’) ); // anything
console.log( radio.checked ); // true

借使该节点列表中唯有一个节点的话,那么该节点的previousSibling和nextSibling都为null;父节点的firstChild指向了父节点中第三个节点;如下代码:

终极为了更好的分别attribute和property,基本可以计算为attribute节点都是在HTML代码中可知的,而property只是一个一般的名值对性能。

<div id=”test”><p class=”a”>aaaaaa</p><p
class=”b”>bbbbbb</p><p
class=”c”>cccccc</p></div>

复制代码 代码如下:

JS如下:

// gameid和id都是attribute节点
// id同时又有啥不可经过property来访问和改动
<div gameid=”880″ id=”box”>hello</div>
// areaid仅仅是property
elem.areaid = 900;

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

父节点的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”>aaaaaa</p><p
class=”b”>bbbbbb</p><p
class=”c”>cccccc</p></div>

JS代码如下:

var test = document.getElementById(“test”);
console.log(test.hasChildNodes());

// true若是是之类的 就回去false;如下代码:

<div id=”test”></div>
var test = document.getElementById(“test”);
console.log(test.hasChildNodes()); // false

ownerDocument:
所有节点都有最后一个性能是ownerDocument,该属性指向表示一切文档的文档节点,这种关涉表示的其余节点都属于它所在的文档,任何节点都不可以同时设有三个或更加多文档中,通过这些特性,大家可以不必在节点层次中经过层层回溯到达顶端,而是可以间接访问文档节点;如下测试代码:

<div id="test">
 <p class="a">11</p>
</div>
var test = document.getElementById("test");
console.log(test.ownerDocument); // document
var p = test.ownerDocument.getElementsByTagName("p");
console.log(p); // <p class="a">11</p>

appendChild():
用于向childNodes列表的尾声添加一个节点;重临的是新扩展的节点;如下代码:

<div id=”test”>
<p class=”a”>11</p>
</div>

JS代码如下:

var test = document.getElementById("test");
var newNode = document.createElement("p");
var returnNode = test.appendChild(newNode);
console.log(returnNode); // <p></p>
console.log(returnNode === newNode); // true
console.log(test.lastChild === newNode); // true

insertBefore():
该措施是将新节点插入到指定的节点的前方去,该方法接收2个参数,要插入的节点和作为参考的节点;插入节点后,被插入的节点会化为参照节点的前一个同胞节点,同时被艺术重回,如下代码:

<div id=”test”>
<p class=”a”>11</p>
</div>

JS代码如下:

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

插入节点后,结构变为如下:

复制代码 代码如下:

<div id=”test”>
<div></div>
<p class=”a”>11</p>
</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”>11</p>
    <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”>11</p><p
class=”b”>22</p></div>

JS代码如下:

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

轮换后html代码结构变成如下:

<div id=”test”><div></div><p
class=”b”>22</p></div>

轮换最终一个节点代码如下:

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

轮换后的代码如下:

<div id=”test”><p
class=”a”>11</p><div></div></div>removeChild():移除节点,该情势接收一个参数,即要移除的节点;

被移除的节点将变为重临值,如下代码:

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

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

<div id=”test”><p class=”b”>22</p></div>

移除最终一个节点的代码如下:

// 移除最终一个节点
var returnNode = test.removeChild(test.lastChild);
console.log(returnNode); // <p class=”b”>22</p>
移除后的代码结构变成如下:

<div id=”test”><p
class=”a”>11</p></div>cloneNode():

克隆一个一律的副本,该措施接收一个布尔值参数,如果为true的话,表达是深复制,复制该节点及成套子节点书,如果为false的话,只复制该节点本身,比如如下代码:

var test = document.getElementById("test");
var deeplist = test.cloneNode(true);
console.log(deeplist);
// <div id="test"><p class="a">11</p><p class="b">22</p></div>
如果是浅复制的如下代码:
var test = document.getElementById("test");
var deeplist = test.cloneNode(false);
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列表访问文档元素;如下测试代码:

console.log(document.documentElement); // 指向html的引用
console.log(document.childNodes[0]); // <!doctype html>
console.log(document.firstChild); // <!doctype html>
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); //

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”)); // <input name=”aa”/>

我们还是可以够通过方括号的语法来走访,如下代码:

console.log(inputs[“aa”]); // <input name=”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

当然也得以得到自定义的习性;如下代码:

<div id=”test” data-value=”test1″></div>

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结构如下:

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

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()方法重回表示被删除特性的节点;

如下代码:

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

JS代码如下:

复制代码 代码如下:

var div = document.getElementById(“test”);
var oldAttr = div.attributes.removeNamedItem(“id”);
console.log(oldAttr); // 再次回到是被删除的节点  id=”test”

当今的html结构变成如下:

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

如上格局:近日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′

上边的函数使用一个数组来保存名值对,最终再以空格为分隔符将它们拼接起来,不过上边的代码大家须要留意两点:

1.对准attributes对象中的特性,分化的浏览器再次来到的一一不相同。
2.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>11</li>
 <li>22</li>
 <li>33</li>
</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>11</li><li>22</li><li>33</li></ul>

JS代码如下:

复制代码 代码如下:

var list = document.getElementById(“list”);
console.log(list.childNodes);
console.log(list.childNodes.length);

那么平日大家不能都如此小心小意的编排html代码的,因为一步小心就有一个空格暴发,因而大家得以如下判断下是或不是因素节点;如下代码演示:

<ul id="list">
 <li>11</li>
 <li>22</li>
 <li>33</li>
</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;

从未有过子节点;

1.创制文本节点;
能够利用document.createTextNode()创造新文本节点,那几个点子须求一个参数,即要插入的文件,如下代码:

var element = document.createElement("div");
var text = document.createTextNode("aa");
element.appendChild(text); 
document.body.appendChild(element); 
  1. 分开文本节点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上面触发;比如如下代码:

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

第三种是经过JS来触发,如下代码:

复制代码 代码如下:

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

地点的伊芙ntUtil.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(完结):对象已经加载成功;

<script>(在IE和opera)中和<link>(仅IE中)元素也会触发readystatechange事件,可以用来确定外部的javascript和css文件是或不是已经加载成功,基于元素触发的readystatechange事件,即readyState属性无论等于”loaded”照旧”complete”都得以象征资源已经可用;如下针对IE的论断javascript是或不是早已加载成功的方案:

EventUtil.addHandler(window,'load',function(){
 var script = document.createElement("script");
 EventUtil.addHandler(script,'readystatechange',function(event){
  event = EventUtil.getEvent(event);
  var target = EventUtil.getTarget(event);
  if (target.readyState == "loaded" || target.readyState == "complete"){
   EventUtil.removeHandler(target, "readystatechange", arguments. callee);
   alert(script.src);
  }
 });
 script.src = 'a.js';
 document.body.appendChild(script); 
});

上面我们可以使用javascript客户端检测技能来判定是不是是IE和其余标准浏览器做一个概括的包裹;如下代码:

var ua = navigator.userAgent.toLowerCase();
EventUtil.addHandler(window,'load',function(){
 var script = document.createElement("script");
 if(/msie ([^;]+)/.test(ua) || "ActiveXObject" in window) {
  // IE 浏览器
  EventUtil.addHandler(script,'readystatechange',function(event){
   event = EventUtil.getEvent(event);
   var target = EventUtil.getTarget(event);
   if (target.readyState == "loaded" || target.readyState == "complete"){
    EventUtil.removeHandler(target, "readystatechange", arguments. callee);
    console.log("javascript已经加载完成");
   }
  });
 }else {
  // 除IE之外的标准浏览器
  EventUtil.addHandler(script,'load',function(event){
   console.log("javascript已经加载完成");
  });
 }
 script.src = 'a.js';
 document.body.appendChild(script);
});

地点的是针对具有的重大的浏览器举办打包来判定动态加载的JS是或不是早已加载成功!

领会动态加载行内JS格局

另一种加载javascript代码的主意是行内方式,如下代码:

复制代码 代码如下:

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

从理论来讲,上面的代码应该是实惠的;

复制代码 代码如下:

var script = document.createElement(‘script’);
script.type = ‘text/javascript’;
script.appendChild(document.createTextNode(“function sayHi(){alert(1);}
sayHi()”));
document.body.appendChild(script);

如上代码在firefox,IE9+,chrome和opera中,都是健康的,可以运行的,不过在IE8及以下会报错,如下:

亚洲必赢官网 8

IE8及以下将script视为一个特殊的要素,分歧意dom访问其子节点;然而大家可以行使script元素的text属性来指定javascript代码,如下代码:

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

近来在富有的主流的浏览器都是常规的,在IE8及以下也是例行的;不过在safari3.0之前的本子不可以正确的接济text属性,但可以允许利用文本节点来指定代码;如下代码:

var script = document.createElement('script');
script.type = 'text/javascript';
var code = "function sayHi(){alert(1);} sayHi()";
try{
 script.appendChild(document.createTextNode(code));
}catch(e){
 script.text = code;
}
document.body.appendChild(script);

上边我们可以应用一个函数来封装下;如下代码:

function loadScriptString(code) {
 var script = document.createElement('script');
 script.type = 'text/javascript';
 try{
  script.appendChild(document.createTextNode(code));
 }catch(e){
  script.text = code;
 }
 document.body.appendChild(script);
}
loadScriptString("function sayHi(){alert(1);} sayHi()");

略知一二动态加载css样式

与动态脚本类似,所谓动态样式是指在页面刚载入时不设有的体裁,动态样式是在页面加载成功后动态拉长到页面中的;

动态加载样式如下代码:

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

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

俺们也得以像JS一样先封装一个函数,为了调用尤其有益于;如下代码:

function loadStyles(url) {
 var link = document.createElement("link");
 link.rel = "stylesheet";
 link.type = "text/css";
 link.href = url;
 var head = document.getElementsByTagName("head")[0];
 head.appendChild(link);
}
loadStyles("style.css");

俺们也足以利用事件的措施来判定css动态加载是或不是早已加载成功~

EventUtil.addHandler(window,'load',function(){
 var link = document.createElement("link");
 link.rel = "stylesheet";
 link.type = "text/css";
 EventUtil.addHandler(link, "load", function(event){
  console.log("css loaded");
 });
 link.href = "style.css";
 document.getElementsByTagName("head")[0].appendChild(link);
});

专注:如上代码:不仅在标准浏览器下chrome,firefox,opera下支持,而且IE7-10都扶助那种加载;不过safari不协理那种加载;

或者和javascript一样,大家也得以本着IE下做一种那样的处理;代码如下,也足以接济具备的IE下:

EventUtil.addHandler(window, "load", function(){
 var link = document.createElement("link");
 link.type = "text/css";
 link.rel= "stylesheet";
 EventUtil.addHandler(link, "readystatechange", function(event){
  event = EventUtil.getEvent(event);
  var target = EventUtil.getTarget(event);
  if (target.readyState == "loaded" || target.readyState == "complete"){
   EventUtil.removeHandler(target, "readystatechange", arguments. callee);
   alert("CSS Loaded");
  }
 });
 link.href = "style.css";
 document.getElementsByTagName("head")[0].appendChild(link);
});

俺们也可以像Javascript一样,为了判定所有的浏览器下匡助可以打包一个享有都协理的代码;当然除safari浏览器除外,好像safari浏览器没有奏效;

正如代码:

var ua = navigator.userAgent.toLowerCase();
EventUtil.addHandler(window,'load',function(){
 var link = document.createElement("link");
 link.type = "text/css";
 link.rel= "stylesheet";
 if(/msie ([^;]+)/.test(ua) || "ActiveXObject" in window) {
  // IE 浏览器
  EventUtil.addHandler(link,'readystatechange',function(event){
   event = EventUtil.getEvent(event);
   var target = EventUtil.getTarget(event);
   if (target.readyState == "loaded" || target.readyState == "complete"){
   EventUtil.removeHandler(target, "readystatechange", arguments. callee);
    alert("css已经加载完成");
   }
  });
 }else {
  // 除IE之外的标准浏览器
  EventUtil.addHandler(link,'load',function(event){
   alert("css已经加载完成");
  });
 }
 link.href = "style.css";
 document.getElementsByTagName("head")[0].appendChild(link);
});

另一种概念样式的艺术是应用<style>元从来含有嵌入式的css

正如所示代码:

<style>

body {background-color:red;}

</style>

依照同等的法则,下边的代码除了IE8及以下不援救,其余浏览器下都帮助;如下代码:

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

之所以大家也足以像JS一样包裹一个全包容的css样式;如下代码所示:

var style = document.createElement("style");
style.type = "text/css";
try{
 style.appendChild(document.createTextNode("body{background-color:red}"));
} catch (ex){
 style.styleSheet.cssText = "body{background-color:red}";
}
var head = document.getElementsByTagName("head")[0];
head.appendChild(style);

为了更便利调用,因而大家也足以打包一个函数来;如下代码:

function loadStyleString(css) {
 var style = document.createElement("style");
 style.type = "text/css";
 try{
  style.appendChild(document.createTextNode(css));
 } catch (ex){
  style.styleSheet.cssText = css;
 }
 var head = document.getElementsByTagName("head")[0];
 head.appendChild(style);
}
// 调用方式如下:
loadStyleString("body{background-color:red}");

DOM的扩展

  1. querySelector()方法

querySelector()方法接收一个css拔取符,重回与该方式匹配的率先个要素,假设没有找到匹配元素,则赶回null;如下代码:

复制代码 代码如下:

<div id=”test”>test</div>
<div class=”cls”>1111</div>
<div class=”cls”>2222</div>
<div class=”cls”>2222</div>

JS代码如下:

// 取得body
var body = document.querySelector('body');
console.log(body); // body的引用
// 取得id为test的元素
var test = document.querySelector("#test");
console.log(test); // <div id="test">test</div>
// 取得类为cls的第一个元素
var cls = document.querySelector(".cls");
console.log(cls); // <div class="cls">1111</div>

同理大家也得以透过Element类型调用querySelector()方法时,只会在该因素后代范围内寻找匹配的因素,如下代码:

复制代码 代码如下:

<div class=”testParent”>
<p>1111</p>
<p>2222</p>
</div>

我想通过先得到div中的testParent,然后再得到p元素(通过querySelector方法);如下代码:

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

浏览器接济程度:IE8+,firefox,chrome,safari3.1+,opera10+

2. querySelectorAll()方法

querySelectorAll()方法接收的参数与querySelector()方法同样,都是一个css拔取符,可是回到的是颇具匹配的因素,这些艺术重回的是一个NodeList的实例。

如下代码演示:

<div id="test">
 <em class="selected">11111</em>
 <em class="selected">22222</em>
 <em>33333</em>
 <em>44444</em>
</div>

JS代码如下:

// 取得div中所有em元素
var em = document.getElementById("test").querySelectorAll('em');
console.log(em); // NodeList
console.log(em.length); // 4

// 第二种方式 也可以先使用querySelector
var test = document.querySelector("#test");
var em2 = test.querySelectorAll('em');
console.log(em2); // NodeList
console.log(em2.length); // 4

// 取得类为selected的所有元素
var selected = document.querySelectorAll('.selected');
console.log(selected); // <em class="selected">11111</em>
    // <em class="selected">22222</em>
// 也可以通过以下的方式获得所有的em元素
var em = document.querySelectorAll('div em');
console.log(em); // NodeList
console.log(em.length); // 4

要赢得再次回到的NodeList中的每一个元素,可以动用item()方法,也得以使用方括号的语法;

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

浏览器协理程度:IE8+,firefox,chrome,safari3.1+,opera10+

3. matchesSelector()方法

以此情势接收一个参数,即css拔取符,就算调用元素与该拔取符匹配,再次回到true,否则,重返false;

正如代码:

console.log(document.body.webkitMatchesSelector(“body”)); // true

IE9+通过msMatchesSelector()接济该措施,Firefox3.6+通过mozMatchesSelector()协助该格局;safari5+和chrome通过webkitMatchesSelector()辅助该方法;因此大家得以打包一个函数,如下代码:

function matchesSelector(element,selector) {
if(element.MatchesSelector) {
 return element.MatchesSelector(selector);
}else if(element.msMatchesSelector) {
 return element.msMatchesSelector(selector);
}else if(element.webkitMatchesSelector) {
 return element.webkitMatchesSelector(selector);
}else if(element.mozMatchesSelector) {
 return element.mozMatchesSelector(selector);
}else {
  throw new Error("Not supported");
 }
}
console.log(matchesSelector(document.body,'body')); // true
var test = document.querySelector('#test');
console.log(matchesSelector(test,'#test')); // true

4. getElementsByClassName() 方法

该办法接收一个参数,即含有一个要么八个类名的字符串,再次来到带有指定类的具有因素的NodeList;传入多少个类名时,类名的先后顺序不紧要。

复制代码 代码如下:

<p class=”p1″>111</p>
<p class=”p1″>222</p>
<p class=”p1″>333</p>

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

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

5. classList属性

如下代码:

<div class=”aa bb cc” id=”div”>aaa</div>

我想删除aa这一个类名的时候,此前须求如下写代码:

var div = document.getElementById("div");
// 首先,取得类名字符串并拆分成数组
var classNames = div.className.split(/\s+/);
var pos = -1,
  i, 
 len;
for(i = 0,len = classNames.length; i < len; i+=1) {
 if(classNames[i] == 'aa') {
  pos = i;
  break;
 }
}
// 删除类名
classNames.splice(i,1);
// 把剩下的类名拼成字符串并重新设置
div.className = classNames.join(" "); 
// <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,代码如下:

<div class=”aa bb cc” id=”div”>aaa</div>

JS如下:

var div = document.getElementById("div");
// 删除类名aa,如下方法即可
div.classList.remove("aa");
// html结构如下: <div class="bb cc" id="div">aaa</div>
// 添加类名current,如下方法即可
div.classList.add("current");
// html结构变为如下 <div class="bb cc current" id="div">aaa</div>

// 切换aa类名
div.classList.toggle("aa");
// html结构变为如下 <div class="aa bb cc current" id="div">aaa</div>
// 确定元素是否包含类名;
console.log(div.classList.contains("aa")); // true

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

HTML5新增自定义数据属性

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

<div id=”myDiv” data-appId=”12345″
data-myname=”Nicholas”></div>

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

//本例中使用的方法仅用于演示
var div = document.getElementById("myDiv");
console.log(div.dataset); // DOMStringMap {value: "12345", name: "Nicholas"}
//取得自定义属性的值
var value1 = div.dataset.value;
console.log(value1); // 12345
var name1 = div.dataset.name;
console.log(name1); // Nicholas
//设置值
div.dataset.value = 23456;
div.dataset.name = "Michael";
//有没有"myname"值呢?
if (div.dataset.name){
 console.log("Hello, " + div.dataset.name); // Hello, Michael
}

亚洲必赢官网 9

浏览器接济的档次有;firefox6+和chrome浏览器;

您可能感兴趣的篇章:

  • 重整JavaScript对DOM中各体系型的因素的常用操作
  • JavaScript利用HTML
    DOM举行文档操作的点子
  • JavaScript操作HTML
    DOM节点的基础教程
  • JavaScript对HTML
    DOM使用伊夫(Eve)ntListener举行操作
  • 详解JavaScript操作HTML
    DOM的主干方法
  • JavaScript
    DOM操作表格及体制
  • js使用DOM操作完结简单留言板的办法
  • JavaScript操作DOM元素的childNodes和children区别
  • javascript中HTMLDOM操作详解
  • JavaScript基础语法、dom操作树及document对象
  • JS操作iframe里的dom(实例讲解)
  • 浅析JS操作DOM的有的常用方法
网站地图xml地图