DOM 是前端開發的基本功,但真正容易出問題的往往不是 API 名稱,而是那些看似理所當然的細節。本文從 Node 型別開始,把節點關係、屬性操作、動態載入與 DOM 擴充逐一梳理。
DOM 1 級定義了一個 Node 介面,由 DOM 中所有節點型別實作。每個節點都有一個 nodeType 屬性用來標示型別,常見的有:
Node.ELEMENT_NODE(1); 元素節點 Node.ATTRIBUTE_NODE(2); 屬性節點 Node.TEXT_NODE(3); 文本節點 Node.DOCUMENT_NODE(9); 文檔節點
實際上還有很多種,但常用的就這四種。先看一段範例:
<div id="test"> <p>aaaaaa</p> <p>bbbbbb</p> <p>cccccc</p> </div>
var test = document.getElementById("test");
if (test.nodeType === Node.ELEMENT_NODE) {
alert(1)
}
這段程式在 IE8 及以下會報錯:

因為 IE 並未公開 Node 型別的建構函式。解法是直接用數值比較——元素節點是 1、屬性節點是 2、文本節點是 3:
var test = document.getElementById("test");
// 下面的所有瀏覽器都支援
if (test.nodeType == 1) {
alert(1)
}
元素的 nodeName 保存的是標籤名稱,而 nodeValue 一般都是 null:
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 互為兄弟節點。每個節點都有一個 childNodes 屬性,保存類似陣列的內容,也有 length 屬性,但它不是 Array 的實例:
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——因為標籤之間的空白也被當成文本節點計入了。但在 IE8 及以下,長度是 3,它們不把空白算進去。若想統一行為,最簡單的辦法是讓 HTML 不帶多餘空白:
<div id="test"><p>aaaaaa</p><p>bbbbbb</p><p>cccccc</p></div>
取得子元素有兩種寫法,中括號索引或 item():
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
可以透過 slice 借用轉成真陣列:
// 在 IE8 及之前版本中無效 var arrayOfNodes = Array.prototype.slice.call(test.childNodes, 0); console.log(arrayOfNodes instanceof Array); // true
由於 IE8 及更早版本把 NodeList 實作為 COM 物件,不能像一般 JScript 物件那樣處理。要在舊版 IE 中也能轉換,可以封裝一個方法:
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:當前節點的下一個同胞節點。
<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 與 lastChild:
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>
}
恆等式永遠成立:
console.log(test.firstChild === test.childNodes[0]); // true console.log(test.lastChild === test.childNodes[test.childNodes.length - 1]); // true
若沒有子節點,兩者都是 null。
hasChildNodes() 用來判斷是否有子節點,回傳布林值:
var test = document.getElementById("test");
console.log(test.hasChildNodes()); // true
若元素是空的 <div id="test"></div>,則回傳 false。
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 列表末尾添加節點,回傳新增的節點:
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() 把新節點插入到指定節點之前,接收兩個參數:要插入的節點與作為參照的節點。插入後新節點會成為參照節點的前一個同胞節點,並被回傳:
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);
結果為:
<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() 接收兩個參數:要插入的節點與要被替換的節點。被替換的節點會由方法回傳並從文件樹中移除,插入的節點則佔據其位置。
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>
替換後的結構為:
<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 deeplist = test.cloneNode(false);
console.log(deeplist); // <div id="test"></div>
JavaScript 透過 Document 型別表示文件,document 是 HTMLDocument(繼承自 Document)的一個實例,代表整個 HTML 頁面。它是 window 的屬性,因此可以透過全域物件存取,並有以下特點:
· nodeType 值為 9
· nodeName 值為 "#document"
· nodeValue 值為 null
· parentNode 值為 null
· ownerDocument 值為 null
documentElement 永遠指向 html 元素,直接取用比層層查找更快:
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 取得頁面完整網址:
console.log(document.URL); // https://127.0.0.1/dom/dom.html
domain 取得頁面所在網域,也可以設定,常見的跨子域場景就是把多個子域的 domain 設為相同的父域:
console.log(document.domain); // 127.0.0.1
namedItem() 可以透過元素的 name 特性取得集合中的項目:
<input name="aa"/> <input name="bb"/>
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 節點的特徵:
· 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 元素都由 HTMLElement 型別表示,它直接繼承 Element。取得元素特性有三個方法。
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,那時必須改用 className:
// 在 IE7 下測試
console.log(test.getAttribute("className")); // testName
自訂屬性也一樣能取:
<div id="test" data-value="test1"></div>
console.log(test.getAttribute("data-value")); // test1
setAttribute() 接收屬性名稱與值兩個參數。若屬性已存在則以新值替換,不存在則建立並賦值:
<div id="test"></div>
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() 刪除元素特性(IE7 及以下刪除類名需用 className):
var test = document.getElementById("test");
test.removeAttribute("id");
test.removeAttribute("class");
test.removeAttribute("title");
test.removeAttribute("data-value");
Element 是唯一具備 attributes 屬性的 DOM 節點型別,該屬性包含一個 NamedNodeMap 集合。集合中每個節點的 nodeName 就是特性名稱,nodeValue 就是特性值。
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
div.attributes["id"].nodeValue = "aa";
removeNamedItem(name) 從列表中移除 nodeName 等於 name 的節點,效果等同於在元素上呼叫 removeAttribute(),差別在於它會回傳被刪除的節點:
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 就派上用場了:
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. 不同瀏覽器回傳特性的順序不同;
2. IE7 及更早版本會回傳 HTML 元素上所有可能的特性,包含從未指定的那些。
針對第二點可以這樣改進:每個特性節點都有一個 specified 屬性,值為 true 代表該特性確實在 HTML 中指定過,或透過 setAttribute 設定過;在 IE 中,從未設定的特性該值都是 false:
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 包含它的所有子節點,這些子節點可能是元素、文本節點、註解或處理指令。不同瀏覽器統計的數量並不一樣:
<ul id="list"> <li>11</li> <li>22</li> <li>33</li> </ul>
var list = document.getElementById("list");
console.log(list.childNodes);
console.log(list.childNodes.length);
標準瀏覽器(IE9+、Firefox、Chrome)印出的長度是 7,因為把空白也算進去了;IE8 及以下回傳 3。如果把 HTML 中的空白全部去掉:
<ul id="list"><li>11</li><li>22</li><li>33</li></ul>
那麼所有瀏覽器都會回傳 3。
現實中我們不可能時時小心地不產生空白,因此更實際的做法是在程式碼中過濾:
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。
文本節點的特徵:
· nodeType 值為 3
· nodeName 值為 "#text"
· nodeValue 值為節點所包含的文本
· parentNode 是一個 Element
· 沒有子節點
建立文本節點用 document.createTextNode(),參數是要插入的文本:
var element = document.createElement("div");
var text = document.createTextNode("aa");
element.appendChild(text);
document.body.appendChild(element);
分割文本節點用 splitText(offset),從 offset 位置把當前節點切成兩個:
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 都支援。
最常見的寫法如下,會在 body 末尾動態插入 a.js,且不會阻塞瀏覽器載入:
var script = document.createElement("script");
script.type = "text/javascript";
script.src = 'a.js';
document.body.appendChild(script);
為了方便重複使用,可以封裝成函式:
function loadScript(url) {
var script = document.createElement("script");
script.type = "text/javascript";
script.src = url;
document.body.appendChild(script);
}
loadScript("a.js");
多個 js 依序呼叫 loadScript 即可。
但如果有個需求是「動態載入完成後要接著做點事」呢?動態載入等同於非同步載入,不會阻塞瀏覽器,因此我們需要一個通知機制。JavaScript 中最常用的是 load 事件:當頁面載入完成(包含所有圖片、javascript 檔、css 檔等外部資源)後,window 上的 load 事件就會觸發。觸發方式有兩種:
<body onload="a()"></body>
或者透過 JavaScript 綁定:
EventUtil.addHandler(window, 'load', function(event){
alert(1);
});
這裡的 EventUtil 是之前文章中介紹過的跨瀏覽器事件封裝:
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 是否載入完成就很簡單——script 元素同樣會觸發 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);
});
指定 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 與 Safari 3+ 支援,IE8 及以下不支援,需要另外處理。
IE 為 DOM 文件的某些部分提供了 readystatechange 事件,用來回報文件或元素的載入狀態,共有五個可能的值:
· uninitialized(未初始化):物件存在但尚未初始化;
· loading(正在載入):物件正在載入資料;
· loaded(載入完畢):資料載入完成;
· interactive(交互):可以操作物件了,但尚未完全載入;
· complete(完成):物件已完全載入。
<script>(IE 與 Opera)與 <link>(僅 IE)元素也會觸發這個事件,可用來確認外部 js 與 css 是否載入完成。基於元素觸發時,readyState 等於 "loaded" 或 "complete" 都代表資源已可用:
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);
});
再加上客戶端偵測,就能封裝出一個跨瀏覽器的版本:
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);
});
另一種方式是行內寫法:
<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 及以下會報錯:

因為 IE8 及以下把 script 視為一個特殊元素,不允許 DOM 存取其子節點。解法是改用 script 元素的 text 屬性:
var script = document.createElement('script');
script.type = 'text/javascript';
script.text = "function sayHi(){alert(1);} sayHi()";
document.body.appendChild(script);
這樣在所有主流瀏覽器(含 IE8 及以下)都能正常運作。但 Safari 3.0 之前的版本不支援 text 屬性,卻允許使用文本節點。兩者搭配 try/catch 就能通吃:
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()");
與動態腳本類似,動態樣式指的是頁面初次載入時並不存在、而在載入完成後才動態加入的樣式:
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);
同樣可以封裝成函式:
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 也可以改用 readystatechange:
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);
});
把兩者整合,就得到一個涵蓋所有瀏覽器(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);
同樣用 try/catch 就能做到全相容:
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}");
querySelector() 接收一個 CSS 選擇符,回傳與該模式匹配的第一個元素,找不到則回傳 null:
<div id="test">test</div> <div class="cls">1111</div> <div class="cls">2222</div> <div class="cls">2222</div>
// 取得 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 呼叫時,只會在該元素的後代範圍內查找:
<div class="testParent"> <p>1111</p> <p>2222</p> </div>
var testParent = document.querySelector('.testParent');
var pfirst = testParent.querySelector("p");
console.log(pfirst); // <p>1111</p>
支援程度:IE8+、Firefox、Chrome、Safari 3.1+、Opera 10+。
參數與 querySelector 相同,但回傳所有匹配的元素,型別是 NodeList 實例:
<div id="test"> <em class="selected">11111</em> <em class="selected">22222</em> <em>33333</em> <em>44444</em> </div>
// 取得 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);
// 也可以用後代選擇符
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、Safari 3.1+、Opera 10+。
接收一個 CSS 選擇符,若呼叫的元素與該選擇符匹配則回傳 true,否則回傳 false:
console.log(document.body.webkitMatchesSelector("body")); // true
各瀏覽器早期都帶有前綴:IE9+ 是 msMatchesSelector(),Firefox 3.6+ 是 mozMatchesSelector(),Safari 5+ 與 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
接收一個包含一個或多個類名的字串,回傳帶有指定類的所有元素的 NodeList。傳入多個類名時,順序並不重要。
<p class="p1">111</p> <p class="p1">222</p> <p class="p1">333</p>
console.log(document.getElementsByClassName("p1")); // 回傳 NodeList
支援的瀏覽器有 IE9+、Firefox 3+、Safari 3.1+、Chrome 與 Opera 9.5+。
過去若要刪除一個類名,得自己拆字串、找位置、再拼回去:
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 屬性,讓操作變得乾淨得多。它是 DOMTokenList 的實例,具備表示項目數量的 length 屬性,可透過 item() 或方括號取得每個項目,並提供以下方法:
· add(value):將字串值加入列表,若已存在則不重複添加;
· contains(value):判斷列表中是否存在該值,回傳布林值;
· remove(value):從列表中刪除該字串;
· toggle(value):存在則刪除,不存在則添加。
var div = document.getElementById("div");
// 刪除類名 aa
div.classList.remove("aa");
// <div class="bb cc" id="div">aaa</div>
// 添加類名 current
div.classList.add("current");
// <div class="bb cc current" id="div">aaa</div>
// 切換 aa 類名
div.classList.toggle("aa");
// <div class="aa bb cc current" id="div">aaa</div>
// 確定元素是否包含類名
console.log(div.classList.contains("aa")); // true
支援 classList 的瀏覽器有 IE10+、Firefox 3.6+ 與 Chrome。
HTML5 允許為元素添加非標準屬性,但必須加上 data- 前綴:
<div id="myDiv" data-appId="12345" data-myname="Nicholas"></div>
添加之後,可以透過元素的 dataset 屬性存取,它是 DOMStringMap 的實例,也就是一個名值對的映射:
// 本例中使用的方法僅用於演示
var div = document.getElementById("myDiv");
console.log(div.dataset); // DOMStringMap {appId: "12345", myname: "Nicholas"}
// 取得自訂屬性的值
var value1 = div.dataset.appId;
console.log(value1); // 12345
var name1 = div.dataset.myname;
console.log(name1); // Nicholas
// 設定值
div.dataset.appId = 23456;
div.dataset.myname = "Michael";
// 有沒有 myname 值呢?
if (div.dataset.myname) {
console.log("Hello, " + div.dataset.myname); // Hello, Michael
}

要注意 dataset 取值時會把 data- 之後的連字號命名轉成駝峰式(例如 data-app-id 對應 dataset.appId)。支援 dataset 的瀏覽器有 Firefox 6+ 與 Chrome。
這些細節單看都不難,但累積起來就是DOM 操作穩不穩定的關鍵。特別是三點值得牢記:childNodes 會把空白算成節點,屬性查找永遠是「先實例、後原型」,以及動態載入資源時必須針對 IE 的 readystatechange 與標準瀏覽器的 load 事件分別處理。把這些行為理解透,寫出來的程式才不會在跨瀏覽器環境裡出意外。