您的位置:澳门新葡8455最新网站 > Web前端 > 您所不掌握的javascript操作DOM的细节知识点,Ele

您所不掌握的javascript操作DOM的细节知识点,Ele

发布时间:2019-10-07 19:27编辑:Web前端浏览(102)

    DOM Element节点类型详解

    2015/09/21 · HTML5 · DOM

    本文作者: 伯乐在线 - 韩子迟 。未经小编许可,禁绝转发!
    款待加入伯乐在线 专栏我。

    上文中大家解说了 DOM 中最关键的节点类型之一的 Document 节点类型,本文大家承继深远,谈谈另一个最主要的节点类型 Element 。

    一:Node类型

    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类型中有以下三种:

    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); 文书档案节点

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

    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>
    

    打赏扶助自个儿写出越来越多好小说,多谢!

    图片 1

    1 赞 1 收藏 评论

    JS如下:

    关于作者:韩子迟

    图片 2

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

    图片 3

    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列表的最后加多一个节点;重返的是新添的节点;如下代码:

    <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 = “笔者是龙恩”;

    U卡宴L:  取得页面中完全的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个参数,第多少个参数是性质名称,第4个参数是呼应的值;如若该值存在,则会以现行反革命的值替换此前的值,如若属性名官样文章,则会创立该属性,并点名该属性的值;如下代码:

    <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);
    });

    地点的EventUtil.addHandler 是大家事先在javascript事件下结论中封装的JS函数,现在大家一直拿过来使用,如下代码:

    var EventUtil = {
     addHandler: function(element,type,handler) {
      if(element.addEventListener) {
        element.addEventListener(type,handler,false);
      }else if(element.attachEvent) {
       element.attachEvent("on"+type,handler);
      }else {
       element["on" +type] = handler;
      }
     },
     removeHandler: function(element,type,handler){
      if(element.removeEventListener) {
        element.removeEventListener(type,handler,false);
      }else if(element.detachEvent) {
       element.detachEvent("on"+type,handler);
      }else {
       element["on" +type] = null;
      }
     },
     getEvent: function(event) {
      return event ? event : window.event;
     },
     getTarget: function(event) {
      return event.target || event.srcElement;
     },
     preventDefault: function(event){
      if(event.preventDefault) {
       event.preventDefault();
      }else {
       event.returnValue = false;
      }
     },
     stopPropagation: function(event) {
      if(event.stopPropagation) {
       event.stopPropagation();
      }else {
       event.cancelBubble = true;
      }
     }
    };
    

    上边大家来看看哪些利用JS事件来决断JS是还是不是加载成功的代码,大家得以应用load事件来监听,如下代码:

    EventUtil.addHandler(window,'load',function(){
     var script = document.createElement("script");
     EventUtil.addHandler(script,'load',function(event){
      console.log(script.src);
     });
     script.src = 'a.js';
     document.body.appendChild(script);
    });
    

    如上代码,script成分也会触发load事件,以便能够分明动态加载jS是不是加载成功,上面包车型大巴代码钦赐src属性和点名的事件管理程序的事件能够替换个方式置,前后相继顺序不首要,如上代码,大家也足以如此写,如下代码:

    EventUtil.addHandler(window,'load',function(){
     var script = document.createElement("script");
     script.src = 'a.js';
     document.body.appendChild(script);
     EventUtil.addHandler(script,'load',function(event){
      console.log(script.src);
     });  
    });
    

    时下只有IE9+,Firefox,opera,chrome和safari3+帮助,IE8及以下不协理该load事件,由此大家要求针对IE8及以下做管理;

    理解readystatechange事件

    IE为DOM文书档案中的有个别部分提供了readystatechange事件,这么些事件的指标提供与文书档案或因素的加载的情形有关音讯,那件事件提供了上面5个值中的一个;

    uninitialized(未早先化):对象存在但未曾起初化;
    loading(正在加载):对象正在加载数据;
    loaded(加载完结): 对象加载数据造成;
    interactive(交互): 能够操作对象了,但绝非完全加载;
    complete(完毕):对象已经加载成功;

    <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及以下会报错,如下:

    图片 5

    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
    }
    

    图片 6

    浏览器协理的水平有;firefox6+和chrome浏览器;

    您或许感兴趣的文章:

    • 收拾JavaScript对DOM中各类别型的元素的常用操作
    • JavaScript利用HTML DOM举办文书档案操作的情势
    • JavaScript操作HTML DOM节点的基础教程
    • JavaScript对HTML DOM使用EventListener举行操作
    • 详解JavaScript操作HTML DOM的大旨方法
    • JavaScript DOM操作表格及体制
    • js使用DOM操作落成简单留言板的方法
    • JavaScript操作DOM元素的childNodes和children区别
    • javascript中HTMLDOM操作详解
    • JavaScript基础语法、dom操作树及document对象
    • JS操作iframe里的dom(实例解说)
    • 浅析JS操作DOM的有的常用方法

    本文由澳门新葡8455最新网站发布于Web前端,转载请注明出处:您所不掌握的javascript操作DOM的细节知识点,Ele

    关键词:

上一篇:HTTP Client Hints 介绍

下一篇:没有了