日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
Vue模板編譯原理

Vue 3 發(fā)布在即，本來想著直接看看 Vue 3 的模板編譯，但是我打開 Vue 3 源碼的時候，發(fā)現(xiàn)我好像連 Vue 2 是怎么編譯模板的都不知道。從小魯迅就告訴我們，不能一口吃成一個胖子，那我只能回頭看看 Vue 2 的模板編譯源碼，至于 Vue 3 就留到正式發(fā)布的時候再看。

創(chuàng)新互聯(lián)公司 - 雅安移動機房，四川服務(wù)器租用，成都服務(wù)器租用，四川網(wǎng)通托管,綿陽服務(wù)器托管，德陽服務(wù)器托管，遂寧服務(wù)器托管，綿陽服務(wù)器托管，四川云主機，成都云主機，西南云主機，雅安移動機房，西南服務(wù)器托管，四川/成都大帶寬，成都機柜租用，四川老牌ＩＤＣ服務(wù)商

Vue 的版本
很多人使用 Vue 的時候，都是直接通過 vue-cli 生成的模板代碼，并不知道 Vue 其實提供了兩個構(gòu)建版本。

 
 
 
 
    
  
  
  
  
  1. vue.js：完整版本，包含了模板編譯的能力；
    2. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. vue.runtime.js：運行時版本，不提供模板編譯能力，需要通過 vue-loader 進行提前編譯。
    2.

Vue不同構(gòu)建版本

完整版與運行時版區(qū)別
簡單來說，就是如果你用了 vue-loader ，就可以使用 vue.runtime.min.js，將模板編譯的過程交過 vue-loader，如果你是在瀏覽器中直接通過 script 標簽引入 Vue，需要使用 vue.min.js，運行的時候編譯模板。

編譯入口

 
 
 
 
    
  
  
  
  
  1. 了解了 Vue 的版本，我們看看 Vue 完整版的入口文件（src/platforms/web/entry-runtime-with-compiler.js）。
    2. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. // 省略了部分代碼，只保留了關(guān)鍵部分
    2. 
  
  
  
  
  2. import { compileToFunctions } from './compiler/index'
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. const mount = Vue.prototype.$mount
    5. 
  
  
  
  
  5. Vue.prototype.$mount = function (el) {
    6. 
  
  
  
  
  6.   const options = this.$options
    7. 
  
  
  
  
  7.   
    8. 
  
  
  
  
  8.   // 如果沒有 render 方法，則進行 template 編譯
    9. 
  
  
  
  
  9.   if (!options.render) {
    10. 
  
  
  
  
  10.     let template = options.template
    11. 
  
  
  
  
  11.     if (template) {
    12. 
  
  
  
  
  12.       // 調(diào)用 compileToFunctions，編譯 template，得到 render 方法
    13. 
  
  
  
  
  13.       const { render, staticRenderFns } = compileToFunctions(template, {
    14. 
  
  
  
  
  14.         shouldDecodeNewlines,
    15. 
  
  
  
  
  15.         shouldDecodeNewlinesForHref,
    16. 
  
  
  
  
  16.         delimiters: options.delimiters,
    17. 
  
  
  
  
  17.         comments: options.comments
    18. 
  
  
  
  
  18.       }, this)
    19. 
  
  
  
  
  19.       // 這里的 render 方法就是生成生成虛擬 DOM 的方法
    20. 
  
  
  
  
  20.       options.render = render
    21. 
  
  
  
  
  21.     }
    22. 
  
  
  
  
  22.   }
    23. 
  
  
  
  
  23.   return mount.call(this, el, hydrating)
    24. 
  
  
  
  
  24. }
    25. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. 再看看 ./compiler/index 文件的 compileToFunctions 方法從何而來。
    2. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. import { baseOptions } from './options'
    2. 
  
  
  
  
  2. import { createCompiler } from 'compiler/index'
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. // 通過 createCompiler 方法生成編譯函數(shù)
    5. 
  
  
  
  
  5. const { compile, compileToFunctions } = createCompiler(baseOptions)
    6. 
  
  
  
  
  6. export { compile, compileToFunctions }
    7.

后續(xù)的主要邏輯都在 compiler 模塊中，這一塊有些繞，因為本文不是做源碼分析，就不貼整段源碼了。簡單看看這一段的邏輯是怎么樣的。

 
 
 
 
    
  
  
  
  
  1. export function createCompiler(baseOptions) {
    2. 
  
  
  
  
  2.   const baseCompile = (template, options) => {
    3. 
  
  
  
  
  3.     // 解析 html，轉(zhuǎn)化為 ast
    4. 
  
  
  
  
  4.     const ast = parse(template.trim(), options)
    5. 
  
  
  
  
  5.     // 優(yōu)化 ast，標記靜態(tài)節(jié)點
    6. 
  
  
  
  
  6.     optimize(ast, options)
    7. 
  
  
  
  
  7.     // 將 ast 轉(zhuǎn)化為可執(zhí)行代碼
    8. 
  
  
  
  
  8.     const code = generate(ast, options)
    9. 
  
  
  
  
  9.     return {
    10. 
  
  
  
  
  10.       ast,
    11. 
  
  
  
  
  11.       render: code.render,
    12. 
  
  
  
  
  12.       staticRenderFns: code.staticRenderFns
    13. 
  
  
  
  
  13.     }
    14. 
  
  
  
  
  14.   }
    15. 
  
  
  
  
  15.   const compile = (template, options) => {
    16. 
  
  
  
  
  16.     const tips = []
    17. 
  
  
  
  
  17.     const errors = []
    18. 
  
  
  
  
  18.     // 收集編譯過程中的錯誤信息
    19. 
  
  
  
  
  19.     options.warn = (msg, tip) => {
    20. 
  
  
  
  
  20.       (tip ? tips : errors).push(msg)
    21. 
  
  
  
  
  21.     }
    22. 
  
  
  
  
  22.     // 編譯
    23. 
  
  
  
  
  23.     const compiled = baseCompile(template, options)
    24. 
  
  
  
  
  24.     compiled.errors = errors
    25. 
  
  
  
  
  25.     compiled.tips = tips
    26. 
  
  
  
  
  26. 
  
  
  
  
  27.     return compiled
    28. 
  
  
  
  
  28.   }
    29. 
  
  
  
  
  29.   const createCompileToFunctionFn = () => {
    30. 
  
  
  
  
  30.     // 編譯緩存
    31. 
  
  
  
  
  31.     const cache = Object.create(null)
    32. 
  
  
  
  
  32.     return (template, options, vm) => {
    33. 
  
  
  
  
  33.       // 已編譯模板直接走緩存
    34. 
  
  
  
  
  34.       if (cache[template]) {
    35. 
  
  
  
  
  35.         return cache[template]
    36. 
  
  
  
  
  36.       }
    37. 
  
  
  
  
  37.       const compiled = compile(template, options)
    38. 
  
  
  
  
  38.      return (cache[key] = compiled)
    39. 
  
  
  
  
  39.     }
    40. 
  
  
  
  
  40.   }
    41. 
  
  
  
  
  41.   return {
    42. 
  
  
  
  
  42.     compile,
    43. 
  
  
  
  
  43.     compileToFunctions: createCompileToFunctionFn(compile)
    44. 
  
  
  
  
  44.   }
    45. 
  
  
  
  
  45. }
    46.

主流程
可以看到主要的編譯邏輯基本都在 baseCompile 方法內(nèi)，主要分為三個步驟：

模板編譯，將模板代碼轉(zhuǎn)化為 AST；
優(yōu)化 AST，方便后續(xù)虛擬 DOM 更新；
生成代碼，將 AST 轉(zhuǎn)化為可執(zhí)行的代碼；

 
 
 
 
    
  
  
  
  
  1. const baseCompile = (template, options) => {
    2. 
  
  
  
  
  2.   // 解析 html，轉(zhuǎn)化為 ast
    3. 
  
  
  
  
  3.   const ast = parse(template.trim(), options)
    4. 
  
  
  
  
  4.   // 優(yōu)化 ast，標記靜態(tài)節(jié)點
    5. 
  
  
  
  
  5.   optimize(ast, options)
    6. 
  
  
  
  
  6.   // 將 ast 轉(zhuǎn)化為可執(zhí)行代碼
    7. 
  
  
  
  
  7.   const code = generate(ast, options)
    8. 
  
  
  
  
  8.   return {
    9. 
  
  
  
  
  9.     ast,
    10. 
  
  
  
  
  10.     render: code.render,
    11. 
  
  
  
  
  11.     staticRenderFns: code.staticRenderFns
    12. 
  
  
  
  
  12.   }
    13. 
  
  
  
  
  13. }
    14.

parse
AST
首先看到 parse 方法，該方法的主要作用就是解析 HTML，并轉(zhuǎn)化為 AST（抽象語法樹），接觸過 ESLint、Babel 的同學肯定對 AST 不陌生，我們可以先看看經(jīng)過 parse 之后的 AST 長什么樣。

下面是一段普普通通的 Vue 模板：

 
 
 
 
    
  
  
  
  
  1. new Vue({
    2. 
  
  
  
  
  2.   el: '#app',
    3. 
  
  
  
  
  3.   template: `
    4. 
  
  
  
  
  4.     
    5. 
  
  
  
  
  5.       {{message}}
    6. 
  
  
  
  
  6.       showName
    7. 
  
  
  
  
  7.     
  •   `,
  •   data: {
  •     name: 'shenfq',
  •     message: 'Hello Vue!'
  •   },
  •   methods: {
  •     showName() {
  •       alert(this.name)
  •     }
  •   }
  • })

    • 經(jīng)過 parse 之后的 AST：

    Template AST
    AST 為一個樹形結(jié)構(gòu)的對象，每一層表示一個節(jié)點，第一層就是 div（tag: "div"）。div 的子節(jié)點都在 children 屬性中，分別是 h2 標簽、空行、button 標簽。我們還可以注意到有一個用來標記節(jié)點類型的屬性：type，這里 div 的 type 為 1，表示是一個元素節(jié)點，type 一共有三種類型：

    元素節(jié)點；
    表達式；
    文本；
    在 h2 和 button 標簽之間的空行就是 type 為 3 的文本節(jié)點，而 h2 標簽下就是一個表達式節(jié)點。

    解析HTML
    parse 的整體邏輯較為復雜，我們可以先簡化一下代碼，看看 parse 的流程。

     
 
 
 
      
  
  
  
  
    1. import { parseHTML } from './html-parser'
      2. 
  
  
  
  
    2. 
  
  
  
  
    3. export function parse(template, options) {
      4. 
  
  
  
  
    4.   let root
      5. 
  
  
  
  
    5.   parseHTML(template, {
      6. 
  
  
  
  
    6.     // some options...
      7. 
  
  
  
  
    7.     start() {}, // 解析到標簽位置開始的回調(diào)
      8. 
  
  
  
  
    8.     end() {}, // 解析到標簽位置結(jié)束的回調(diào)
      9. 
  
  
  
  
    9.     chars() {}, // 解析到文本時的回調(diào)
      10. 
  
  
  
  
    10.     comment() {} // 解析到注釋時的回調(diào)
      11. 
  
  
  
  
    11.   })
      12. 
  
  
  
  
    12.   return root
      13. 
  
  
  
  
    13. }
      14.

    可以看到 parse 主要通過 parseHTML 進行工作，這個 parseHTML 本身來自于開源庫：simple html parser，只不過經(jīng)過了 Vue 團隊的一些修改，修復了相關(guān) issue。

    HTML parser
    下面我們一起來理一理 parseHTML 的邏輯。

     
 
 
 
      
  
  
  
  
    1. export function parseHTML(html, options) {
      2. 
  
  
  
  
    2.   let index = 0
      3. 
  
  
  
  
    3.   let last,lastTag
      4. 
  
  
  
  
    4.   const stack = []
      5. 
  
  
  
  
    5.   while(html) {
      6. 
  
  
  
  
    6.     last = html
      7. 
  
  
  
  
    7.     let textEnd = html.indexOf('<')
      8. 
  
  
  
  
    8. 
  
  
  
  
    9.     // "<" 字符在當前 html 字符串開始位置
      10. 
  
  
  
  
    10.     if (textEnd === 0) {
      11. 
  
  
  
  
    11.       // 1、匹配到注釋: 
      12. 
  
  
  
  
    12.       if (/^
  
  
  
  
    13.         const commentEnd = html.indexOf('-->')
      14. 
  
  
  
  
    14.         if (commentEnd >= 0) {
      15. 
  
  
  
  
    15.           // 調(diào)用 options.comment 回調(diào)，傳入注釋內(nèi)容
      16. 
  
  
  
  
    16.           options.comment(html.substring(4, commentEnd))
      17. 
  
  
  
  
    17.           // 裁切掉注釋部分
      18. 
  
  
  
  
    18.           advance(commentEnd + 3)
      19. 
  
  
  
  
    19.           continue
      20. 
  
  
  
  
    20.         }
      21. 
  
  
  
  
    21.       }
      22. 
  
  
  
  
    22. 
  
  
  
  
    23.       // 2、匹配到條件注釋:   
      24. 
  
  
  
  
    24.       if (/^
  
  
  
  
    25.         // ... 邏輯與匹配到注釋類似
      26. 
  
  
  
  
    26.       }
      27. 
  
  
  
  
    27. 
  
  
  
  
    28.       // 3、匹配到 Doctype: 
      29. 
  
  
  
  
    29.       const doctypeMatch = html.match(/^]+>/i)
      30. 
  
  
  
  
    30.       if (doctypeMatch) {
      31. 
  
  
  
  
    31.         // ... 邏輯與匹配到注釋類似
      32. 
  
  
  
  
    32.       }
      33. 
  
  
  
  
    33. 
  
  
  
  
    34.       // 4、匹配到結(jié)束標簽: 
  •       const endTagMatch = html.match(endTag)
  •       if (endTagMatch) {}
  •       // 5、匹配到開始標簽: 
  •       const startTagMatch = parseStartTag()
  •       if (startTagMatch) {}
  •     }
  •     // "<" 字符在當前 html 字符串中間位置
  •     let text, rest, next
  •     if (textEnd > 0) {
  •       // 提取中間字符
  •       rest = html.slice(textEnd)
  •       // 這一部分當成文本處理
  •       text = html.substring(0, textEnd)
  •       advance(textEnd)
  •     }
  •     // "<" 字符在當前 html 字符串中不存在
  •     if (textEnd < 0) {
  •       text = html
  •       html = ''
  •     }
  •     
  •     // 如果存在 text 文本
  •     // 調(diào)用 options.chars 回調(diào)，傳入 text 文本
  •     if (options.chars && text) {
  •       // 字符相關(guān)回調(diào)
  •       options.chars(text)
  •     }
  •   }
  •   // 向前推進，裁切 html
  •   function advance(n) {
  •     index += n
  •     html = html.substring(n)
  •   }
  • }

    • 上述代碼為簡化后的 parseHTML，while 循環(huán)中每次截取一段 html 文本，然后通過正則判斷文本的類型進行處理，這就類似于編譯原理中常用的有限狀態(tài)機。每次拿到 "<" 字符前后的文本，"<" 字符前的就當做文本處理，"<" 字符后的通過正則判斷，可推算出有限的幾種狀態(tài)。

    其他的邏輯處理都不復雜，主要是開始標簽與結(jié)束標簽，我們先看看關(guān)于開始標簽與結(jié)束標簽相關(guān)的正則。

     
 
 
 
      
  
  
  
  
    1. const ncname = '[a-zA-Z_][\\w\\-\\.]*'
      2. 
  
  
  
  
    2. const qnameCapture = `((?:${ncname}\\:)?${ncname})`
      3. 
  
  
  
  
    3. const startTagOpen = new RegExp(`^<${qnameCapture}`)
      4.

    這段正則看起來很長，但是理清之后也不是很難。這里推薦一個正則可視化工具。我們到工具上看看startTagOpen：

    startTagOpen
    這里比較疑惑的點就是為什么 tagName 會存在 :，這個是 XML 的 命名空間，現(xiàn)在已經(jīng)很少使用了，我們可以直接忽略，所以我們簡化一下這個正則：

     
 
 
 
      
  
  
  
  
    1. const ncname = '[a-zA-Z_][\\w\\-\\.]*'
      2. 
  
  
  
  
    2. const startTagOpen = new RegExp(`^<${ncname}`)
      3. 
  
  
  
  
    3. const startTagClose = /^\s*(\/?)>/
      4. 
  
  
  
  
    4. const endTag = new RegExp(`^<\\/${ncname}[^>]*>`)
      5.

    startTagOpen

    endTag
    除了上面關(guān)于標簽開始和結(jié)束的正則，還有一段用來提取標簽屬性的正則，真的是又臭又長。

     
 
 
 
      
  
  
  
  
    1. const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
      2.

    把正則放到工具上就一目了然了，以 = 為分界，前面為屬性的名字，后面為屬性的值。

    attribute
    理清正則后可以更加方便我們看后面的代碼。

     
 
 
 
      
  
  
  
  
    1. while(html) {
      2. 
  
  
  
  
    2.   last = html
      3. 
  
  
  
  
    3.   let textEnd = html.indexOf('<')
      4. 
  
  
  
  
    4. 
  
  
  
  
    5.   // "<" 字符在當前 html 字符串開始位置
      6. 
  
  
  
  
    6.   if (textEnd === 0) {
      7. 
  
  
  
  
    7.     // some code ...
      8. 
  
  
  
  
    8. 
  
  
  
  
    9.     // 4、匹配到標簽結(jié)束位置: 
  •     const endTagMatch = html.match(endTag)
  •     if (endTagMatch) {
  •       const curIndex = index
  •       advance(endTagMatch[0].length)
  •       parseEndTag(endTagMatch[1], curIndex, index)
  •       continue
  •     }
  •     // 5、匹配到標簽開始位置: 
  •     const startTagMatch = parseStartTag()
  •     if (startTagMatch) {
  •       handleStartTag(startTagMatch)
  •       continue
  •     }
  •   }
  • }
  • // 向前推進，裁切 html
  • function advance(n) {
  •   index += n
  •   html = html.substring(n)
  • }
  • // 判斷是否標簽開始位置，如果是，則提取標簽名以及相關(guān)屬性
  • function parseStartTag () {
  •   // 提取 
  •   const start = html.match(startTagOpen)
  •   if (start) {
  •     const [fullStr, tag] = start
  •     const match = {
  •       attrs: [],
  •       start: index,
  •       tagName: tag,
  •     }
  •     advance(fullStr.length)
  •     let end, attr
  •     // 遞歸提取屬性，直到出現(xiàn) ">" 或 "/>" 字符
  •     while (
  •       !(end = html.match(startTagClose)) &&
  •       (attr = html.match(attribute))
  •     ) {
  •       advance(attr[0].length)
  •       match.attrs.push(attr)
  •     }
  •     if (end) {
  •       // 如果是 "/>" 表示單標簽
  •       match.unarySlash = end[1]
  •       advance(end[0].length)
  •       match.end = index
  •       return match
  •     }
  •   }
  • }
  • // 處理開始標簽
  • function handleStartTag (match) {
  •   const tagName = match.tagName
  •   const unary = match.unarySlash
  •   const len = match.attrs.length
  •   const attrs = new Array(len)
  •   for (let i = 0; i < l; i++) {
  •     const args = match.attrs[i]
  •     // 這里的 3、4、5 分別對應(yīng)三種不同復制屬性的方式
  •     // 3: attr="xxx" 雙引號
  •     // 4: attr='xxx' 單引號
  •     // 5: attr=xxx   省略引號
  •     const value = args[3] || args[4] || args[5] || ''
  •     attrs[i] = {
  •       name: args[1],
  •       value
  •     }
  •   }
  •   if (!unary) {
  •     // 非單標簽，入棧
  •     stack.push({
  •       tag: tagName,
  •       lowerCasedTag:
  •       tagName.toLowerCase(),
  •       attrs: attrs
  •     })
  •     lastTag = tagName
  •   }
  •   if (options.start) {
  •     // 開始標簽的回調(diào)
  •     options.start(tagName, attrs, unary, match.start, match.end)
  •   }
  • }
  • // 處理閉合標簽
  • function parseEndTag (tagName, start, end) {
  •   let pos, lowerCasedTagName
  •   if (start == null) start = index
  •   if (end == null) end = index
  •   if (tagName) {
  •     lowerCasedTagName = tagName.toLowerCase()
  •   }
  •   // 在棧內(nèi)查找相同類型的未閉合標簽
  •   if (tagName) {
  •     for (pos = stack.length - 1; pos >= 0; pos--) {
  •       if (stack[pos].lowerCasedTag === lowerCasedTagName) {
  •         break
  •       }
  •     }
  •   } else {
  •     pos = 0
  •   }
  •   if (pos >= 0) {
  •     // 關(guān)閉該標簽內(nèi)的未閉合標簽，更新堆棧
  •     for (let i = stack.length - 1; i >= pos; i--) {
  •       if (options.end) {
  •         // end 回調(diào)
  •         options.end(stack[i].tag, start, end)
  •       }
  •     }
  •     // 堆棧中刪除已關(guān)閉標簽
  •     stack.length = pos
  •     lastTag = pos && stack[pos - 1].tag
  •   }
  • }

    • 在解析開始標簽的時候，如果該標簽不是單標簽，會將該標簽放入到一個堆棧當中，每次閉合標簽的時候，會從棧頂向下查找同名標簽，直到找到同名標簽，這個操作會閉合同名標簽上面的所有標簽。接下來我們舉個例子：

     
 
 
 
      
  
  
  
  
      2. 
  
  
  
  
    2.   
      test
      3. 
  
  
  
  
    3.   
      4. 
  
  
  
  
    4.   
      5.

    在解析了 div 和 h2 的開始標簽后，棧內(nèi)就存在了兩個元素。h2 閉合后，就會將 h2 出棧。然后會解析兩個未閉合的 p 標簽，此時，棧內(nèi)存在三個元素（div、p、p）。如果這個時候，解析了 div 的閉合標簽，除了將 div 閉合外，div 內(nèi)兩個未閉合的 p 標簽也會跟隨閉合，此時棧被清空。

    為了便于理解，特地錄制了一個動圖，如下：

    入棧與出棧
    理清了 parseHTML 的邏輯后，我們回到調(diào)用 parseHTML 的位置，調(diào)用該方法的時候，一共會傳入四個回調(diào)，分別對應(yīng)標簽的開始和結(jié)束、文本、注釋。

     
 
 
 
      
  
  
  
  
    1. parseHTML(template, {
      2. 
  
  
  
  
    2.   // some options...
      3. 
  
  
  
  
    3. 
  
  
  
  
    4.   // 解析到標簽位置開始的回調(diào)
      5. 
  
  
  
  
    5.   start(tag, attrs, unary) {},
      6. 
  
  
  
  
    6.   // 解析到標簽位置結(jié)束的回調(diào)
      7. 
  
  
  
  
    7.   end(tag) {},
      8. 
  
  
  
  
    8.   // 解析到文本時的回調(diào)
      9. 
  
  
  
  
    9.   chars(text: string) {},
      10. 
  
  
  
  
    10.   // 解析到注釋時的回調(diào)
      11. 
  
  
  
  
    11.   comment(text: string) {}
      12. 
  
  
  
  
    12. })
      13.

    處理開始標簽
    首先看解析到開始標簽時，會生成一個 AST 節(jié)點，然后處理標簽上的屬性，最后將 AST 節(jié)點放入樹形結(jié)構(gòu)中。

     
 
 
 
      
  
  
  
  
    1. function makeAttrsMap(attrs) {
      2. 
  
  
  
  
    2.   const map = {}
      3. 
  
  
  
  
    3.   for (let i = 0, l = attrs.length; i < l; i++) {
      4. 
  
  
  
  
    4.     const { name, value } = attrs[i]
      5. 
  
  
  
  
    5.     map[name] = value
      6. 
  
  
  
  
    6.   }
      7. 
  
  
  
  
    7.   return map
      8. 
  
  
  
  
    8. }
      9. 
  
  
  
  
    9. function createASTElement(tag, attrs, parent) {
      10. 
  
  
  
  
    10.   const attrsList = attrs
      11. 
  
  
  
  
    11.   const attrsMap = makeAttrsMap(attrsList)
      12. 
  
  
  
  
    12.   return {
      13. 
  
  
  
  
    13.     type: 1,       // 節(jié)點類型
      14. 
  
  
  
  
    14.     tag,           // 節(jié)點名稱
      15. 
  
  
  
  
    15.     attrsMap,      // 節(jié)點屬性映射
      16. 
  
  
  
  
    16.     attrsList,     // 節(jié)點屬性數(shù)組
      17. 
  
  
  
  
    17.     parent,        // 父節(jié)點
      18. 
  
  
  
  
    18.     children: [],  // 子節(jié)點
      19. 
  
  
  
  
    19.   }
      20. 
  
  
  
  
    20. }
      21. 
  
  
  
  
    21. 
  
  
  
  
    22. const stack = []
      23. 
  
  
  
  
    23. let root // 根節(jié)點
      24. 
  
  
  
  
    24. let currentParent // 暫存當前的父節(jié)點
      25. 
  
  
  
  
    25. parseHTML(template, {
      26. 
  
  
  
  
    26.   // some options...
      27. 
  
  
  
  
    27. 
  
  
  
  
    28.   // 解析到標簽位置開始的回調(diào)
      29. 
  
  
  
  
    29.   start(tag, attrs, unary) {
      30. 
  
  
  
  
    30.     // 創(chuàng)建 AST 節(jié)點
      31. 
  
  
  
  
    31.     let element = createASTElement(tag, attrs, currentParent)
      32. 
  
  
  
  
    32. 
  
  
  
  
    33.     // 處理指令: v-for v-if v-once
      34. 
  
  
  
  
    34.     processFor(element)
      35. 
  
  
  
  
    35.     processIf(element)
      36. 
  
  
  
  
    36.     processOnce(element)
      37. 
  
  
  
  
    37.     processElement(element, options)
      38. 
  
  
  
  
    38. 
  
  
  
  
    39.     // 處理 AST 樹
      40. 
  
  
  
  
    40.     // 根節(jié)點不存在，則設(shè)置該元素為根節(jié)點
      41. 
  
  
  
  
    41.     if (!root) {
      42. 
  
  
  
  
    42.       root = element
      43. 
  
  
  
  
    43.       checkRootConstraints(root)
      44. 
  
  
  
  
    44.     }
      45. 
  
  
  
  
    45.     // 存在父節(jié)點
      46. 
  
  
  
  
    46.     if (currentParent) {
      47. 
  
  
  
  
    47.       // 將該元素推入父節(jié)點的子節(jié)點中
      48. 
  
  
  
  
    48.       currentParent.children.push(element)
      49. 
  
  
  
  
    49.       element.parent = currentParent
      50. 
  
  
  
  
    50.     }
      51. 
  
  
  
  
    51.     if (!unary) {
      52. 
  
  
  
  
    52.      // 非單標簽需要入棧，且切換當前父元素的位置
      53. 
  
  
  
  
    53.       currentParent = element
      54. 
  
  
  
  
    54.       stack.push(element)
      55. 
  
  
  
  
    55.     }
      56. 
  
  
  
  
    56.   }
      57. 
  
  
  
  
    57. })
      58.

    處理結(jié)束標簽
    標簽結(jié)束的邏輯就比較簡單了，只需要去除棧內(nèi)最后一個未閉合標簽，進行閉合即可。

     
 
 
 
      
  
  
  
  
    1. parseHTML(template, {
      2. 
  
  
  
  
    2.   // some options...
      3. 
  
  
  
  
    3. 
  
  
  
  
    4.   // 解析到標簽位置結(jié)束的回調(diào)
      5. 
  
  
  
  
    5.   end() {
      6. 
  
  
  
  
    6.     const element = stack[stack.length - 1]
      7. 
  
  
  
  
    7.     const lastNode = element.children[element.children.length - 1]
      8. 
  
  
  
  
    8.     // 處理尾部空格的情況
      9. 
  
  
  
  
    9.     if (lastNode && lastNode.type === 3 && lastNode.text === ' ') {
      10. 
  
  
  
  
    10.       element.children.pop()
      11. 
  
  
  
  
    11.     }
      12. 
  
  
  
  
    12.     // 出棧，重置當前的父節(jié)點
      13. 
  
  
  
  
    13.     stack.length -= 1
      14. 
  
  
  
  
    14.     currentParent = stack[stack.length - 1]
      15. 
  
  
  
  
    15.   }
      16. 
  
  
  
  
    16. })
      17.

    處理文本
    處理完標簽后，還需要對標簽內(nèi)的文本進行處理。文本的處理分兩種情況，一種是帶表達式的文本，還一種就是純靜態(tài)的文本。

     
 
 
 
      
  
  
  
  
    1. parseHTML(template, {
      2. 
  
  
  
  
    2.   // some options...
      3. 
  
  
  
  
    3. 
  
  
  
  
    4.   // 解析到文本時的回調(diào)
      5. 
  
  
  
  
    5.   chars(text) {
      6. 
  
  
  
  
    6.     if (!currentParent) {
      7. 
  
  
  
  
    7.       // 文本節(jié)點外如果沒有父節(jié)點則不處理
      8. 
  
  
  
  
    8.       return
      9. 
  
  
  
  
    9.     }
      10. 
  
  
  
  
    10.     
      11. 
  
  
  
  
    11.     const children = currentParent.children
      12. 
  
  
  
  
    12.     text = text.trim()
      13. 
  
  
  
  
    13.     if (text) {
      14. 
  
  
  
  
    14.       // parseText 用來解析表達式
      15. 
  
  
  
  
    15.       // delimiters 表示表達式標識符，默認為 ['{{', '}}']
      16. 
  
  
  
  
    16.       const res = parseText(text, delimiters))
      17. 
  
  
  
  
    17.       if (res) {
      18. 
  
  
  
  
    18.         // 表達式
      19. 
  
  
  
  
    19.         children.push({
      20. 
  
  
  
  
    20.           type: 2,
      21. 
  
  
  
  
    21.           expression: res.expression,
      22. 
  
  
  
  
    22.           tokens: res.tokens,
      23. 
  
  
  
  
    23.           text
      24. 
  
  
  
  
    24.         })
      25. 
  
  
  
  
    25.       } else {
      26. 
  
  
  
  
    26.         // 靜態(tài)文本
      27. 
  
  
  
  
    27.         children.push({
      28. 
  
  
  
  
    28.           type: 3,
      29. 
  
  
  
  
    29.           text
      30. 
  
  
  
  
    30.         })
      31. 
  
  
  
  
    31.       }
      32. 
  
  
  
  
    32.     }
      33. 
  
  
  
  
    33.   }
      34. 
  
  
  
  
    34. })
      35.

    下面我們看看 parseText 如何解析表達式。

     
 
 
 
      
  
  
  
  
    1. // 構(gòu)造匹配表達式的正則
      2. 
  
  
  
  
    2. const buildRegex = delimiters => {
      3. 
  
  
  
  
    3.   const open = delimiters[0]
      4. 
  
  
  
  
    4.   const close = delimiters[1]
      5. 
  
  
  
  
    5.   return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
      6. 
  
  
  
  
    6. }
      7. 
  
  
  
  
    7. 
  
  
  
  
    8. function parseText (text, delimiters){
      9. 
  
  
  
  
    9.   // delimiters 默認為 {{ }}
      10. 
  
  
  
  
    10.   const tagRE = buildRegex(delimiters || ['{{', '}}'])
      11. 
  
  
  
  
    11.   // 未匹配到表達式，直接返回
      12. 
  
  
  
  
    12.   if (!tagRE.test(text)) {
      13. 
  
  
  
  
    13.     return
      14. 
  
  
  
  
    14.   }
      15. 
  
  
  
  
    15.   const tokens = []
      16. 
  
  
  
  
    16.   const rawTokens = []
      17. 
  
  
  
  
    17.   let lastIndex = tagRE.lastIndex = 0
      18. 
  
  
  
  
    18.   let match, index, tokenValue
      19. 
  
  
  
  
    19.   while ((match = tagRE.exec(text))) {
      20. 
  
  
  
  
    20.     // 表達式開始的位置
      21. 
  
  
  
  
    21.     index = match.index
      22. 
  
  
  
  
    22.     // 提取表達式開始位置前面的靜態(tài)字符，放入 token 中
      23. 
  
  
  
  
    23.     if (index > lastIndex) {
      24. 
  
  
  
  
    24.       rawTokens.push(tokenValue = text.slice(lastIndex, index))
      25. 
  
  
  
  
    25.       tokens.push(JSON.stringify(tokenValue))
      26. 
  
  
  
  
    26.     }
      27. 
  
  
  
  
    27.     // 提取表達式內(nèi)部的內(nèi)容，使用 _s() 方法包裹
      28. 
  
  
  
  
    28.     const exp = match[1].trim()
      29. 
  
  
  
  
    29.     tokens.push(`_s(${exp})`)
      30. 
  
  
  
  
    30.     rawTokens.push({ '@binding': exp })
      31. 
  
  
  
  
    31.     lastIndex = index + match[0].length
      32. 
  
  
  
  
    32.   }
      33. 
  
  
  
  
    33.   // 表達式后面還有其他靜態(tài)字符，放入 token 中
      34. 
  
  
  
  
    34.   if (lastIndex < text.length) {
      35. 
  
  
  
  
    35.     rawTokens.push(tokenValue = text.slice(lastIndex))
      36. 
  
  
  
  
    36.     tokens.push(JSON.stringify(tokenValue))
      37. 
  
  
  
  
    37.   }
      38. 
  
  
  
  
    38.   return {
      39. 
  
  
  
  
    39.     expression: tokens.join('+'),
      40. 
  
  
  
  
    40.     tokens: rawTokens
      41. 
  
  
  
  
    41.   }
      42. 
  
  
  
  
    42. }
      43.

    首先通過一段正則來提取表達式：

    提取表達式
    看代碼可能有點難，我們直接看例子，這里有一個包含表達式的文本。

     
 
 
 
      
  
  
  
  
    1. 是否登錄：{{isLogin ? '是' : '否'}}
      2.

    運行結(jié)果

    解析文本
    optimize
    通過上述一些列處理，我們就得到了 Vue 模板的 AST。由于 Vue 是響應(yīng)式設(shè)計，所以拿到 AST 之后還需要進行一系列優(yōu)化，確保靜態(tài)的數(shù)據(jù)不會進入虛擬 DOM 的更新階段，以此來優(yōu)化性能。

     
 
 
 
      
  
  
  
  
    1. export function optimize (root, options) {
      2. 
  
  
  
  
    2.   if (!root) return
      3. 
  
  
  
  
    3.   // 標記靜態(tài)節(jié)點
      4. 
  
  
  
  
    4.   markStatic(root)
      5. 
  
  
  
  
    5. }
      6.

    簡單來說，就是把所以靜態(tài)節(jié)點的 static 屬性設(shè)置為 true。

     
 
 
 
      
  
  
  
  
    1. function isStatic (node) {
      2. 
  
  
  
  
    2.   if (node.type === 2) { // 表達式，返回 false
      3. 
  
  
  
  
    3.     return false
      4. 
  
  
  
  
    4.   }
      5. 
  
  
  
  
    5.   if (node.type === 3) { // 靜態(tài)文本，返回 true
      6. 
  
  
  
  
    6.     return true
      7. 
  
  
  
  
    7.   }
      8. 
  
  
  
  
    8.   // 此處省略了部分條件
      9. 
  
  
  
  
    9.   return !!(
      10. 
  
  
  
  
    10.     !node.hasBindings && // 沒有動態(tài)綁定
      11. 
  
  
  
  
    11.     !node.if && !node.for && // 沒有 v-if/v-for
      12. 
  
  
  
  
    12.     !isBuiltInTag(node.tag) && // 不是內(nèi)置組件 slot/component
      13. 
  
  
  
  
    13.     !isDirectChildOfTemplateFor(node) && // 不在 template for 循環(huán)內(nèi)
      14. 
  
  
  
  
    14.     Object.keys(node).every(isStaticKey) // 非靜態(tài)節(jié)點
      15. 
  
  
  
  
    15.   )
      16. 
  
  
  
  
    16. }
      17. 
  
  
  
  
    17. 
  
  
  
  
    18. function markStatic (node) {
      19. 
  
  
  
  
    19.   node.static = isStatic(node)
      20. 
  
  
  
  
    20.   if (node.type === 1) {
      21. 
  
  
  
  
    21.     // 如果是元素節(jié)點，需要遍歷所有子節(jié)點
      22. 
  
  
  
  
    22.     for (let i = 0, l = node.children.length; i < l; i++) {
      23. 
  
  
  
  
    23.       const child = node.children[i]
      24. 
  
  
  
  
    24.       markStatic(child)
      25. 
  
  
  
  
    25.       if (!child.static) {
      26. 
  
  
  
  
    26.         // 如果有一個子節(jié)點不是靜態(tài)節(jié)點，則該節(jié)點也必須是動態(tài)的
      27. 
  
  
  
  
    27.         node.static = false
      28. 
  
  
  
  
    28.       }
      29. 
  
  
  
  
    29.     }
      30. 
  
  
  
  
    30.   }
      31. 
  
  
  
  
    31. }
      32.

    generate
    得到優(yōu)化的 AST 之后，就需要將 AST 轉(zhuǎn)化為 render 方法。還是用之前的模板，先看看生成的代碼長什么樣：

     
 
 
 
      
  
  
  
  
      2. 
  
  
  
  
    2.   {{message}}
      3. 
  
  
  
  
    3.   showName
      4. 
  
  
  
  
     
 
 
 
      
  
  
  
  
    1. {
      2. 
  
  
  
  
    2.   render: "with(this){return _c('div',[(message)?_c('h2',[_v(_s(message))]):_e(),_v(" "),_c('button',{on:{"click":showName}},[_v("showName")])])}"
      3. 
  
  
  
  
    3. }
      4.

    將生成的代碼展開：

     
 
 
 
      
  
  
  
  
    1. with (this) {
      2. 
  
  
  
  
    2.     return _c(
      3. 
  
  
  
  
    3.       'div',
      4. 
  
  
  
  
    4.       [
      5. 
  
  
  
  
    5.         (message) ? _c('h2', [_v(_s(message))]) : _e(),
      6. 
  
  
  
  
    6.         _v(' '),
      7. 
  
  
  
  
    7.         _c('button', { on: { click: showName } }, [_v('showName')])
      8. 
  
  
  
  
    8.       ])
      9. 
  
  
  
  
    9.     ;
      10. 
  
  
  
  
    10. }
      11.

    看到這里一堆的下劃線肯定很懵逼，這里的 _c 對應(yīng)的是虛擬 DOM 中的 createElement 方法。其他的下劃線方法在 core/instance/render-helpers 中都有定義，每個方法具體做了什么不做展開。

    render-helpers`
    具體轉(zhuǎn)化方法就是一些簡單的字符拼接，下面是簡化了邏輯的部分，不做過多講述。

     
 
 
 
      
  
  
  
  
    1. export function generate(ast, options) {
      2. 
  
  
  
  
    2.   const state = new CodegenState(options)
      3. 
  
  
  
  
    3.                                                   
      
                                                分享文章：Vue模板編譯原理                                                
      
                                                網(wǎng)頁網(wǎng)址：http://www.5511xx.com/article/dhhoedj.html