DIV CSS 佈局教程網

從原型鏈看 DOM:Node 類型全解析
編輯:JavaScript基礎知識     

前言:本系列從原型、原型鏈、屬性類型等角度切入 DOM 物件模型,目的是把日常在用的每一個屬性與方法都弄清楚——它從哪裡來、做什麼事。全靠自己在總結中摸索,一個問題深究下去還真能挖出不少有意思的東西,越學越覺得 JavaScript 有趣。

一、DOM 是什麼

DOM(文件物件模型)是針對 HTML 與 XML 文件的一組 API。它把文件描繪成一棵層次化的節點樹,讓開發者能新增、移除、修改頁面的任意部分,是操作頁面標記跨平台、語言中立的標準方式。DOM1 提供了基本文件結構與查詢的介面,本系列主要討論 JavaScript 對 DOM1 的實作,並穿插部分 DOM2 與 DOM3 的內容。

節點層次

DOM 可以把任何 HTML 或 XML 文件描繪成多層節點構成的結構。節點分為多種類型,各自代表文件中不同的資訊與標記,也各有自己的屬性、方法與彼此關係。節點之間的關係構成層次,所有頁面標記表現為一棵以特定節點為根的樹。節點的概念比元素大,元素只是節點的一種類型。

  • 文件節點:每個文件的根節點。HTML 文件中 window.document(即 #document)只有一個子節點,就是 HTML 元素。
  • 文件元素:文件中最外層的元素,其他元素都包含在它裡面,每個文件只能有一個。HTML 頁面中文件元素永遠是 html;XML 沒有預定義元素,任何元素都能成為文件元素。

每一段標記都透過樹中的一個節點來表示:HTML 元素用元素節點、特性用特性節點、文件類型用文件類型節點、註解用註解節點……共有 12 種節點類型,全部繼承自同一個基類型 Node。這些類型包括:

  1. Node 類型
  2. Document 類型
  3. Element 類型
  4. Text 類型
  5. Comment 類型
  6. CDATASection 類型
  7. DocumentType 類型
  8. DocumentFragment 類型
  9. Attr 類型

相對應的 DOM 操作技術則包含:動態腳本、動態樣式、操作表格、使用 NodeList。本篇著重 Node 類型,其他類型留待後續說明。

二、Node 類型

DOM1 定義了一個 Node 介面,由所有節點類型實作。在 JavaScript 中它以 Node 類型存在,所有節點類型(Element、Attr、Text、CDATASection、Comment、Document、DocumentType、DocumentFragment 等)都繼承自它:

Element.prototype instanceof Node;  // true

因此所有節點類型的實例都共享原型鏈上的屬性與方法:

某類型實例 → 某類型.prototype → Node.prototype → EventTarget.prototype → Object.prototype

例如 document instanceof Node 為 true,因為 #document 既是 Document 類型的實例,也是 Node 的實例;html 元素則是 HTMLElement 的實例、Element 的實例,同時也是 Node 的實例。

一個有趣的思考:html 元素的 __proto__ 之謎

document.documentElement.__proto__ == HTMLElement.prototype;
// false —— html 元素實例的原型指向的不是 HTMLElement 的 prototype?

HTMLElement.prototype.isPrototypeOf(document.documentElement);
// true —— 但 HTMLElement.prototype 確實在 html 元素的原型鏈上

這是不是很矛盾?__proto__ 不是該指向建立這個實例的函式的原型嗎?而且 document.documentElement.__proto__ 與 HTMLElement.prototype 竟然不是同一個東西。

查了 MDN 上关于 Object.prototype.__proto__ 的說明後受了點啟發:

會不會是 document.documentElement.__proto__ 被引擎重寫了,重新指向一個 HTMLHtmlElement 類型的原型物件?查看它的 __proto__:

類型是 Element,而 HTMLElement.prototype 也是 Element 類型的實例,那這兩個是同一個嗎?驗證一下:

document.documentElement.__proto__.__proto__ == HTMLElement.prototype;  // true

確實如此。這也解釋了為什麼 html 元素改變了 [[Prototype]] 指向後,仍然留在原本的原型鏈上——引擎在預設原型鏈(html.__proto__ → HTMLElement.prototype → Element.prototype → Node.prototype → EventTarget.prototype → Object.prototype)中插入了一個額外物件。

那時我還不確定引擎為何要插入這一層,只注意到 html 元素身上有「版本」和「建構器」兩個屬性,而且無法直接透過 HTMLHtmlElement.prototype.version 存取,必須透過實例(也就是 html 元素)本身。

補充:後來透過 document.documentElement.__proto__.constructor 才確認,那個物件其實就是 HTMLHtmlElement 介面的原型物件。上面的推論有誤,但思考過程還是留著吧。真正的原型鏈是:

某元素.__proto__ → HTML某元素Element.prototype → HTMLElement.prototype
              → Element.prototype → Node.prototype → EventTarget.prototype → Object.prototype

例如 html 元素:document.documentElement.__proto__ → HTMLHtmlElement.prototype → HTMLElement.prototype → Element.prototype → Node.prototype → EventTarget.prototype → Object.prototype;body 元素則是 document.body.__proto__ → HTMLBodyElement.prototype → HTMLElement.prototype → …。兩者都可以透過 某元素.__proto__.constructor 取得對應的建構器。

Node.prototype 上的內容

可以注意到 Node.prototype 本身是 EventTarget 類型的實例,難怪 Node.prototype.__proto__ 會指向 EventTarget.prototype:

Object.getOwnPropertyNames(EventTarget.prototype);
// ["addEventListener", "removeEventListener", "dispatchEvent", "constructor"]

用組合繼承模式來類比,內部實作大概長這樣:

function EventTarget() { /* 初始化實例的屬性和方法 */ }
function Node()        { /* 初始化實例的屬性和方法 */ }

Node.prototype = new EventTarget();
Node.prototype.construct = Node;

// 以 Element 為例
Element.prototype = new Node();
Element.construct = Element;

不過實際上我們無法成功構造 Node 與 EventTarget 的實例,主控台會提示「不合法的建構」,可見這是引擎內部實作的:

三、Node.prototype 的常見屬性與方法

這些關係指標屬性大多是唯讀的,因為對應存取器屬性的 set 被設為 undefined。即使 set 可用,前提也得是該節點的對應屬性不為 null。因此 DOM 另外提供了一組操作節點的方法(從下面第 9 點開始,這些方法可寫,也可以在 Node.prototype 上重寫)。

1. nodeType 屬性

每個節點都繼承這個屬性,用來標示節點類型。型別由 Node 上定義的 12 個數值常數表示,這些常數是靜態屬性,掛在建構函式身上(加 * 者為常用):

* Node.ELEMENT_NODE;   // 1
* Node.ATTRIBUTE_NODE;  // 2
* Node.TEXT_NODE;       // 3
* Node.CDATA_SECTION_NODE; // 4
  Node.ENTITY_REFERENCE_NODE; // 5
  Node.ENTITY_NODE;     // 6
  Node.PROCESSING_INSTRUCTION_NODE; // 7
* Node.COMMENT_NODE;    // 8
* Node.DOCUMENT_NODE;   // 9
* Node.DOCUMENT_TYPE_NODE; // 10
* Node.DOCUMENT_FRAGMENT_NODE; // 11
  Node.NOTATION_NODE;   // 12

有意思的是,這些值同時也能透過 Node.prototype 或原型鏈存取,三種寫法完全等價:

Node.prototype.COMMENT_NODE == Node.COMMENT_NODE;  // true
Node.prototype.COMMENT_NODE;  // 8
Node.COMMENT_NODE;            // 8
document.COMMENT_NODE;        // 8

實務上為了相容那些沒有公開 Node 建構函式的瀏覽器,通常直接用數字比較:

if (someNode.nodeType == 1) {
    console.log("這是一個元素節點");
}

2. nodeName 與 nodeValue 屬性

這兩個屬性用來表示節點的具體資訊,但不同節點類型的含義不同。

(1) Element 元素節點(原型鏈:某元素.__proto__ → HTML某元素Element.prototype → HTMLElement.prototype → Element.prototype → Node.prototype → EventTarget.prototype)

nodeName 是標籤名,nodeValue 為 null。

var someNode = document.documentElement;  // 取得 HTML 元素
if (someNode.nodeType == 1) {
    console.log(someNode.nodeName + "是元素節點名");
    console.log("它的 nodeValue:" + someNode.nodeValue);
}
/* HTML是元素節點名
   它的nodeValue:null */

(2) Attr 特性節點(原型鏈:某特性節點.__proto__ → Attr.prototype → Node.prototype → EventTarget.prototype)

nodeName 是特性名稱,nodeValue 是特性的值。

var html = document.documentElement;
html.attributes;  // attributes 是 Element.prototype 上的屬性

這個回傳值是 NamedNodeMap 類型的實例,原型鏈為 html.attributes.__proto__ → NamedNodeMap.prototype → Object.prototype。它裡面才有我們真正需要的特性物件:

html.attributes["0"];             // lang="zh-cn",一個特性節點
html.attributes["1"];             // style="overflow:hidden;",另一個特性節點
html.attributes["lang"].nodeName; // "lang"
html.attributes["lang"].nodeValue;// "zh-cn"
html.attributes["0"] instanceof Attr;  // true

(3) Text 文本節點(原型鏈:某文本節點.__proto__ → Text.prototype → CharacterData.prototype → Node.prototype → EventTarget.prototype)

nodeName 為 "#text",nodeValue 為節點包含的文字。

(4) CDATASection 節點(原型鏈:實例.__proto__ → CDATASection.prototype → Text.prototype → CharacterData.prototype → Node.prototype → EventTarget.prototype)

nodeName 為 "#cdata-section",nodeValue 為 CDATA 區塊中的內容。

(5) Comment 註解節點(僅針對 XML 文件;原型鏈:實例.__proto__ → Comment.prototype → CharacterData.prototype → Node.prototype → EventTarget.prototype)

nodeName 為 "#comment",nodeValue 為註解內容。

(6) Document 文件節點(原型鏈:document.__proto__ → HTMLDocument.prototype → Document.prototype → Node.prototype → EventTarget.prototype)

Document.prototype 上的屬性與方法多達 176 個,用 Object.getOwnPropertyNames() 取出的結果是一個 Array 實例:

可以發現 document 節點與 element 元素節點的事件屬性並非統一繼承,而是在各自的原型鏈上分別繼承。nodeName 為 "#document",nodeValue 為 null。

(7) DocumentType 節點(原型鏈:document.doctype.__proto__ → DocumentType.prototype → Node.prototype → EventTarget.prototype)

nodeName 為 doctype 的名稱,nodeValue 為 null。

(8) DocumentFragment 節點(原型鏈:文檔片段實例.__proto__ → DocumentFragment.prototype → Node.prototype → EventTarget.prototype)

可以注意到它與 Document.prototype 有相當多方法重疊。nodeName 為 "#document-fragment",nodeValue 為 null。

3. childNodes 屬性

每個節點都繼承這個屬性,值是一個 NodeList 物件。這裡要區分 NodeList 與 HTMLCollection 兩種介面:

(1) NodeList 介面——為 childNodes 屬性提供,原型鏈:某節點.childNodes.__proto__ → NodeList.prototype → Object.prototype。符合的還有 getElementsByName、querySelectorAll 等。

原型上的 item() 方法回傳指定索引的節點,索引越界時回傳 null。等價寫法是 nodeList[idx],但這種寫法越界時回傳的是 undefined。

把 NodeList 轉成真陣列,最經典的做法是借用原生的 slice:

function transToArr(collections, start, end) {
    var length = arguments.length;
    if (length == 0) {
        return;
    } else if (length == 1) {
        return Array.prototype.slice.call(collections);
    } else {
        if (typeof arguments[1] == 'number') {
            if (typeof arguments[2] == 'number') {
                return Array.prototype.slice.call(collections, start, end);
            } else {
                // end 不是數字時,slice 會取到最後
                end = collections.length;
                return Array.prototype.slice.call(collections, start, end);
            }
        }
    }
}

(2) HTMLCollection 介面——包含元素的通用集合,原型鏈:集合.__proto__ → HTMLCollection.prototype → Object.prototype。透過 getElementsByTagName、getElementsByClassName、getElementsByTagNameNS、document.forms 等取得的都是它。

(3) 即時更新的集合——NodeList 與 HTMLCollection 大多數時候是「live」的,當文件結構改變時會自動更新。下圖中 nodechilds 與 lis 內容相同卻互不相等,是因為兩者保存的引用位址不同,但各自的每一項都指向同一個 element 節點。所以刪除一個 li 之後,兩個集合都會同步變化。

正因為是動態集合,childNodes.length 會即時變化,所以清空文字節點時要特別注意迴圈的遞增方式:

// 刪除 childNodes 中的所有文字節點
// 因為 child.length 是動態變化的,所以只在「沒刪」時才 i++
var child = parent.childNodes;
for (var i = 0; i < child.length; ) {
    if (child[i].nodeType == 3) {
        parent.removeChild(child[i]);   // 刪掉之後 i 保持不動,下次直接看新的 child[i]
    } else {
        i++;
    }
}

但 NodeList 並非永遠動態——querySelectorAll() 回傳的就是靜態集合,之後對 DOM 的任何改動都不會影響它:

所以當你要遍歷 NodeList 或快取長度時,先想清楚手上這份是動態還是靜態。

4. parentNode 屬性

指向文件樹中的父節點,可能是 Document 類型,也可能是 Element 類型。

5. previousSibling 與 nextSibling 屬性

childNodes 列表中第一個節點的 previousSibling 為 null,最後一個節點的 nextSibling 也為 null。

6. firstChild 與 lastChild 屬性

分別指向父節點 childNodes 的第一個與最後一個節點。只有一個子節點時兩者指向同一個;沒有子節點時兩者皆為 null。

7. hasChildNodes()

包含一個或多個子節點時回傳 true,比 childNodes.length 判斷起來更直觀。它的 writable 看起來是允許的,可以試著重寫(重寫在實例上或 Node.prototype 上都可以):

8. ownerDocument

指向代表整個文件的文件節點。任何節點都屬於它所在的文件,不可能同時存在於兩個文件中。透過這個屬性可以直接取到根節點,不必層層回溯。注意 document.ownerDocument 為 null。

9. parentNode.appendChild()

回傳新增的節點。這裡插一段觀察:重寫 Node.prototype.appendChild 之後發現,只要可取得焦點的區域(a、input、button 等)獲得焦點,就會觸發 appendChild;輸入內容期間不觸發,刪除內容時又會觸發,而且一次觸發執行 4 次(不同頁面測試有 3 次的)。猜測是獲得焦點相當於插入了游標,DOM 結構被改動了才觸發這個事件;而游標不移開時在原位編輯不算結構變化,所以不觸發。至於為何要執行 4 次就不得而知了。日常之所以感覺不到,應該是引擎內部做了妥善處理。

回到主題:appendChild() 會把節點加到 childNodes 的末尾,新增後 childNodes、父節點與原本最後一個子節點的關係指標都會相應更新。如果傳入的節點本來就在文件中,結果會是把它從原位置搬到新位置。

var a = document.body.firstChild;
document.body.appendChild(document.body.firstChild) == a;  // true
a == document.body.lastChild;                              // true

10. parentNode.insertBefore(要插入的節點, 參照節點)

插入到 childNodes 的指定位置。插入後,被插入節點會成為參照節點的前一個同胞節點,並回傳被插入的節點。

如果參照節點是 null,效果等同 appendChild()——因為插到 null 之前,就是插在最後一個子節點之後。基於這個思路,可以自己實作 insertAfter:

// 插入到 desEle 之後,等同插入到 desEle.nextSibling 之前
Node.prototype.insertAfter = function (srcEle, desEle) {
    this.insertBefore(srcEle, desEle.nextSibling);
    return srcEle;
};

11. parentNode.replaceChild(新節點, 要被替換的節點)

被替換的節點會由這個方法回傳,並從文件樹中移除;新節點佔據它的位置,並複製被替換節點的所有關係指標。技術上被替換的節點仍屬於文件,但它在文件中已經沒有自己的位置了。

var parent = $('#hdtb-msb');
var first = parent.firstChild;
var last  = parent.lastChild;
var firstnode = parent.replaceChild(last, first);
firstnode;               // 原本的第一個子節點,已被換出
firstnode.ownerDocument; // #document,證明它仍屬於文件

12. removeChild()

參數為要移除的節點,回傳被移除的節點。與 replaceChild 類似,被移除的節點仍為文件所有,只是不再佔據文件中的位置。

13. node.cloneNode()

建立呼叫者的一個完全相同的副本。參數為 true 進行深複製(含整個子節點樹),false 進行淺複製(只有節點本身)。複製後的節點屬於文件所有但沒有父節點,需要透過 appendChild、insertBefore 或 replaceChild 加入文件。

var clone1 = last.cloneNode(true);
clone1;  // 含子節點的完整副本
var clone2 = last.cloneNode(false);
clone2;  // 只有本身,沒有子節點
clone1.ownerDocument == clone2.ownerDocument;  // true

注意:cloneNode() 不會複製以 JavaScript 方式附加的屬性,例如用 addEventListener 綁定的事件處理器。它只複製特性(包含以 HTML 特性方式綁定的事件,例如 <h1 onclick="..."> 這種會被複製成功)與子節點(深複製時),其他都不複製。

14. normalize()

用來處理文件樹中的文字節點。由於解析器或 DOM 操作的緣故,可能出現「文字節點內容為空」或「連續兩個文字節點並存」的情況。在節點上呼叫這個方法時,會搜尋其後代節點:找到空文字節點就刪除,找到相鄰文字節點就合併為一個。

所謂空文字節點,指的是內容真的為空。例如:

document.createTextNode('');   // 空,會被刪除
document.createTextNode(' ');  // 只有空格,不算空
document.createTextNode(' ');  // 只有空格,不算空

也就是要看該文字節點在 CharacterData.prototype 上的 data 屬性值。下圖中的 data 是換行符,雖然視覺上看起來像空行,但並不是空字串,所以不會被刪除。因此要注意:這種寫法下 ul 的 childNodes 裡那些「文字節點」其實是換行符。

<ul>
    <li></li>
    <li></li>
</ul>

參考:《JavaScript 高級程序設計》、MDN 的 HTMLCollection 與 NodeList 文件。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved