最近下了Chrome的源碼,安裝了一個debug版的Chromium研究了一下,雖然不少地方都只知其一;不知其二,可是仍是有一點收穫,將在這篇文章介紹DOM樹是如何構建的,看了本文應該能夠回答如下問題:html
先說一下,怎麼安裝一個能夠debug的Chromehtml5
爲了能夠打斷點debug,必須得從頭編譯(編譯的時候帶上debug參數)。因此要下載源碼,Chrome把最新的代碼更新到了Chromium的工程,是徹底開源的,你能夠把它整一個git工程下載下來。Chromium的下載安裝可參考它的文檔, 這裏把一些關鍵點說一下,以Mac爲例。你須要先下載它的安裝腳本工具,而後下載源碼:node
1
|
fetch chromium --no-history
|
–no-history的做用是不把整個git工程下載下來,那個實在是太大了。或者是直接執行git clone:git
1
|
git clone https://chromium.googlesource.com/chromium/src
|
這個就是整一個git工程,下載下來有6.48GB(那時)。博主就是用的這樣的方式,若是下載到最後提示出錯了:github
1
2
3
|
fatal:The remote endhung up unexpectedly
fatal:early EOF
fatal:index-pack failed
|
能夠這樣解決:chrome
1
2
|
git config --global core.compression0
git clone --depth1 https://chromium.googlesource.com/chromium/src
|
就不用重頭開始clone,由於實在太大、太耗時了。xcode
下載好以後生成build的文件:瀏覽器
1
|
gn gen out/gn --ide=xcode
|
–ide=xcode是爲了可以使用蘋果的XCode進行可視化進行調試。gn命令要下載Chrome的devtools包,文檔裏面有說明。數據結構
裝備就緒以後就能夠進行編譯了:app
1
|
ninja -C out/gn chrome
|
在筆者的電腦上編譯了3個小時,firfox的源碼須要編譯七、8個小時,因此相對來講已經快了不少,同時沒報錯,一次就過,至關順利。編譯組裝好了以後,會在out/gn目錄生成Chromium的可執行文件,具體路徑是在:
1
|
out/gn/Chromium.app/Contents/MacOS/Chromium
|
運行這個就能夠打開Chromium了:
那麼怎麼在可視化的XCode裏面進行debug呢?
在上面生成build文件的同時,會生成XCode的工程文件:sources.xcodeproj,具體路徑是在:
1
|
out/gn/sources.xcodeproj
|
雙擊這個文件,打開XCode,在上面的菜單欄裏面點擊Debug -> AttachToProcess -> Chromium,要先打開Chrome,才能在列表裏面看到Chrome的進程。而後小試牛刀,打個斷點試試,看會不會跑進來:
在左邊的目錄樹,打開chrome/browser/devtools/devtools_protocol.cc這個文件,而後在這個文件的ParseCommand函數裏面打一個斷點,按照字面理解這個函數應該是解析控制檯的命令。打開Chrome的控制檯,輸入一條命令,例如:new Date(),按回車能夠看到斷點生效了:
經過觀察變量值,能夠看到剛剛敲進去的命令。這就說明了咱們安裝成功,而且能夠經過可視化的方式進行調試。
可是咱們要debug頁面渲染過程,Chrome的blink框架使用多進程技術,每打開一個tab都會新開一個進程,按上面的方式是debug不了構建DOM過程的,從Chromium的文檔能夠查到,須要在啓動的時候帶上一個參數:
1
|
Chromium --renderer-startup-dialog
|
Chrom的啓動進程就會緒塞,而且提示它的渲染進程ID:
[7339:775:0102/210122.254760:ERROR:child_process.cc(145)] Renderer (7339) paused waiting for debugger to attach. Send SIGUSR1 to unpause.
7339就是它的渲染進程id,在XCode裏面點 Debug -> AttachToProcess By Id or Name -> 填入id -> 肯定,attach以後,Chrome進程就會恢復,而後就能夠開始調試渲染頁面的過程了。
在content/renderer/render_view_impl.cc這個文件的1093行RenderViewImpl::Create函數裏面打個斷點,按照上面的方式,從新啓動Chrome,在命令行帶上某個html文件的路徑,爲了打開Chrome的時候就會同時打開這個文件,方便調試。執行完以後就能夠看到斷點生效了。能夠說render_view_impl.cc這個文件是第一個具體開始渲染頁面的文件——它會初始化頁面的一些默認設置,如字體大小、默認的viewport等,響應關閉頁面、OrientationChange等事件,而在它再往上的層主要是一些負責通訊的類。
先畫出構建DOM的幾個關鍵的類的UML圖,以下所示:
第一個類HTMLDocumentParser負責解析html文本爲tokens,一個token就是一個標籤文本的序列化,並藉助HTMLTreeBuilder對這些tokens分類處理,根據不一樣的標籤類型、在文檔不一樣位置,調用HTMLConstructionSite不一樣的函數構建DOM樹。而HTMLConstructionSite藉助一個工廠類對不一樣類型的標籤建立不一樣的html元素,並創建起它們的父子兄弟關係,其中它有一個m_document的成員變量,這個變量就是這棵樹的根結點,也是js裏面的window.document對象。
爲做說明,用一個簡單的html文件一步步看這個DOM樹是如何創建起來的:
1
2
3
4
5
6
7
8
9
10
11
12
|
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
</head>
<body>
<div>
<h1 class="title">demo</h1>
<input value="hello">
</div>
</body>
</html>
|
而後按照上面第2點提到debug的方法,打開Chromium並開始debug:
1
|
chromium ~/demo.html --renderer-startup-dialog
|
咱們先來研究一下Chrome的加載和解析機制
以發http請求去加載html文本作爲咱們分析的第一步,在此以前的一些初始化就不考慮了。Chrome是在DocumentLoader這個類裏面的startLoadingMainResource函數裏去加載url返回的數據,如訪問一個網站則返回html文本:
1
2
3
4
|
FetchRequest fetchRequest(m_request,FetchInitiatorTypeNames::document,
mainResourceLoadOptions);
m_mainResource=
RawResource::fetchMainResource(fetchRequest,fetcher(),m_substituteData);
|
把m_request打印出來,在這個函數裏面加一行代碼:
1
|
LOG(INFO)<<"request url is: "<<m_request.url().getString()
|
並從新編譯Chrome運行,控制檯輸出:
[22731:775:0107/224014.494114:INFO:DocumentLoader.cpp(719)] request url is: 「file:///Users/yincheng/demo.html」
能夠看到,這個url確實是咱們傳進的參數。
發請求後,每次收到的數據塊,會經過Blink封裝的IPC進程間通訊,觸發DocumentLoader的dataReceived函數,裏面會去調它commitData函數,開始處理具體業務邏輯:
1
2
3
4
5
6
7
8
|
void DocumentLoader::commitData(constchar*bytes, size_t length){
ensureWriter(m_response.mimeType());
if(length)
m_dataReceived=true;
m_writer->addData(bytes,length);
}
|
這個函數關鍵行是最2行和第7行,ensureWriter這個函數會去初始化上面畫的UML圖的解析器HTMLDocumentParser (Parser),並實例化document對象,這些實例都經過實例m_writer去帶動的。也就是說,writer會去實例化Parser,而後第7行writer傳遞數據給Parser去解析。
檢查一下收到的數據bytes是什麼東西:
能夠看到bytes就是請求返回的html文本。
在ensureWriter函數裏面有個判斷:
1
2
3
4
5
6
|
voidDocumentLoader::ensureWriter(const AtomicString& mimeType,
constKURL& overridingURL){
if(m_writer)
return;
}
|
若是m_writer已經初始化過了,則直接返回。也就是說Parser和document只會初始化一次。
在上面的addData函數裏面,會啓動一條線程執行Parser的任務:
1
2
|
if(!m_haveBackgroundParser)
startBackgroundParser();
|
並把數據傳遞給這條線程進行解析,Parser一旦收到數據就會序列成tokens,再構建DOM樹。
這裏咱們只要關注序列化後的token是什麼東西就行了,爲此,寫了一個函數,把tokens的一些關鍵信息打印出來:
1
2
3
4
5
|
String getTokenInfo(){
String tokenInfo="";
tokenInfo="tagName: "+this->m_name+"|type: "+getType()+"|attr:"+getAttributes()+"|text: "+this->m_data;
return tokenInfo;
}
|
打印出來的結果:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
tagName: html |type: DOCTYPE |attr: |text: "
tagName: |type: Character |attr: |text: \n"
tagName: html |type: startTag |attr: |text: "
tagName: |type: Character |attr: |text: \n"
tagName: head |type: startTag |attr: |text: "
tagName: |type: Character |attr: |text: \n "
tagName: meta |type: startTag |attr:charset=utf-8 |text: "
tagName: |type: Character |attr: |text: \n"
tagName: head |type: EndTag |attr: |text: "
tagName: |type: Character |attr: |text: \n"
tagName: body |type: startTag |attr: |text: "
tagName: |type: Character |attr: |text: \n "
tagName: div |type: startTag |attr: |text: "
tagName: |type: Character |attr: |text: \n "
tagName: h1 |type: startTag |attr:class=title |text: "
tagName: |type: Character |attr: |text: demo"
tagName: h1 |type: EndTag |attr: |text: "
tagName: |type: Character |attr: |text: \n "
tagName: input |type: startTag |attr:value=hello |text: "
tagName: |type: Character |attr: |text: \n "
tagName: div |type: EndTag |attr: |text: "
tagName: |type: Character |attr: |text: \n"
tagName: body |type: EndTag |attr: |text: "
tagName: |type: Character |attr: |text: \n"
tagName: html |type: EndTag |attr: |text: "
tagName: |type: Character |attr: |text: \n"
tagName: |type: EndOfFile |attr: |text: "
|
這些內容有標籤名、類型、屬性和innerText,標籤之間的文本(換行和空白)也會被看成一個標籤處理。Chrome總共定義了7種標籤類型:
1
2
3
4
5
6
7
8
9
|
enum TokenType{
Uninitialized,
DOCTYPE,
StartTag,
EndTag,
Comment,
Character,
EndOfFile,
};
|
有了一個根結點document和一些格式化好的tokens,就能夠構建dom樹了。
在研究這個過程以前,先來看一下一個DOM結點的數據結構是怎麼樣的。以p標籤HTMLParagraphElement爲例,畫出它的UML圖,以下所示:
Node是最頂層的父類,它有三個指針,兩個指針分別指向它的前一個結點和後一個結點,一個指針指向它的父結點;
ContainerNode繼承於Node,添加了兩個指針,一個指向第一個子元素,另外一個指向最後一個子元素;
Element又添加了獲取dom結點屬性、clientWidth、scrollTop等函數
HTMLElement又繼續添加了Translate等控制,最後一級的子類HTMLParagraphElement只有一個建立的函數,可是它繼承了全部父類的屬性。
須要提到的是每一個Node都組合了一個treeScope,這個treeScope記錄了它屬於哪一個document(一個頁面可能會嵌入iframe)。
構建DOM最關鍵的步驟應該是創建起每一個結點的父子兄弟關係,即上面提到的成員指針的指向。
到這裏咱們能夠先回答上面提出的第一個問題,什麼是瀏覽器內核
瀏覽器內核也叫渲染引擎,上面已經看到了Chrome是如何實例化一個P標籤的,而從firefox的源碼裏面P標籤的依賴關係是這樣的:
在代碼實現上和Chrome沒有任何關係。這就好像W3C出了道題,firefox給了一個解法,取名爲Gecko,Safari也給了本身的答案,取名Webkit,Chrome以爲Safari的解法比較好直接拿過來用,又結合自身的基礎又封裝了一層,取名Blink。因爲W3C出的這道題「開放性」比較大,出的時間比較晚,致使各家實現各有花樣。
明白了這點後,繼續DOM構建。下面開始再也不說Chrome,叫Webkit或者Blink應該更準確一點
Webkit把tokens序列好以後,傳遞給構建的線程。在HTMLDocumentParser::processTokenizedChunkFromBackgroundParser的這個函數裏面會作一個循環,把解析好的tokens作一個遍歷,依次調constructTreeFromCompactHTMLToken
進行處理。
根據上面的輸出,最開始處理的第一個token是docType的那個:
1
|
"tagName: html |type: DOCTYPE |attr: |text: "
|
在那個函數裏面,首先Parser會調TreeBuilder的函數:
1
|
m_treeBuilder->constructTree(&token);
|
而後在TreeBuilder裏面根據token的類型作不一樣的處理:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
void HTMLTreeBuilder::processToken(AtomicHTMLToken*token){
if(token->type()==HTMLToken::Character){
processCharacter(token);
return;
}
switch(token->type()){
case HTMLToken::DOCTYPE:
processDoctypeToken(token);
break;
case HTMLToken::StartTag:
processStartTag(token);
break;
case HTMLToken::EndTag:
processEndTag(token);
break;
//othercode
}
}
|
它會對不一樣類型的結點作相應處理,從上往下依次是文本節點、doctype節點、開標籤、閉標籤。doctype這個結點比較特殊,單獨做爲一種類型處理
在Parser處理doctype的函數裏面調了HTMLConstructionSite的插入doctype的函數:
1
2
3
4
|
void HTMLTreeBuilder::processDoctypeToken(AtomicHTMLToken*token){
m_tree.insertDoctype(token);
setInsertionMode(BeforeHTMLMode);
}
|
在這個函數裏面,它會先建立一個doctype的結點,再建立插dom的task,並設置文檔類型:
1
2
3
4
5
6
7
8
|
void HTMLConstructionSite::insertDoctype(AtomicHTMLToken*token){
//const String& publicId = ...
//const String& systemId = ...
DocumentType*doctype=
DocumentType::create(m_document,token->name(),publicId,systemId);//建立DOCType結點
attachLater(m_attachmentRoot,doctype); //建立插DOM的task
setCompatibilityModeFromDoctype(token->name(),publicId,systemId);//設置文檔類型
}
|
咱們來看一下不一樣的doctype對文檔類型的設置有什麼影響,以下:
1
2
3
4
5
|
// Check for Quirks Mode.
if(name!="html"){
setCompatibilityMode(Document::QuirksMode);
return;
}
|
若是tagName不是html,那麼文檔類型將會是怪異模式,如下兩種就會是怪異模式:
1
2
|
<!DOCType svg>
<!DOCType math>
|
而經常使用的html4寫法:
1
2
|
<!DOCTYPE HTML PUBLIC"-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
|
在源碼裏面這個將是有限怪異模式:
1
2
3
4
5
6
7
|
// Check for Limited Quirks Mode.
if(!systemId.isEmpty()&&
publicId.startsWith("-//W3C//DTD HTML 4.01 Transitional//",
TextCaseASCIIInsensitive))){
setCompatibilityMode(Document::LimitedQuirksMode);
return;
}
|
上面的systemId就是」http://www.w3.org/TR/html4/loose.dtd」,它不是空的,因此判斷成立。而若是systemId爲空,則它將是怪異模式。若是既不是怪異模式,也不是有限怪異模式,那麼它就是標準模式:
1
2
|
// Otherwise we are No Quirks Mode.
setCompatibilityMode(Document::NoQuirksMode);
|
經常使用的html5的寫法就是標準模式,若是連DOCType聲明也沒有呢?那麼會默認設置爲怪異模式:
1
2
3
|
void HTMLConstructionSite::setDefaultCompatibilityMode(){
setCompatibilityMode(Document::QuirksMode);
}
|
這些模式有什麼區別,從源碼註釋可窺探一二:
1
2
3
4
5
6
7
|
// There are three possible compatibility modes:
// Quirks - quirks mode emulates WinIE and NS4. CSS parsing is also relaxed in
// this mode, e.g., unit types can be omitted from numbers.
// Limited Quirks - This mode is identical to no-quirks mode except for its
// treatment of line-height in the inline box model.
// No Quirks - no quirks apply. Web pages will obey the specifications to the
// letter.
|
大意是說,怪異模式會模擬IE,同時CSS解析會比較寬鬆,例如數字單位能夠省略,而有限怪異模式和標準模式的惟一區別在於在於對inline元素的行高處理不同。標準模式將會讓頁面遵照文檔規定。
怪異模式下的input和textarea的默認盒模型將會變成border-box:
標準模式下的文檔高度是實際內容的高度:
而在怪異模式下的文檔高度是窗口可視域的高度:
在有限怪異模式下,div裏面的圖片下方不會留空白,以下圖左所示;而在標準模式下td下方會留點空白,以下圖右所示:
1
|
<div><img src="test.jpg" style="height:100px"></div>
|
這個空白是div的行高撐起來的,當把div的行高設置成0的時候,就沒有下面的空白了。在怪異模和有限怪異模式下,爲了計算行內子元素的最小高度,一個塊級元素的行高必須被忽略。
這裏的敘述雖然跟解讀源碼沒有直接的關係(咱們還沒解讀到CSS處理),可是頗有必要提一下。
接下來咱們開始正式說明DOM構建
下一個遇到的開標籤是<html>標籤,處理這個標籤的任務應該是實例化一個HTMLHtmlElement元素,而後把它的父元素指向document。Webkit源碼裏面使用了一個m_attachmentRoot的變量記錄attach的根結點,初始化HTMLConstructionSite也會初始化這個變量,值爲document:
1
2
3
4
5
|
HTMLConstructionSite::HTMLConstructionSite(
Document&document)
:m_document(&document),
m_attachmentRoot(document)){
}
|
因此html結點的父結點就是document,實際的操做過程是這樣的:
1
2
3
4
5
6
|
void HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML(AtomicHTMLToken* token){
HTMLHtmlElement*element = HTMLHtmlElement::create(*m_document);
attachLater(m_attachmentRoot,element);
m_openElements.pushHTMLHtmlElement(HTMLStackItem::create(element,token));
executeQueuedTasks();
}
|
第二行先建立一個html結點,第三行把它加到一個任務隊列裏面,傳遞兩個參數,第一個參數是父結點,第二個參數是當前結點,第五行執行隊列裏面的任務。代碼第四行會把它壓到一個棧裏面,這個棧存放了未遇到閉標籤的全部開標籤。
第三行attachLater是如何創建一個task的:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
void HTMLConstructionSite::attachLater(ContainerNode* parent,
Node* child,
bool selfClosing){
HTMLConstructionSiteTask task(HTMLConstructionSiteTask::Insert);
task.parent=parent;
task.child=child;
task.selfClosing=selfClosing;
// Add as a sibling of the parent if we have reached the maximum depth
// allowed.
if(m_openElements.stackDepth()>maximumHTMLParserDOMTreeDepth&&
task.parent->parentNode())
task.parent=task.parent->parentNode();
queueTask(task);
}
|
代碼邏輯比較簡單,比較有趣的是發現DOM樹有一個最大的深度:maximumHTMLParserDOMTreeDepth,超過這個最大深度就會把它子元素看成父無素的同級節點,這個最大值是多少呢?512:
1
|
static const unsigned maximumHTMLParserDOMTreeDepth = 512;
|
咱們重點關注executeQueuedTasks幹了些什麼,它會根據task的類型執行不一樣的操做,因爲本次是insert的,它會去執行一個插入的函數:
1
2
3
4
5
6
7
|
void ContainerNode::parserAppendChild(Node* newChild){
if(!checkParserAcceptChild(*newChild))
return;
AdoptAndAppendChild()(*this, *newChild, nullptr);
}
notifyNodeInserted(*newChild, ChildrenChangeSourceParser);
}
|
在插入裏面它會先去檢查父元素是否支持子元素,若是不支持,則直接返回,就像video標籤不支持子元素。而後再去調具體的插入:
1
2
3
4
5
6
7
8
9
10
|
void ContainerNode::appendChildCommon(Node&child){
child.setParentOrShadowHostNode(this);
if(m_lastChild){
child.setPreviousSibling(m_lastChild);
m_lastChild->setNextSibling(&child);
}else{
setFirstChild(&child);
}
setLastChild(&child);
}
|
上面代碼第二行,設置子元素的父結點,也就是會把html結點的父結點指向document,而後若是沒有lastChild,會將這個子元素做爲firstChild,因爲上面已經有一個docype的子結點了,因此已經有lastChild了,所以會把這個子元素的previousSibling指向老的lastChild,老的lastChild的nexSibling指向它。最後倒數第二行再把子元素設置爲當前ContainerNode(即document)的lastChild。這樣就創建起了html結點的父子兄弟關係。
能夠看到,藉助上一次的m_lastChild創建起了兄弟關係。
這個時候你可能會有一個問題,爲何要用一個task隊列存放將要插入的結點呢,而不是直接插入呢?一個緣由放到task裏面方便統一處理,而且有些task可能不能當即執行,要先存起來。不過在咱們這個案例裏面都是存完後下一步就執行了。
當遇到head標籤的token時,也是先建立一個head結點,而後再建立一個task,插到隊列裏面:
1
2
3
4
5
|
void HTMLConstructionSite::insertHTMLHeadElement(AtomicHTMLToken*token){
m_head=HTMLStackItem::create(createHTMLElement(token),token);
attachLater(currentNode(),m_head->element());
m_openElements.pushHTMLHeadElement(m_head);
}
|
attachLater傳參的第一個參數爲父結點,這個currentNode爲開標籤棧裏面的最頂的元素:
1
2
3
|
ContainerNode* currentNode() const{
returnm_openElements.topNode();
}
|
咱們剛剛把html元素壓了進去,則棧頂元素爲html元素,因此head的父結點就爲html。因此每當遇到一個開標籤時,就把它壓起來,下一次再遇到一個開標籤時,它的父元素就是上一個開標籤。
因此,初步能夠看到,藉助一個棧創建起了父子關係。
而當遇到一個閉標籤呢?
當遇到一個閉標籤時,會把棧裏面的元素一直pop出來,直到pop到第一個和它標籤名字同樣的:
1
|
m_tree.openElements()->popUntilPopped(token->name());
|
咱們第一個遇到的是閉標籤是head標籤,它會把開的head標籤pop出來,棧裏面就剩下html元素了,因此當再遇到body時,html元素就是body的父元素了。
這個是棧的一個典型應用。
如下面的html爲例來研究壓棧和出棧的過程:
1
2
3
4
5
6
7
8
9
10
11
12
|
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8"></meta>
</head>
<body>
<div>
<p><b>hello</b></p>
<p>demo</p>
</div>
</body>
</html>
|
把push和pop打印出來是這樣的:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
push "HTML" m_stackDepth=1
push "HEAD" m_stackDepth=2
pop "HEAD" m_stackDepth=1
push "BODY" m_stackDepth=2
push "DIV" m_stackDepth=3
push "P" m_stackDepth=4
push "B" m_stackDepth=5
pop "B" m_stackDepth=4
pop "P" m_stackDepth=3
push "P" m_stackDepth=4
pop "P" m_stackDepth=3
pop "DIV" m_stackDepth=2
"tagName: body |type: EndTag |attr: |text: "
"tagName: html |type: EndTag |attr: |text: "
|
這個過程確實和上面的描述一致,遇到一個閉標籤就把一次的開標籤pop出來。
而且能夠發現遇到body閉標籤後,並不會把body給pop出來,由於若是body閉標籤後面又再寫了標籤的話,就會自動當成body的子元素。
假設上面的b標籤的閉標籤忘記寫了,又會發生什麼:
1
|
<p><b>hello</p>
|
打印出來的結果是這樣的:
1
2
3
4
5
6
7
8
9
10
11
|
push "P" m_stackDepth=4
push "B" m_stackDepth=5
"tagName: p |type: EndTag |attr: |text: "
pop "B" m_stackDepth=4
pop "P" m_stackDepth=3
push "B" m_stackDepth=4
push "P" m_stackDepth=5
pop "P" m_stackDepth=4
pop "B" m_stackDepth=3
pop "DIV" m_stackDepth=2
push "B" m_stackDepth=3
|
一樣地,在上面第3行,遇到P閉標籤時,會把全部的開標籤pop出來,直到遇到P標籤。不一樣的是後續的過程當中會不斷地插入b標籤,最後渲染的頁面結構:
由於b等帶有格式化的標籤會特殊處理,遇到一個開標籤時會它們放到一個列表裏面:
1
2
|
// a, b, big, code, em, font, i, nobr, s, small, strike, strong, tt, and u.
m_activeFormattingElements.append(currentElementRecord()->stackItem());
|
遇到一個閉標籤時,又會從這個列表裏面刪掉。每處理一個新標籤時就會進行檢查和這個列表和棧裏的開標籤是否對應,若是不對應則會reconstruct:從新插入一個開標籤。所以b就不斷地被從新插入,直到遇到下一個b的閉標籤爲止。
若是上面少寫的是一個span,那麼渲染以後的結果是正常的:
而對於文本節點是實例化了Text的對象,這裏再也不展開討論。
在瀏覽器裏面能夠看到,自定義標籤默認不會有任何的樣式,而且它默認是一個行內元素:
初步觀察它和span標籤的表現是同樣的:
在blink的源碼裏面,不認識的標籤默認會被實例化成一個HTMLUnknownElement,這個類對外提供了一個create函數,這和HTMLSpanElement是同樣的,只有一個create函數,而且你們都是繼承於HTMLElement。而且建立span標籤的時候和unknown同樣,並無作特殊處理,直接調的create。因此從本質上來講,能夠把自定義的標籤看成一個span看待。而後你能夠再設置display: block改爲塊級元素之類的。
可是你能夠用js定義一個自定義標籤,定義它的屬性等,Webkit會去讀它的定義:
1
2
3
4
|
// "4. Let definition be the result of looking up a custom element ..." etc.
CustomElementDefinition* definition=
m_isParsingFragment ? nullptr
:lookUpCustomElementDefinition(document,token);
|
例如給自定義標籤建立一個原生屬性:
1
|
<high-school country="China">NO. 2 high school</high-school>
|
上面定義了一個country,爲了能夠直接獲取這個屬性:
1
|
console.log(document.getElementsByTagName("high-school")[0].country);
|
註冊一個自定義標籤:
1
|
window.customElements.define("high-school",HighSchoolElement);
|
這個HighSchoolElement繼承於HTMLElement:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
class HighSchoolElement extends HTMLElement{
constructor(){
super();
this._country=null;
}
get country(){
returnthis._country;
}
set country(country){
this.setAttribute("country", _country);
}
static get observedAttributes(){
return["country"];
}
attributeChangedCallback(name, oldValue, newValue){
this._country=newValue;
this._updateRender(name, oldValue, newValue);
}
_updateRender(name, oldValue, newValue){
console.log(name + " change from " + oldValue + " " + newValue);
}
}
|
就能夠直接取到contry這個屬性,而不用經過getAttribute的函數,而且能夠在屬性發生變化時更新元素的渲染,改變color等。詳見Custom Elements – W3C.
經過這種方式建立的,它就不是一個HTMLUnknownElement了。blink經過V8引擎把js的構造函數轉化成C++的函數,實例化一個HTMLElement的對象。
最後再來看查DOM的過程
在頁面添加一個script:
1
|
<script>document.getElementById("text")</script>
|
Chrome的V8引擎把js代碼層層轉化,最後會調:
1
|
DocumentV8Internal::getElementByIdMethodForMainWorld(info);
|
而這個函數又會調TreeScope的getElementById的函數,TreeScope存儲了一個m_map的哈希map,這個map以標籤id字符串做爲key值,Element爲value值,咱們能夠把這個map打印出來:
1
2
3
4
5
|
Map::iterator it=m_map.begin();
while(it!=m_map.end()){
LOG(INFO) << it->key << " " << it->value->element->tagName();
++it;
}
|
html結構是這樣的:
1
2
3
4
5
|
<div class="user"id="id-yin">
<pid="id-name"class="important">yin</p>
<pid="id-age">20</p>
<pid="id-sex">mail</p>
</div>
|
打印出來的結果爲:
1
2
3
4
|
"id-age" "P"
"id-sex" "P"
"id-name" "P"
"id-yin" "DIV"
|
能夠看到, 這個m_map把頁面全部有id的標籤都存了進來。因爲map的查找時間複雜度爲O(1),因此使用ID選擇器能夠說是最快的。
再來看一下類選擇器:
js以下:
1
2
|
var users = document.getElementsByClassName("user");
users.length;
|
在執行第一行的時候,Webkit返回了一個ClassCollection的列表:
1
|
return new ClassCollection(rootNode,classNames);
|
而這個列表並非去查DOM獲取的,它只是記錄了className做爲標誌。這與咱們的認知是一致的,這種HTMLCollection的數據結構都是在使用的時候纔去查DOM,因此在上面第二行去獲取它的length,就會觸發它的查DOM,在nodeCount這個函數裏面執行:
1
2
3
4
5
6
7
|
NodeType* currentNode = collection.traverseToFirst();
unsigned currentIndex = 0;
while(currentNode){
m_cachedList.push_back(currentNode);
currentNode = collection.traverseForwardToOffset(
currentIndex+1, *currentNode, currentIndex);
}
|
第一行先獲取符合collection條件的第一個結點,而後不斷獲取下一個符合條件的結點,直到null,並把它存到一個cachedList裏面,下次再獲取這個collection的東西時便不用再重複查DOM,只要cached仍然是有效的:
1
2
|
if(this->isCachedNodeCountValid())
return this->cachedNodeCount();
|
怎麼樣找到有效的節點呢:
1
2
3
4
|
ElementType* element = Traversal<ElementType>::firstWithin(current);
while(element && !isMatch(*element))
element = Traversal<ElementType>::next(*element,¤t,isMatch);
return element;
|
第一行先獲取第一個節點,若是它沒有match,則繼續next,直到找到符合條件或者空爲止。咱們的重點在於,它是怎麼遍歷的,如何next獲取下一個節點,核心代碼:
1
2
3
4
5
6
7
|
if(current.hasChildren())
return current.firstChild();
if(current==stayWithin)
return 0;
if(current.nextSibling())
return current.nextSibling();
return nextAncestorSibling(current,stayWithin);
|
第一行先判斷當前節點有沒有子元素,若是有的話返回它的第一個子元素,若是當前節點沒有子元素,而且這個節點就是開始找的根元素(document.getElement,則爲document),則說明沒有下一個元素了,直接返回0/null。若是這個節點不是根元素了(例如已經到了子元素這一層了),那麼看它有沒有相鄰元素,若是有則返回下一下相鄰元素,若是相鄰無素也沒有了,由於它是一個葉子結點(沒有子元素),說明它已經到了最深的一層,而且是當前層的最後一個葉子結點,那就返回它的父元素的下個相鄰節點。能夠看出這是一個深度優先的查找。
1
|
document.querySelector("#id-name");
|
它會調ContainerNode的querySelecotr函數:
1
2
3
4
|
SelectorQuery* selectorQuery = document().selectorQueryCache().add(
selectors,document(),exceptionState);
return selectorQuery->queryFirst(*this);
|
先把輸入的selector字符串序列化成一個selectorQuery,而後再queryFirst,經過打斷點能夠發現,它最後會調的TreeScope的getElementById:
1
|
rootNode.treeScope().getElementById(idToMatch);
|
1
|
document.querySelector(".user");
|
它會從document開始遍歷:
1
2
3
4
5
6
7
|
for(Element& element: ElementTraversal::descendantsOf(rootNode)){
if(element.hasClass() && element.classNames().contains(className)){
SelectorQueryTrait::appendElement(output,element);
if(SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
|
咱們重點查看它是怎麼遍歷,即第一行的for循環。表面上看它好像把全部的元素取出來而後作個循環,其實否則,它是重載++操做符:
1
|
voidoperator++(){ m_current = TraversalNext::next(*m_current, m_root);}
|
只要咱們看下next是怎麼操做的就能夠得知它是怎麼遍歷,而這個next跟上面的講解class時是同樣的。不同的是match條件判斷是:有className,而且className列表裏面包含這個class,如上面代碼第二行。
例如寫兩個class:
1
|
document.querySelector(".user .important");
|
最終也會轉成一個遍歷,只是判斷是否match的條件不同:
1
2
3
4
5
6
7
|
for(Element& element: ElementTraversal::descendantsOf(*traverseRoot)){
if(selectorMatches(selector,element,rootNode)){
SelectorQueryTrait::appendElement(output,element);
if(SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
|
怎麼判斷是否match比較複雜,這裏再也不展開討論。
同時在源碼能夠看到,若是是怪異模式,會調一個executeSlow的查詢,而且判斷match條件也不同。不過遍歷是同樣的。
查看源碼確實是一件很費時費力的工做,可是經過一番探索,可以瞭解瀏覽器的一些內在機制,至少已經能夠回答上面提出來的幾個問題。同時知道了Webkit/Blink藉助一個棧,結合開閉標籤,一步步構建DOM樹,並對DOCType的標籤、自定義標籤的處理有了必定的瞭解。最後又討論了查DOM的幾種狀況,明白了查找的過程。
經過上面的分析,對頁面渲染的第一步構建DOM應該會有一個基礎的瞭解。