DOM Element节点类型详解俄罗斯贵宾会：

2019-11-21

DOM Element节点类型详解

2015/09/21 · HTML5 · DOM

本文作者：伯乐在线 - 韩子迟。未经作者许可，禁止转载！
欢迎加入伯乐在线专栏作者。

上文中我们讲解了 DOM 中最重要的节点类型之一的 Document 节点类型，本文我们继续深入，谈谈另一个重要的节点类型 Element 。

一：Node类型

1、概况

Element 类型用于表现 HTML 或 XML 元素，提供了对元素标签名、子节点及特性的访问。 Element 节点具有以下特征：

nodeType 的值为 1
nodeName 的值为元素的标签名
nodeValue 的值为null
parentNode 可能是 Document 或者 Element
其子节点可能是 Element、Text、Comment、ProcessingInstruction、CDATASection 或者 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') { // 这样最好，适用于任何文档 // ... }

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类型中有以下几种：

2、HTML 元素

所有 HTML 元素都由 HTMLElement 类型表示，不是直接通过这个类型，也是通过它的子类型来表示。 HTMLElement 类型直接继承自 Element 并添加了一些属性。每个 HTML 元素中都存在下列标准属性：

id 元素在文档中的唯一标识符
title 有关元素的附加说明信息，一般通过工具提示条显示出来
lang 元素内容的语言代码，很少使用
dir 语言的方向，值为 ltr 或者 rtl，也很少使用
className 与元素的 class 特性对应

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

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>

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')

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 对象拥有下列方法：

getNamedItem(name): 返回 nodeName 属性等于 name 的节点
removeNamedItem(name): 从列表移除 nodeName 属性等于 name 的节点
setNamedItem(node): 向列表中添加节点，以节点的 nodeName 属性为索引
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);

// 取得元素的特性值

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>

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代码如下：

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>

</ul>

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>

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>

打赏支持我写出更多好文章，谢谢！

俄罗斯贵宾会 1

1 赞 1 收藏评论

JS如下：

关于作者：韩子迟

a JavaScript beginner 个人主页 · 我的文章 · 9 ·

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

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

俄罗斯贵宾会 4

因为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列表的末尾添加一个节点；返回的是新增加的节点；如下代码：

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个参数，要插入的节点和作为参照的节点；插入节点后，被插入的节点会变成参照节点的前一个同胞节点，同时被方法返回，如下代码：

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

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

复制代码代码如下:

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

复制代码代码如下:

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

插入后HTML结构如下：

复制代码代码如下:

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

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个参数，要插入的节点和要替换的节点，要替换的节点将由这个方法返回并从文档树中被移除，同时由插入的节点占据其位置，如下代码：

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代码结构变为如下：

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

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>

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

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

// 移除最后一个节点
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); // http://127.0.0.1/dom/dom.html

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

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

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

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

HTML代码如下：

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

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

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

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

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

生成HTML结构如下：

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

JS代码如下：

var test = document.getElementById("test");
test.removeAttribute("id");
test.removeAttribute("class");
test.removeAttribute("title");
test.removeAttribute("data-value");

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

attributes属性

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

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

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

<div id="test" class="testName" title="aa" data-value="test1"></div>JS代码如下：

复制代码代码如下:

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

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

复制代码代码如下:

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

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

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

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

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

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

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

如下代码：

JS代码如下：

复制代码代码如下:

本文由俄罗斯贵宾会发布于Web前端,转载请注明出处：DOM Element节点类型详解俄罗斯贵宾会：

上一篇：没有了

下一篇：没有了

DOM Element节点类型详解俄罗斯贵宾会：

DOM Element节点类型详解

1、概况

2、HTML 元素

3、特性的获取和设置

4、attributes 属性

5、元素的子节点

打赏支持我写出更多好文章，谢谢！

关于作者：韩子迟

您可能还会对下面的文章感兴趣：

相关文章