写文章不容易，点个赞呗兄弟

专注 Vue 源码分享，文章分为白话版和 源码版，白话版助于理解工作原理，源码版助于了解内部详情，让我们一起学习吧
研究基于 Vue 版本 【2.5.17】

如果你觉得排版难看，请点击 下面链接 或者 拉到 下面 关注公众号 也可以吧

【Vue 原理】Compile – 源码版 之 Parse 主要流程

本文难度较繁琐，需要耐心观看，如果你对 compile 源码暂时不感兴趣可以先移步白话版 Compile – 白话版，

parse 是 渲染三巨头的老大，其作用是把 template 字符串模板，转换成 ast

其涉及源码也是多得一批，达到了 一千多行，想想如果我把全部源码放到文章里面来简直不能看，所以我打算只保留主要部分，就是正常流程可以走通，去掉那些特殊处理的地方

大部分源码都是特殊处理，比如 script，style，input，pre 等标签，这次全部都去掉，只留下通用元素的处理流程，留下一个骨架

因为 parse 的内容非常的多，除了精简源码之外，我还通过不同内容划分文章去记录

今天，要记录的就是 parse 解析 template 成 ast 的大致流程，而怎么解析标签名，怎么解析标签属性会暂时忽略，而独立成文。当有解析标签名和解析属性的地方会直接出结果。比如当我说在 模板 “<div></div>” 匹配出头标签时，直接就得到 div，而不会去考究是如何匹配出来的

好的，到底 template 是怎么变成 ast 的呢？跟着我去探索把~

---

AST

先来说说 ast 吧，这种复杂的概念，反正是需要查的。所以本文根本不需要解释太多

直接说我的理解吧

抽象语法树，以树状形式表现出语法结构

直接使用例子去直观感受就好了

<div>111</div>

用 ast 去描述这个模板就是

{ 
    tag:'div',    

    type :1 , 

    children:[ { 
        type:3, 
        text:'11' 
    } ] 
}

简单得一批把，复杂的这里也不提了，反正跟 parse 没多大关系我觉得

另外记一下，节点的 type 表示的意思

type：1，节点

type：2，表达式，比如 {{isShow}}

type：3，纯文本

现在就开始 parse 的内容了，那么就看 parse 的源码

---

Parse

parse 是渲染三巨头的老大，同时它也是一个函数，源码如下

function parse(template) {var stack = []; // 缓存模板中解析的每个节点的 ast

    var root;   // 根节点，是 ast
    var currentParent; // 当前解析的标签的父节点

    /**
    * parseHTML 处理 template 匹配标签，再传入 start，end，chars 等方法
    **/
    parseHTML(template, {start: (.. 被抽出，在后面)

         end: (.. 被抽出，在后面), // 为 起始标签 开启闭合节点
         chars: (.. 被抽出，在后面) // 文字节点
    });    



    return root

}

parse 接收 template 字符串，使用 parseHTML 这个函数在 template 中匹配标签

并传入 start，end，chars 三个函数 供 parseHTML 处理标签等内容

start，end，chars 方法都已经被我抽出来，放在后面逐个说明

下面来看下其中声明的三个变量

1 stack

是一个数组存放模板中按顺序 从头到尾 每个标签的 ast

注：不会存放单标签的 ast，比如 input，img 这些

比如 stack 是这样的

stack=[{ 
    tag:'div',    

    type :1 , 

    children:[ { 
        type:3, 
        text:'11' 
    } ] 
}]

主要作用是帮助理清节点父子关系

2 root

每个模板都必须有一个根节点。写过 Vue 项目的都知道了，所以一般解析到第一个标签的时候，会直接设置这个标签为 根节点

并且最后返回的也是 root

不可以存在两个根节点（有 v-if 的不讨论）

3 currentParent

在解析标签的时候，必须要知道这个标签的 父节点时谁

这样才知道 这个标签是谁的子节点，才能把这个节点添加给相应的 节点的 children

注：根节点 没有 父节点，所以就是 undefined

parse 源码已经被我精简得很简单了，主要内容其实就在 其中涉及的四个方法中

parseHTML，start，end，chars

parseHTML 是处理 template 的主力，其他三个函数是功能类型的，负责处理相应的内容。例如，start 是处理头标签的，end 是处理尾标签的，chars 是处理文本的

先来看看 parseHTML

---

处理 template

parseHTML 作为处理 template，匹配标签的函数，是十分庞大的，其中兼顾了非常多情况的处理

而本次在不影响流程的情况下，我去掉了下面这些处理，优化阅读

1、没有结束标签的处理

2、文字中包含 < 的处理

3、注释的处理

4、忽略首尾空白字符，默认起始和结尾都是标签

个人认为主要内容为三个

1、循环 template 匹配标签

2、把匹配到的内容，传给相应的方法处理

3、截断 template

来看源码，已经简化得不行了，但是还是要花点心思看看

function parseHTML(html, options) {while (html) {       



         // 寻找 < 的起始位置

        var textEnd = html.indexOf('<'),
            text ,rest ,next;        



        // 模板起始位置是标签开头 <

        if (textEnd === 0) {   

               

            /**
             * 如果是尾标签的 <
             * 比如 html = '</div>'，匹配出 endTagMatch =["</div>", "div"]
             */
            var endTagMatch = html.match(endTag);            



            if (endTagMatch) {// endTagMatch[0]="</a>"

                html = html.substring(endTagMatch[0].length); 

              

                // 处理尾标签，方法后面有记录
                options.end();                



                continue

            }   

                

            /**
             * 如果是起始标签的 <
             * parseStartTag 作用是，匹配标签存在的属性，截断 template
             * html = '<div></div>', 

             * parseStartTag 处理之后，startTagMatch = {tagName: "div", attrs: []}

             */
            var startTagMatch = parseStartTag();   

       

            // 匹配到 起始标签之后
            if (startTagMatch) {  

             

                // 处理起始标签，后面有介绍
                options.start(起始标签的信息);                



                continue

            }
        }        



        // 模板起始位置不是 <，而是文字

        if (textEnd >= 0) {text = html.substring(0, textEnd);
            html = html.substring(n);
        }       



        // 处理文字，后面有介绍
        if (options.chars && text) {options.chars(text);
        }
    }
}

思路如下

1 匹配 < 这个符号

因为他是标签的开头（已经排除了文字中含有 < 的处理，不做讨论）

2 如果 template 开头是 <

那么可能是 尾标签，可能是 头标签，那么就需要判断到底是哪个

1、先匹配尾标签，如果匹配到，那么就是尾标签，使用 end 方法处理。

2、如果不是，使用 parseStartTag 函数匹配得到首标签，并把 首标签信息传给 start 处理

parseStartTag 就是使用正则在 template 中匹配出 首标签信息，其中包括标签名，属性等

比如 template 是

html = '<div name="22">111</div>;'

parseStartTag 处理匹配之后得到

{    

    tagName: "div", 

    attrs: [{name:"22"}]
}

3 如果 template 开头不是 <

那么证明 开头 到 < 的位置这一段，是字符串，那么就是文本了

传给 chars 方法处理

每次处理一次，就会截断到匹配的位置，然后 template 越来越短，直接为空，退出 while，于是处理完毕

对于截断呢，使用 substring，可能忘了怎么作用的，写个小例子

传入数字，表示这个位置前面的字符串都不要

然后，就到了我们其他三个方法的闪亮登场了

---

处理头标签

每当 parseHTML 匹配到一个 首标签，都会把该标签的信息传给 start 方法，让他来处理

function start(tag, attrs, unary) {    



    // 创建 AST 节点

    var element = createASTElement(tag, attrs, currentParent);      



    /**
     * ... 省略了一段处理 vFor，vIf，解析 @ 等属性指令的代码
     **/

    // 设置根节点，一个模板只有一个根节点
    if (!root) root = element;    



    // 处理父子关系

    if (currentParent) {currentParent.children.push(element);
        element.parent = currentParent;
    }    



    // 不是单标签（input，img 那些），就需要保存 stack

    if (!unary) {
        currentParent = element;
        stack.push(element);
    }
}

精简得一目了然（面目全非），看得极度舒适

看看 start 方法都做了哪些恶呢

1、创建 ast

2、解析 attrs，并存放到 ast（已省略属性解析）

3、设置根节点，父节点，把节点添加进父节点的 children

4、ast 保存进 stack

好像不用解释太多，肯定都看得懂啊，除了一个 创建 ast 的函数

这就来源码

function createASTElement(tag, attrs, parent) {    



    return {        

        type: 1,        

        tag: tag,        

        attrsList: attrs,        

        // 把 attrs 数组 转成 对象

        attrsMap: makeAttrsMap(attrs),        

        parent: parent,        

        children: []}
}

创建一个 ast 结构，保存数据

直接返回一个对象，非常明了，包含的各种属性，应该也能看懂

其中有一个 makeAttrsMap 函数，举个栗子

模板上的属性，经过 parseHTML 解析成一个数组，如下

[{name:"hoho" ,value:"333"},{name:"href" ,value:"444"}]

makeAttrMap 转成对象成这样

{hoho:"333",   href:"444"}

然后就保存在 ast 中

---

处理尾标签

每当 parseHTML 匹配到 尾标签，比如 “</div>” 的时候，就会调用传入的 end 方法

来看看吧

function end() {    

    // 标签解析结束，移除该标签

    stack.length -= 1;
    currentParent = stack[stack.length - 1];
}

乍一看，很简单啊！这么少（都是精简 …）

作用有两个

1 从 stack 数组中移除这个节点

stack 保存的是匹配到的头标签，如果标签已经匹配结束了，那么就需要移除

stack 就是为了明确各节点间父子关系而存在的

保证 stack 中最后一个节点，永远是下次匹配的节点的父节点

举个栗子，存在下面模板

stack 匹配两个 头标签之后

stack = ['div' , 'section']

看看 start 可以知道，此时 currentParent = section

然后匹配到 </section>，则移除 stack 中的 section，并且重设 currentParent

stack = ['div']

currentParent = 'div'

再匹配到 p 的时候，p 的父节点就是 div，父子顺序就是正确的了

2 重新设置 stack 最后一个节点为父节点

---

处理文本字符串

当 parseHTML 去匹配 < 的时候，发现 template 不是 <，template 开头 到 < 还有一段距离

那么这段距离的内容就是 文本了，那么就会把这段文本传给 chars 方法处理

来看看源码

function chars(text) {    



    // 必须存在根节点，不可能用文字开头

    if(!currentParent) return



    var children = currentParent.children;    



    // 通过 parseText 解析成字符串，判断是否含有双括号表达式，比如 {{item}}

    // 如果是有表达式，会存放多一些信息，var res = parseText(text)    



    if(res) {

        children.push({            

            type: 2,            

            expression: res.expression,            

            tokens: res.tokens,            

            text: text

        });
    }    



    // 普通字符串，直接存为 字符串子节点

    else if(
      !children.length ||
      children[children.length - 1].text !== ' '
    ) {
        children.push({            

            type: 3,            

            text: text

        });
    }
}

这段代码主要作用就是，为 父节点 添加 文本子节点

而文本子节点分为两种类型

1、普通型，直接存为文本子节点

2、表达式型，需要经过 parseText 处理

直接以结果来定义吧

比如处理这段文本

{{isShow}}

{expression: toString(isShow)

    tokens: [{@binding: "isShow"}]
}

主要是为了把表达式 isShow 拿到，方便后面从实例上获取值

好的，现在，template 处理流程所涉及的主要方法都讲完了

现在用上面这些函数来走一个流程

现在有一个模板

<div>11 </div>

1 开始循环 tempalte

匹配到第一个 头标签（<div>），传入 parse-start，生成 对应的 ast

该 div 的 ast 变成根节点 root，并设置其为当前父节点 currentParent，保存进节点缓存数组 stack

此时

stack = [{ tag:'div' , children:[] } ]

第一轮处理结束，template 截断到第一次匹配到的位置

此时，template = 11 </div>

2 开始第二次遍历

开始匹配 <，发现 < 不在开头，而 开头位置 到 < 有一段普通字符串

调用 parse-char，传入字符串

发现其没有 双括号表达式，直接给父节点添加简单子节点

currentParent.children.push({type:3 , text:'11'})

此时

stack =[{ tag:'div' , children:[ { type:3 , text:'11'} ] } ]

第二轮处理结束，template 截断到刚刚匹配完的字符串

此时，template = </div>

3 开始第三轮遍历

继续寻找 <，发现就在开头，但是这是一个结束标签，标签名是 div

因为 stack 是节点顺序存入的，这个结束标签肯定属于 stack 最后一个 标签

由于 该标签匹配完毕，所以从 stack 中移除

并且设置 当前父节点 currentParent 为 stack 倒数第二个

第三次遍历结束，template 继续截断

此时 template 为空了，结束所有遍历

返回此次 tempalte 解析的 root

{ 
    tag:'div',type :1 , 
    children:[{ type:3 , text:'11'} ] 
}

于是 parse 就成功把 tempalte 解析成了 ast，就是 root

---

总结

本问讲的是 parse 的主要流程，忽略了内部的处理细节，比如怎么解析标签，怎么解析属性，其他内容都会独立成文章

在 parse 的流程中，大致有五个函数，我们屡一下，如下

parse，parseHTML，start，end，chars

parse 是整个 parse 流程的总函数

parseHTML 是 parse 处理的主力函数

start，end，chars 是 在 parse 中传给 parseHTML，用来帮助处理 匹配的标签信息的函数，这三个函数会在 parseHTML 中被调用

---

最后

鉴于本人能力有限，难免会有疏漏错误的地方，请大家多多包涵，如果有任何描述不当的地方，欢迎后台联系本人，有重谢