[ { "path": "0.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n\r\n\r\n\r\n\r\n
\r\n {{ message }}\r\n
\r\n
\r\n
\r\n\r\n \r\n \r\n
\r\n\r\n\r\n
\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "05自定义指令.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
\r\n \r\n \r\n \r\n \r\n
\r\n\r\n\r\n" }, { "path": "06provide组件通信.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
\r\n \r\n
\r\n
\r\n {{ message }}\r\n
\r\n\r\n\r\n\r\n\r\n" }, { "path": "07.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
\r\n \r\n\r\n \r\n
\r\n\r\n\r\n\r\n" }, { "path": "08delimiters.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n\r\n\r\n\r\n\r\n
\r\n {{ message }}\r\n
\r\n\r\n
\r\n ${ message }\r\n
\r\n\r\n\r\n\r\n\r\n" }, { "path": "09v-model.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
\r\n\r\n \r\n \r\n\r\n \r\n \r\n
\r\n\r\n\r\n\r\n\r\n" }, { "path": "1.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
\r\n \r\n
\r\n
\r\n {{ message }}\r\n
\r\n\r\n\r\n\r\n\r\n" }, { "path": "10tag标签.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n\r\n
\r\n \r\n i 标签\r\n 在纯文本中，要宽容，把它当作文本来对待\r\n \r\n {{lovingVue}}\r\n \r\n
\r\n {{select}}\r\n
\r\n
\r\n\r\n\r\n\r\n\r\n" }, { "path": "10标签匹配.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
\r\n \r\n
\r\n \r\n 213\r\n \r\n
\r\n
\r\n {{message}}\r\n
\r\n\r\n
\r\n\r\n\r\n" }, { "path": "11tag标签.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n

标签h1

\r\n
我是div
\r\n
\r\n
我是div
\r\n 我是span\r\n \r\n

标签h1

\r\n
\r\n\r\n\r\n\r\n\r\n" }, { "path": "11标签匹配.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
\r\n\r\n
\r\n {{message}}\r\n
\r\n\r\n
\r\n\r\n\r\n" }, { "path": "12tag标签.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n\r\n
\r\n \r\n \r\n\r\n span 节点\r\n {{isClass}}\r\n {{number}}\r\n \r\n\r\n
\r\n\r\n\r\n\r\n\r\n" }, { "path": "12高阶组件.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
\r\n \r\n \r\n
  • \r\n {{item.msg}}\r\n
    • \r\n     \r\n \r\n
    \r\n\r\n" }, { "path": "13组件.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n\r\n
    \r\n \r\n \r\n\r\n span 节点\r\n {{isClass}}\r\n \r\n \r\n\r\n
    \r\n\r\n\r\n\r\n\r\n" }, { "path": "14高阶组件.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
    \r\n \r\n \r\n
  • \r\n {{item.msg}}\r\n
    • \r\n     \r\n
    \r\n\r\n\r\n\r\n\r\n" }, { "path": "15 vonde.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
    \r\n \r\n \r\n\r\n span 节点\r\n {{isClass}}\r\n \r\n\r\n
    \r\n\r\n\r\n\r\n\r\n" }, { "path": "16transition动画1.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n\r\n
    \r\n \r\n \r\n

    hello

    \r\n \r\n
    \r\n\r\n \r\n\r\n\r\n" }, { "path": "16transition动画2.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n\r\n
    \r\n
    \r\n \r\n \r\n

    hello

    \r\n     \r\n
    \r\n\r\n \r\n
    \r\n\r\n" }, { "path": "16transition动画3.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n\r\n
    \r\n \r\n \r\n

    hello

    \r\n     \r\n
    \r\n\r\n \r\n\r\n\r\n" }, { "path": "17transition动画中的appear.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n\r\n\r\n
    \r\n \r\n

    appear

    \r\n \r\n
    \r\n\r\n\r\n" }, { "path": "2.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
    \r\n \r\n
    \r\n\r\n\r\n\r\n" }, { "path": "3.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
    \r\n {{message}}\r\n \r\n
    \r\n\r\n\r\n\r\n" }, { "path": "4.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n \r\n\r\n\r\n\r\n\r\n\r\n
    \r\n {{ message }}\r\n
    \r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "5.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
    \r\n {{message}}\r\n \r\n \r\n
    \r\n\r\n\r\n\r\n" }, { "path": "6.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "6属性.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
    \r\n {{message}}\r\n\r\n
    \r\n\r\n\r\n\r\n\r\n" }, { "path": "7for属性.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
    \r\n \r\n\r\n
    \r\n\r\n\r\n\r\n\r\n" }, { "path": "8event属性.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
    \r\n \r\n\r\n
    \r\n\r\n\r\n\r\n\r\n" }, { "path": "HTMLUnknownElement.html", "content": "\r\n \r\n \r\n \r\n \r\n \r\n \r\n" }, { "path": "IS_REGEX_CAPTURING_BROKEN.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "JS里charCodeAt()和fromCharCode().html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "JS里charCodeAt()和fromCharCode()方法拓展应用：加密与解密.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n

    \r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "MessageChannel.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n \r\n\r\n" }, { "path": "MessageChannel_0.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "MessageChannel_1.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "Proxy_1.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "Proxy_2.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "Proxy_3.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "Proxy_4.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "Proxy_5.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "Proxy_6.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "README.md", "content": " ***English document***: https://github.com/ygs-code/vue/blob/master/README_EN.md\n# 开始\n\n vue源码业余时间差不多看了一年，以前在网上找帖子，发现很多帖子很零散，都是一部分一部分说，断章的很多，所以自己下定决定一行行看，经过自己坚持与努力，现在基本看完了 。这个vue源码逐行分析，我基本每一行都打上注释，加上整个框架的流程思维导图，基本上是小白也能看懂的vue源码了。\n\n 说的非常的详细，里面的源码注释，有些是自己多年开发vue经验而获得的，有些是自己跑上下文程序知道的， 如果有不足的地方可以联系我QQ群 ：302817612 修改，或者发邮件给我281113270@qq.com 谢谢。 如果大家觉得不错请动动小手指，帮我点一个satr，你们的支持就是我的动力。\n\nvue 如何去看vue源码呢？其实mvvm源码并没有想象中那么神秘，从12年开始到至今mvvm发展已经有了十几年历史了，从以前直接操作dom的jq发展有十几年历史，但是这十几年历史发展，并没有多大的改变，思想还是那些，模块还是分为几大块：\n\n## 1.模板转换：\n\n 就是我们写的 vue 模板 或者是 react jsx 我们都可以理解是模板，然后他会经过 模板编译转换，像vue的话是进过一个方法paseHTML方法转换成ast树，里面的paseHTML用while 循环模板，然后经过正则 匹配到vue指令，还有vue的属性，事件方法等，收集到一个ast树中。\n\n## 2.数据相应：\n\n vue是一个双数据相应的框架，底层用的是Object.defineProperty 监听和挟持数据改变，然后调用回调方法更新视图更新。双数据绑定原理是：obersve()方法判断value没有没有__ob___属性并且是不是Obersve实例化的， value是不是Vonde实例化的，如果不是则调用Obersve 去把数据添加到观察者中，为数据添加__ob__属性， Obersve 则调用defineReactive方法，该方法是连接Dep和wacther方法的一个通道，利用Object.definpropty() 中的get和set方法 监听数据。get方法中是new Dep调用depend()。为dep添加一个wacther类，watcher中有个方法是更新视图的是run调用update去更新vonde 然后更新视图。 然后set方法就是调用dep中的notify 方法调用wacther中的run 更新视图\n\n## 3.虚拟dom：\n\n vnode，在vue用vnode是通过 ast对象，在转义成vonde 需要渲染的函数，比如_c('div' s('')) 等这类的函数，编译成vonde 虚拟dom。然后到updata更新数据 调用__patch__ 把vonde 通过diff算法变成正真正的dom元素。\n\n## 4.diif算法：\n\n​ vue2 的diff 算法是深度优先算法遍历，然后对比算法是通过 新旧的vnode对比先对比他们的基本属性，比如key 标签等，如果是相同则通过diff算法对比然后diff算法是新旧的vnode对比，然后有四个指针索引，两个新的vnode开始指针和新的 vnode 结束指针，两个旧的vnode开始指针和旧的 vnode 结束指针。然后先判断vnode是否为空，如果为空就往中间靠拢 开始的指针++ 结束的指针 --。然后两头对比之后，在交叉对比，直到找不到相同的vnode之后如果多出的就删除，如果少的话就新增，然后对比完之后在更新到真实dom。\n\n\n\n\n\n源码入口流程 vue源码解读流程 1.new Vue 调用的是 Vue.prototype._init 从该函数开始 经过 $options 参数合并之后 initLifecycle 初始化生命周期标志 初始化事件，初始化渲染函数。初始化状态就是数据。把数据添加到观察者中实现双数据绑定。\n\n# new Vue实例化程序入口\n\n```\n Vue.prototype._init = function (options) { //初始化函数\n //... 省略code\n \n initLifecycle(vm); //初始化生命周期 标志\n initEvents(vm); //初始化事件\n initRender(vm); // 初始化渲染\n callHook(vm, 'beforeCreate'); //触发beforeCreate钩子函数\n initInjections(vm); // resolve injections before data/props 在数据/道具之前解决注入问题 //初始化 inject\n initState(vm); // //初始化状态\n initProvide(vm); // resolve provide after data/props 解决后提供数据/道具 provide 选项应该是一个对象或返回一个对象的函数。该对象包含可注入其子孙的属性，用于组件之间通信。\n callHook(vm, 'created'); //触发created钩子函数\n \n \n //... 省略code\n // 然后挂载模板，这里大概就是把模板转换成ast的入口\n vm.$mount(vm.$options.el);\n \n }\n```\n\n\n\n# 查找和挂载模板\n\n​ vm.$mount 进入这个挂载模板方法，判断是否有 render 函数 或者是template，如果没有则使用el.outerHTML , 实际上这里就是要拿到模板的html内容\n\n```\n Vue.prototype.$mount = function (el, hydrating) { \n //... 省略code\n el = el && query(el); //获取dom\n if (!options.render) {\n if (template) {\n \n }else if (template.nodeType) { \n template = template.innerHTML;\n } else if (el) {\n template = getOuterHTML(el);\n }\n ｝\n \n \n // render 函数 也是 ast 转换 方法\n var ref = compileToFunctions(\n template, //模板字符串\n {\n shouldDecodeNewlines: shouldDecodeNewlines, //flase //IE在属性值中编码换行，而其他浏览器则不会\n shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref, //true chrome在a[href]中编码内容\n delimiters: options.delimiters, //改变纯文本插入分隔符。修改指令的书写风格，比如默认是{{mgs}} delimiters: ['${', '}']之后变成这样 ${mgs}\n comments: options.comments //当设为 true 时，将会保留且渲染模板中的 HTML 注释。默认行为是舍弃它们。\n },\n this\n );\n \n \n \n \n //... 省略code\n //执行$mount方法 用$mount的方法把扩展挂载到dom上\n return mount.call(\n this,\n el, //真实的dom\n hydrating //undefined\n )\n \n ｝\n```\n\n\n\n# 编译AST和render函数\n\n调用 Vue.prototype.$mount 方法之后 拿到模板之后 就会进入以下这几个方法，这几个方法用了很多函数式编程\n\n```\ncompileToFunctions\n\ncreateCompiler\n\ncreateCompilerCreator\n\nbaseCompile\n\nparse\n\nparseHTML\n\n```\n\n这里比较重点的是parseHTML 他是 while (html) { //循环html 然后 然后经过正则 匹配到vue指令，还有vue的属性，事件方法等，收集到一个ast树中。\n\n```\n function parseHTML(\n html, //字符串模板\n options //参数\n ) {\n var stack = []; // parseHTML 节点标签堆栈\n var expectHTML = options.expectHTML; //true\n var isUnaryTag$$1 = options.isUnaryTag || no; //函数匹配标签是否是 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen, link,meta,param,source,track,wbr'\n var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no; //函数 //判断标签是否是 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'\n var index = 0;\n var last, //\n lastTag; //\n console.log(html)\n\n\n\n while (html) { //循环html\n last = html; //\n // Make sure we're not in a plaintext content element like script/style 确保我们不在像脚本/样式这样的纯文本内容元素中\n if (\n !lastTag || //lastTag 不存在\n !isPlainTextElement(lastTag) // 如果标签不是script,style,textarea\n ) {\n\n var textEnd = html.indexOf('<'); //匹配开始标签或者结束标签的位置\n if (textEnd === 0) { //标识是开始标签\n // Comment:\n if (comment.test(html)) { //匹配 开始字符串为'); //获取注释标签的结束位置\n\n if (commentEnd >= 0) { //如果注释标签结束标签位置大于0，则有注释内容\n console.log(html.substring(4, commentEnd))\n if (options.shouldKeepComment) { //shouldKeepComment为真时候。获取注释标签内容\n\n //截取注释标签的内容\n options.comment(html.substring(4, commentEnd));\n }\n //截取字符串重新循环 while 跳出循环就是靠该函数，每次匹配到之后就截取掉字符串，知道最后一个标签被截取完没有匹配到则跳出循环\n advance(commentEnd + 3);\n continue\n }\n }\n\n //这里思路是先匹配到注释节点，在匹配到这里的ie浏览器加载样式节点\n // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n if (conditionalComment.test(html)) { //匹配开始为 匹配这样动态加ie浏览器的 字符串 \n //匹配ie浏览器动态加样式结束符号\n var conditionalEnd = html.indexOf(']>');\n\n if (conditionalEnd >= 0) {\n //截取字符串重新循环 while 跳出循环就是靠该函数，每次匹配到之后就截取掉字符串，知道最后一个标签被截取完没有匹配到则跳出循环\n advance(conditionalEnd + 2);\n continue\n }\n }\n\n // Doctype:\n //匹配html的头文件 \n var doctypeMatch = html.match(doctype);\n if (doctypeMatch) {\n //截取字符串重新循环 while 跳出循环就是靠该函数，每次匹配到之后就截取掉字符串，知道最后一个标签被截取完没有匹配到则跳出循环\n advance(doctypeMatch[0].length);\n continue\n }\n\n // End tag:\n //匹配开头必需是]*>\n var endTagMatch = html.match(endTag);\n if (endTagMatch) {\n\n var curIndex = index;\n //标签分隔函数 while 跳出循环就是靠该函数，每次匹配到之后就截取掉字符串，知道最后一个标签被截取完没有匹配到则跳出循环\n advance(endTagMatch[0].length);\n console.log(endTagMatch)\n console.log(curIndex, index)\n //查找parseHTML的stack栈中与当前tagName标签名称相等的标签，\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n parseEndTag(\n endTagMatch[1],\n curIndex,\n index\n );\n continue\n }\n\n // Start tag:\n //解析开始标记 标记开始标签\n // 获取开始标签的名称，属性集合，开始位置和结束位置，并且返回该对象\n var startTagMatch = parseStartTag();\n\n if (startTagMatch) {\n //把数组对象属性值循环变成对象，这样可以过滤相同的属性\n //为parseHTML 节点标签堆栈 插入一个桟数据\n //调用options.start 为parse函数 stack标签堆栈 添加一个标签\n handleStartTag(startTagMatch);\n //匹配tag标签是pre,textarea，并且第二个参数的第一个字符是回车键\n if (shouldIgnoreFirstNewline(lastTag, html)) {\n //去除回车键空格\n advance(1);\n }\n continue\n }\n }\n\n var text = (void 0),\n rest = (void 0),\n next = (void 0);\n if (textEnd >= 0) {\n\n rest = html.slice(textEnd); //截取字符串 var textEnd = html.indexOf('<'); //匹配开始标签或者结束标签的位置\n console.log(rest)\n\n while (\n !endTag.test(rest) && //匹配开头必需是]*>)', 'i'));\n var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {\n endTagLength = endTag.length;\n if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {\n text = text\n .replace(//g, '$1') // #7298\n .replace(//g, '$1');\n }\n //匹配tag标签是pre,textarea，并且第二个参数的第一个字符是回车键\n if (shouldIgnoreFirstNewline(stackedTag, text)) {\n text = text.slice(1);\n }\n if (options.chars) {\n options.chars(text);\n }\n return ''\n });\n index += html.length - rest$1.length;\n html = rest$1;\n parseEndTag(stackedTag, index - endTagLength, index);\n }\n\n if (html === last) {\n options.chars && options.chars(html);\n if (\"development\" !== 'production' && !stack.length && options.warn) {\n options.warn((\"Mal-formatted tag at end of template: \\\"\" + html + \"\\\"\"));\n }\n break\n }\n }\n\n\n\n\n\n\n // Clean up any remaining tags\n //查找parseHTML的stack栈中与当前tagName标签名称相等的标签，\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n parseEndTag();\n //while 跳出循环就是靠该函数，每次匹配到之后就截取掉字符串，知道最后一个标签被截取完没有匹配到则跳出循环\n function advance(n) {\n index += n; //让索引叠加\n html = html.substring(n); //截取当前索引 和 后面的字符串。\n }\n\n //获取开始标签的名称，收集属性集合，开始位置和结束位置，并且返回该对象\n function parseStartTag() {\n var start = html.match(startTagOpen); //匹配开始标签 匹配开头必需是< 后面可以忽略是任何字符串 ^<((?:[a-zA-Z_][\\\\w\\\\-\\\\.]*\\\\:)?[a-zA-Z_][\\\\w\\\\-\\\\.]*)\n console.log(start)\n console.log(start[0].length)\n\n if (start) {\n var match = {\n tagName: start[1], //标签名称\n attrs: [], //标签属性集合\n start: index //标签的开始索引\n };\n //标记开始标签的位置，截取了开始标签\n advance(start[0].length);\n var end, attr;\n\n while (\n !(end = html.match(startTagClose)) //没有到 关闭标签 > 标签\n && (attr = html.match(attribute)) //收集属性\n ) {\n console.log(html)\n //截取属性标签\n advance(attr[0].length);\n match.attrs.push(attr); //把属性收集到一个集合\n }\n if (end) {\n match.unarySlash = end[1]; //如果是/>标签 则unarySlash 是/。 如果是>标签 则unarySlash 是空\n console.log(end)\n\n //截取掉开始标签，并且更新索引\n advance(end[0].length);\n match.end = index; //开始标签的结束位置\n return match\n }\n }\n }\n\n //把数组对象属性值循环变成对象，这样可以过滤相同的属性\n //为parseHTML 节点标签堆栈 插入一个桟数据\n //调用options.start 为parse函数 stack标签堆栈 添加一个标签\n function handleStartTag(match) {\n /*\n * match = {\n tagName: start[1], //标签名称\n attrs: [], //标签属性集合\n start: index， //开始标签的开始索引\n match:index ， //开始标签的 结束位置\n unarySlash:'' //如果是/>标签 则unarySlash 是/。 如果是>标签 则unarySlash 是空\n };\n * */\n\n var tagName = match.tagName; //开始标签名称\n var unarySlash = match.unarySlash; //如果是/>标签 则unarySlash 是/。 如果是>标签 则unarySlash 是空\n console.log(expectHTML)\n console.log('lastTag==')\n console.log(lastTag)\n console.log(tagName)\n\n if (expectHTML) { //true\n\n if (\n lastTag === 'p' //上一个标签是p\n /*\n 判断标签是否是\n 'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +\n 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +\n 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +\n 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +\n 'title,tr,track'\n */\n && isNonPhrasingTag(tagName)\n ) {\n //查找parseHTML的stack栈中与当前tagName标签名称相等的标签，\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n parseEndTag(lastTag);\n }\n if (\n canBeLeftOpenTag$$1(tagName) && //判断标签是否是 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'\n lastTag === tagName //上一个标签和现在标签相同
  • 编译成
  • 但是这种情况是不会出现的 因为浏览器解析的时候会自动补全如果是
  • 我是li标签
  • 浏览器自动解析成
  • 我是li标签
    • \n ) {\n //查找parseHTML的stack栈中与当前tagName标签名称相等的标签，\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n parseEndTag(tagName);\n }\n }\n\n var unary = isUnaryTag$$1(tagName) || //函数匹配标签是否是 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen, link,meta,param,source,track,wbr'\n !!unarySlash; //如果是/> 则为真\n\n var l = match.attrs.length;\n var attrs = new Array(l); //数组属性对象转换正真正的数组对象\n for (var i = 0; i < l; i++) {\n var args = match.attrs[i]; //获取属性对象\n // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n //对FF bug进行黑客攻击:https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n if (\n IS_REGEX_CAPTURING_BROKEN && //这个应该是 火狐浏览器私有 标志\n args[0].indexOf('\"\"') === -1\n ) {\n if (args[3] === '') {\n delete args[3];\n }\n if (args[4] === '') {\n delete args[4];\n }\n if (args[5] === '') {\n delete args[5];\n }\n }\n var value = args[3] || args[4] || args[5] || '';\n var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'\n ? options.shouldDecodeNewlinesForHref // true chrome在a[href]中编码内容\n : options.shouldDecodeNewlines; //flase //IE在属性值中编码换行，而其他浏览器则不会\n\n attrs[i] = { //把数组对象属性值循环变成对象，这样可以过滤相同的属性\n name: args[1], //属性名称\n //属性值\n value: decodeAttr(value, shouldDecodeNewlines) //替换html 中的特殊符号，转义成js解析的字符串,替换 把 <替换 < ， > 替换 > ， "替换 \"， &替换 & ， 替换\\n ， 替换\\t\n\n };\n\n }\n\n console.log('==!unary==')\n console.log(!unary)\n\n if (!unary) { //如果不是单标签\n\n // 为parseHTML 节点标签堆栈 插入一个桟数据\n stack.push({ //标签堆栈\n tag: tagName, //开始标签名称\n lowerCasedTag: tagName.toLowerCase(), //变成小写记录标签\n attrs: attrs //获取属性\n });\n //设置结束标签\n lastTag = tagName;\n console.log('== parseHTML handleStartTag stack==')\n console.log(stack)\n\n }\n\n\n //\n if (options.start) {\n\n //标签开始函数， 创建一个ast标签dom， 判断获取v-for属性是否存在如果有则转义 v-for指令 把for，alias，iterator1，iterator2属性添加到虚拟dom中\n //获取v-if属性，为el虚拟dom添加 v-if，v-eles，v-else-if 属性\n //获取v-once 指令属性，如果有有该属性 为虚拟dom标签 标记事件 只触发一次则销毁\n //校验属性的值，为el添加muted， events，nativeEvents，directives， key， ref，slotName或者slotScope或者slot，component或者inlineTemplate 标志 属性\n // 标志当前的currentParent当前的 element\n //为parse函数 stack标签堆栈 添加一个标签\n options.start(\n tagName, //标签名称\n attrs, //标签属性\n unary, // 如果不是单标签则为真\n match.start, //开始标签的开始位置\n match.end //开始标签的结束的位置\n );\n }\n\n\n }\n\n\n\n //查找parseHTML的stack栈中与当前tagName标签名称相等的标签，\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n function parseEndTag(\n tagName, //标签名称\n start, //结束标签开始位置\n end //结束标签结束位置\n ) {\n var pos,\n lowerCasedTagName;\n if (start == null) { //如果没有传开始位置\n start = index; //就那当前索引\n }\n if (end == null) { //如果没有传结束位置\n end = index; //就那当前索引\n }\n\n if (tagName) { //结束标签名称\n lowerCasedTagName = tagName.toLowerCase(); //将字符串转化成小写\n }\n\n // Find the closest opened tag of the same type 查找最近打开的相同类型的标记\n if (tagName) {\n // 获取stack堆栈最近的匹配标签\n for (pos = stack.length - 1; pos >= 0; pos--) {\n //找到最近的标签相等\n if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n break\n }\n }\n } else {\n // If no tag name is provided, clean shop\n //如果没有提供标签名称，请清理商店\n pos = 0;\n }\n\n\n if (pos >= 0) { //这里就获取到了stack堆栈的pos索引\n // Close all the open elements, up the stack 关闭所有打开的元素，向上堆栈\n console.log(pos)\n\n for (var i = stack.length - 1; i >= pos; i--) {\n\n if (\"development\" !== 'production' && //如果stack中找不到tagName 标签的时候就输出警告日志，找不到标签\n (i > pos || !tagName) &&\n options.warn\n ) {\n options.warn(\n (\"tag <\" + (stack[i].tag) + \"> has no matching end tag.\")\n );\n }\n if (options.end) {\n console.log(options.end)\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n options.end(\n stack[i].tag,//结束标签名称\n start, //结束标签开始位置\n end //结束标签结束位置\n );\n }\n }\n // Remove the open elements from the stack\n //从堆栈中删除打开的元素\n // console.log(stack[pos].tag)\n // 为parseHTML 节点标签堆栈 出桟当前匹配到的标签\n stack.length = pos;\n //获取到上一个标签，就是当前节点的父节点\n lastTag = pos && stack[pos - 1].tag;\n console.log(stack)\n console.log(lastTag)\n\n\n\n\n } else if (lowerCasedTagName === 'br') {\n if (options.start) {\n //标签开始函数， 创建一个ast标签dom， 判断获取v-for属性是否存在如果有则转义 v-for指令 把for，alias，iterator1，iterator2属性添加到虚拟dom中\n //获取v-if属性，为el虚拟dom添加 v-if，v-eles，v-else-if 属性\n //获取v-once 指令属性，如果有有该属性 为虚拟dom标签 标记事件 只触发一次则销毁\n //校验属性的值，为el添加muted， events，nativeEvents，directives， key， ref，slotName或者slotScope或者slot，component或者inlineTemplate 标志 属性\n // 标志当前的currentParent当前的 element\n //为parse函数 stack标签堆栈 添加一个标签\n options.start(\n tagName,\n [], true,\n start,\n end\n );\n }\n } else if (lowerCasedTagName === 'p') {\n if (options.start) {\n //标签开始函数， 创建一个ast标签dom， 判断获取v-for属性是否存在如果有则转义 v-for指令 把for，alias，iterator1，iterator2属性添加到虚拟dom中\n //获取v-if属性，为el虚拟dom添加 v-if，v-eles，v-else-if 属性\n //获取v-once 指令属性，如果有有该属性 为虚拟dom标签 标记事件 只触发一次则销毁\n //校验属性的值，为el添加muted， events，nativeEvents，directives， key， ref，slotName或者slotScope或者slot，component或者inlineTemplate 标志 属性\n // 标志当前的currentParent当前的 element\n //为parse函数 stack标签堆栈 添加一个标签\n options.start(\n tagName,\n [], false,\n start,\n end);\n }\n if (options.end) {\n //删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n options.end(\n tagName,\n start,\n end\n );\n }\n }\n console.log(lastTag)\n\n }\n }\n```\n\n\n\n一些匹配模板正则\n\n```\n var onRE = /^@|^v-on:/;//判断是否是 @或者v-on:属性开头的\n var dirRE = /^v-|^@|^:/; //判断是否是 v-或者@或者: 属性开头的\n var forAliasRE = /([^]*?)\\s+(?:in|of)\\s+([^]*)/; //匹配 含有 字符串 in 字符串 或者 字符串 of 字符串\n var forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/; //匹配上, 但是属于两边是 [{ , 点 , }] 所以匹配上 ,+字符串\n var stripParensRE = /^\\(|\\)$/g; //匹配括号 ()\n\n var argRE = /:(.*)$/; //匹配字符串是否含有:\n var bindRE = /^:|^v-bind:/; //开始匹配是 :或者是v-bind\n var modifierRE = /\\.[^.]+/g; // 匹配以点开头的分组 不属于点 data.object.info.age 匹配到 ['.object'，'.info' , '.age']\n\n var decodeHTMLCached = cached(he.decode); //获取 真是dom的textContent文本\n```\n\n\n\n## 双数据响应\n\n 双数据绑定 入口 方法在defineReactive函数中 ，不管是 prop 还是 state 还是 属性监听方法 set 方法，还是initInjections 入口都是这里。\n\n首先他会实例化 var dep = new Dep(); 依赖收集 Dep，get方法会添加一个 \n\n​ //添加一个dep\n​ dep.depend();\n\n​ if (childOb) { //如果子节点存在也添加一个dep\n​ childOb.dep.depend();\n​ if (Array.isArray(value)) { //判断是否是数组 如果是数组\n​ dependArray(value); //则数组也添加dep\n​ }\n​ }\n\n\n\nset 方法是触发更新视图的\n\n//observe 添加 观察者\n\n // 然后在添加依赖\n\n childOb = !shallow && observe(newVal);\n //更新数据\n dep.notify();\n\n\n\n```\n /**\n * Define a reactive property on an Object.\n * 在对象上定义一个无功属性。\n * 更新数据\n * 通过defineProperty的set方法去通知notify()订阅者subscribers有新的值修改\n * 添加观察者 get set方法\n */\n function defineReactive(obj, //对象\n key,//对象的key\n val, //监听的数据 返回的数据\n customSetter, // 日志函数\n shallow //是否要添加__ob__ 属性\n ) {\n //实例化一个主题对象，对象中有空的观察者列表\n var dep = new Dep();\n //获取描述属性\n var property = Object.getOwnPropertyDescriptor(obj, key);\n var _property = Object.getOwnPropertyNames(obj); //获取实力对象属性或者方法，包括定义的描述属性\n console.log(property);\n console.log(_property);\n\n if (property && property.configurable === false) {\n return\n }\n\n // cater for pre-defined getter/setters\n\n var getter = property && property.get;\n console.log('arguments.length=' + arguments.length)\n\n if (!getter && arguments.length === 2) {\n val = obj[key];\n }\n var setter = property && property.set;\n console.log(val)\n //判断value 是否有__ob__ 实例化 dep对象,获取dep对象 为 value添加__ob__ 属性递归把val添加到观察者中 返回 new Observer 实例化的对象\n var childOb = !shallow && observe(val);\n //定义描述\n Object.defineProperty(obj, key, {\n enumerable: true,\n configurable: true,\n get: function reactiveGetter() {\n\n var value = getter ? getter.call(obj) : val;\n if (Dep.target) { //Dep.target 静态标志 标志了Dep添加了Watcher 实例化的对象\n //添加一个dep\n dep.depend();\n if (childOb) { //如果子节点存在也添加一个dep\n childOb.dep.depend();\n if (Array.isArray(value)) { //判断是否是数组 如果是数组\n dependArray(value); //则数组也添加dep\n }\n }\n }\n return value\n },\n set: function reactiveSetter(newVal) {\n var value = getter ? getter.call(obj) : val;\n /* eslint-disable no-self-compare 新旧值比较 如果是一样则不执行了*/\n if (newVal === value || (newVal !== newVal && value !== value)) {\n return\n }\n /* eslint-enable no-self-compare\n * 不是生产环境的情况下\n * */\n if (\"development\" !== 'production' && customSetter) {\n customSetter();\n }\n if (setter) {\n //set 方法 设置新的值\n setter.call(obj, newVal);\n } else {\n //新的值直接给他\n val = newVal;\n }\n console.log(newVal)\n\n //observe 添加 观察者\n childOb = !shallow && observe(newVal);\n //更新数据\n dep.notify();\n }\n });\n }\n\n```\n\n\n\n\n\n\n\n## 依赖收集 Dep\n\n 在vue数据get获取中，谁读取了该数据，就把它收集起来，所以dep是一个集合，在数据set时，通过遍历dep去触发每个dep的notify方法通过视图更新\ndep的主要功能是只作为收集，那在收集了依赖后，如何使视图更新呢\n所以需要定义一个新的Watcher类，改类是会实现对视图的更新\n dep每收集的一个依赖实际就是一个Watcher\n\n```\n //主题对象Dep构造函数 主要用于添加发布事件后，用户更新数据的 响应式原理之一函数\n var Dep = function Dep() {\n //uid 初始化为0\n this.id = uid++;\n /* 用来存放Watcher对象的数组 */\n this.subs = [];\n };\n\n Dep.prototype.addSub = function addSub(sub) {\n /* 在subs中添加一个Watcher对象 */\n this.subs.push(sub);\n };\n\n Dep.prototype.removeSub = function removeSub(sub) {\n /*删除 在subs中添加一个Watcher对象 */\n remove(this.subs, sub);\n };\n //this$1.deps[i].depend();\n //为Watcher 添加 为Watcher.newDeps.push(dep); 一个dep对象\n Dep.prototype.depend = function depend() {\n //添加一个dep target 是Watcher dep就是dep对象\n if (Dep.target) {\n //像指令添加依赖项\n Dep.target.addDep(this);\n }\n };\n /* 通知所有Watcher对象更新视图 */\n Dep.prototype.notify = function notify() {\n // stabilize the subscriber list first\n var subs = this.subs.slice();\n for (var i = 0, l = subs.length; i < l; i++) {\n //更新数据\n subs[i].update();\n }\n };\n\n // the current target watcher being evaluated.\n // this is globally unique because there could be only one\n // watcher being evaluated at any time.\n //当前正在评估的目标监视程序。\n //这在全球是独一无二的，因为只有一个\n //观察者在任何时候都被评估。\n Dep.target = null;\n var targetStack = [];\n\n function pushTarget(_target) {\n //target 是Watcher dep就是dep对象\n if (Dep.target) { //静态标志 Dep当前是否有添加了target\n //添加一个pushTarget\n targetStack.push(Dep.target);\n }\n Dep.target = _target;\n }\n\n //\n function popTarget() {\n // 出盏一个pushTarget\n Dep.target = targetStack.pop();\n }\n```\n\n## 数据检测 Watcher\n\n Watcher的功能主要是接口到Dep的通知，然后调用update方法更新视图\n在update方法中会触发回调，回调函数实际就是已生成render函数\n\n在调用render函数是，函数里的值就会获取到已经更改后值，所以就会生成新的vnode\n新的vnode生成后，就是patch的过程，用新的vnode与旧的vnode进行比对，最终将比对后的vnode转换为实际的dom添加到模板挂载节点上\n新的模板挂载后，将旧的模板删除，这样视图就更新完成\n\n```\n * *观察者分析表达式，收集依赖项，\n *并在表达式值更改时触发回调。\n *这用于$watch() api和指令。\n * 当前vue实例、updateComponent函数、空函数。\n */\n var Watcher = function Watcher(\n vm, //vm dom\n expOrFn, //获取值的函数，或者是更新viwe试图函数\n cb, //回调函数,回调值给回调函数\n options, //参数\n isRenderWatcher//是否渲染过得观察者\n ) {\n console.log('====Watcher====')\n this.vm = vm;\n //是否是已经渲染过得观察者\n if (isRenderWatcher) { //把当前 Watcher 对象赋值给 vm._watcher上\n vm._watcher = this;\n }\n //把观察者添加到队列里面 当前Watcher添加到vue实例上\n vm._watchers.push(this);\n // options\n if (options) { //如果有参数\n this.deep = !!options.deep; //实际\n this.user = !!options.user; //用户\n this.lazy = !!options.lazy; //懒惰 ssr 渲染\n this.sync = !!options.sync; //如果是同步\n } else {\n\n this.deep = this.user = this.lazy = this.sync = false;\n }\n this.cb = cb; //回调函数\n this.id = ++uid$1; // uid for batching uid为批处理 监听者id\n this.active = true; //激活\n this.dirty = this.lazy; // for lazy watchers 对于懒惰的观察者\n this.deps = []; // 观察者队列\n this.newDeps = []; // 新的观察者队列\n // 内容不可重复的数组对象\n this.depIds = new _Set();\n this.newDepIds = new _Set();\n // 把函数变成字符串形式\n this.expression = expOrFn.toString();\n // parse expression for getter\n //getter的解析表达式\n if (typeof expOrFn === 'function') {\n //获取值的函数\n this.getter = expOrFn;\n } else {\n //如果是keepAlive 组件则会走这里\n //path 因该是路由地址\n if (bailRE.test(path)) { // 匹配上 返回 true var bailRE = /[^\\w.$]/; //匹配不是 数字字母下划线 $符号 开头的为true\n return\n }\n\n // //匹配不上 path在已点分割\n // var segments = path.split('.');\n // return function (obj) {\n //\n // for (var i = 0; i < segments.length; i++) {\n // //如果有参数则返回真\n // if (!obj) {\n // return\n // }\n // //将对象中的一个key值 赋值给该对象 相当于 segments 以点拆分的数组做obj 的key\n // obj = obj[segments[i]];\n // }\n // //否则返回一个对象\n // return obj\n // }\n\n //匹配不是 数字字母下划线 $符号 开头的为true\n\n this.getter = parsePath(expOrFn);\n if (!this.getter) { //如果不存在 则给一个空的数组\n this.getter = function () {\n };\n \"development\" !== 'production' && warn(\n \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n 'Watcher only accepts simple dot-delimited paths. ' +\n 'For full control, use a function instead.',\n vm\n );\n }\n }\n this.value = this.lazy ? // lazy为真的的时候才能获取值 这个有是组件才为真\n undefined :\n this.get(); //计算getter，并重新收集依赖项。 获取值\n };\n\n```\n\n在Watcher实例构造函数执行时，会触发get\n触发了get后就会该Watcher实例进行收集\nupdate为接到Dep通知时触发的方法\nupdate内会调用run方法\n在run方法内会调用cb回调方法\ncb回到方法实际就是模板编译时render方法\n\n\n\n\n\n# 虚拟DOM\n\nvue中的虚拟DOM,实际就是通过定义一个Vnode类，在该类上添加了dom的一些属性来标识一个dom\n\n主要的作用是降低对实际dom的操作，来减轻对浏览器性能的耗费\n\n```\n /*\n * 创建标准的vue vnode\n *\n * */\n\n var VNode = function VNode(\n tag, /*当前节点的标签名*/\n data, /*当前节点对应的对象，包含了具体的一些数据信息，是一个VNodeData类型，可以参考VNodeData类型中的数据信息*/\n children, //子节点\n text, //文本\n elm, /*当前节点的dom */\n context, /*编译作用域*/\n componentOptions, /*组件的option选项*/\n asyncFactory/*异步工厂*/) {\n /*当前节点的标签名*/\n this.tag = tag;\n\n /*当前节点对应的对象，包含了具体的一些数据信息，是一个VNodeData类型，可以参考VNodeData类型中的数据信息*/\n this.data = data;\n\n /*当前节点的子节点，是一个数组*/\n this.children = children;\n\n /*当前节点的文本*/\n this.text = text;\n\n /*当前虚拟节点对应的真实dom节点*/\n this.elm = elm;\n\n /*当前节点的名字空间*/\n this.ns = undefined;\n\n /*编译作用域 vm*/\n this.context = context;\n\n this.fnContext = undefined;\n this.fnOptions = undefined;\n this.fnScopeId = undefined;\n\n /*节点的key属性，被当作节点的标志，用以优化*/\n this.key = data && data.key;\n\n /*组件的option选项*/\n this.componentOptions = componentOptions;\n\n /*当前节点对应的组件的实例*/\n this.componentInstance = undefined;\n\n /*当前节点的父节点*/\n this.parent = undefined;\n\n /*简而言之就是是否为原生HTML或只是普通文本，innerHTML的时候为true，textContent的时候为false*/\n this.raw = false;\n\n /*静态节点标志*/\n this.isStatic = false;\n\n /*是否作为跟节点插入*/\n this.isRootInsert = true;\n\n /*是否为注释节点*/\n this.isComment = false;\n\n /*是否为克隆节点*/\n this.isCloned = false;\n\n /*是否有v-once指令*/\n this.isOnce = false;\n\n /*异步工厂*/\n this.asyncFactory = asyncFactory;\n\n this.asyncMeta = undefined;\n this.isAsyncPlaceholder = false;\n };\n```\n\n# diff算法\n\npatch ，sameVnode， patchVnode ，updateChildren 这几个方法\n\n入口是patch 然后调用sameVnode\n\n```\n //sameVnode(oldVnode, vnode)2个节点的基本属性相同，那么就进入了2个节点的diff过程。\n function sameVnode(a, b) {\n return (\n\n a.key === b.key && ( //如果a的key 等于b的key\n (\n\n a.tag === b.tag && // 如果a的tag 等于b的tag\n a.isComment === b.isComment && // 如果a和b 都是注释节点\n isDef(a.data) === isDef(b.data) && //如果a.data 和 b.data 都定义后，是组件，或者是都含有tag属性\n sameInputType(a, b) //相同的输入类型。判断a和b的属性是否相同\n ) || (\n isTrue(a.isAsyncPlaceholder) && //判断是否是异步的\n a.asyncFactory === b.asyncFactory &&\n isUndef(b.asyncFactory.error)\n )\n )\n )\n }\n```\n\n如果调用sameVnode 条件成立 则进入patchVnode 方法,\n\npatchVnode 方法主要是对vnode 进行增加和删除，主要还有key更新等。然后 判断 两个虚拟dom都不为空，并且他们不相等的时候oldCh !== ch 就进入updateChildren diff更新算法。\n\n```\n // 对比 虚拟dom\n function patchVnode(\n oldVnode, // 旧的虚拟dom\n vnode, // 新的虚拟dom\n insertedVnodeQueue, // 删除虚拟dom队列\n removeOnly\n ) {\n if (oldVnode === vnode) { //如果他们相等\n return\n }\n\n var elm = vnode.elm = oldVnode.elm; //获取真实的dom\n\n // 判断是否有isAsyncPlaceholder 属性\n if (isTrue(oldVnode.isAsyncPlaceholder)) {\n //判断数据 是否不等于 undefined或者null\n if (isDef(vnode.asyncFactory.resolved)) {\n // ssr 渲染\n hydrate(oldVnode.elm, vnode, insertedVnodeQueue);\n } else {\n vnode.isAsyncPlaceholder = true;\n }\n return\n }\n\n // reuse element for static trees.\n // note we only do this if the vnode is cloned -\n // if the new node is not cloned it means the render functions have been\n // reset by the hot-reload-api and we need to do a proper re-render.\n //为静态树重用元素。\n //注意，只有当vnode被克隆时，我们才这样做\n //如果新节点没有克隆，则表示渲染函数已经克隆\n //由hot-reload api重置，我们需要做一个适当的重新渲染。\n if (isTrue(vnode.isStatic) &&\n isTrue(oldVnode.isStatic) &&\n vnode.key === oldVnode.key &&\n (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))\n ) {\n vnode.componentInstance = oldVnode.componentInstance;\n return\n }\n\n var i;\n var data = vnode.data;\n // 钩子函数\n if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n i(oldVnode, vnode);\n }\n\n var oldCh = oldVnode.children;\n var ch = vnode.children;\n //循环组件实例 是否定义有 tag标签\n if (isDef(data) && isPatchable(vnode)) {\n // 触发钩子函数 更新钩子函数\n for (i = 0; i < cbs.update.length; ++i) {\n cbs.update[i](oldVnode, vnode);\n }\n // 触发钩子函数\n if (isDef(i = data.hook) && isDef(i = i.update)) {\n i(oldVnode, vnode);\n }\n }\n\n //如果是文本虚拟dom\n if (isUndef(vnode.text)) {\n // 两个虚拟dom都存在\n if (isDef(oldCh) && isDef(ch)) {\n // 如果他们不相等\n if (oldCh !== ch) {\n // diff算法更新\n updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);\n }\n } else if (isDef(ch)) { // 如果是有新的虚拟dom\n // 如果是文本虚拟dom 则 设置 空\n if (isDef(oldVnode.text)) {\n nodeOps.setTextContent(elm, '');\n }\n // 添加 vnode\n addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n } else if (isDef(oldCh)) { // 如果旧的有 新的虚拟dom没有则删除 虚拟dom\n removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n } else if (isDef(oldVnode.text)) { // 如果是文本虚拟dom则设置文本\n nodeOps.setTextContent(elm, '');\n }\n\n\n } else if (oldVnode.text !== vnode.text) {\n // 如果新旧的文本不相同则设置文本\n nodeOps.setTextContent(elm, vnode.text);\n }\n if (isDef(data)) {\n // 触发钩子\n if (isDef(i = data.hook) && isDef(i = i.postpatch)) {\n i(oldVnode, vnode);\n }\n }\n }\n\n```\n\n\n\n# ddif 算法updateChildren\n\ndiif算法，vue2 的diff 算法是深度优先算法遍历，然后对比算法是通过 新旧的vnode对比先对比他们的基本属性，比如key 标签等，如果是相同则通过diff算法对比然后diff算法是新旧的vnode对比，然后有四个指针索引，两个新的vnode开始指针和新的 vnode 结束指针，两个旧的vnode开始指针和旧的 vnode 结束指针。然后先判断vnode是否为空，如果为空就往中间靠拢 开始的指针++ 结束的指针 --。然后两头对比之后，在交叉对比，直到找不到相同的vnode之后如果多出的就删除，如果少的话就新增，然后对比完之后 在调用patchVnode去增删虚拟dom。然后如果有vnode不相同在调用updateChildren，这样就做到深层递归，也叫深度优先搜索，然后子vnode没有了在更新到真实dom。 \n\n```\n\n // ddif 算法\n function updateChildren(\n parentElm, // 父亲dom\n oldCh, // 旧的虚拟dom\n newCh, // 新的虚拟dom\n insertedVnodeQueue,\n removeOnly\n ) {\n var oldStartIdx = 0; // 旧的虚拟dom开始指针 \n var newStartIdx = 0; // 新的虚拟dom开始指针 \n var oldEndIdx = oldCh.length - 1; // 旧的虚拟dom结束指针 \n var newEndIdx = newCh.length - 1;// 新的虚拟dom结束指针 \n\n var oldStartVnode = oldCh[0]; // 旧的虚拟dom开始节点\n var newStartVnode = newCh[0]; // 新的虚拟dom开始节点\n\n var oldEndVnode = oldCh[oldEndIdx]; // 旧的虚拟dom结束节点\n var newEndVnode = newCh[newEndIdx];// 新的虚拟dom结束节点\n\n var oldKeyToIdx, idxInOld, vnodeToMove, refElm;\n\n // removeOnly is a special flag used only by \n // to ensure removed elements stay in correct relative positions\n // during leaving transitions\n var canMove = !removeOnly;\n\n {\n // 检查同一个兄弟节点是否有重复的key，如果有则发出警告日志\n checkDuplicateKeys(newCh);\n }\n\n /*\n diff 算法开始\n 这里diff算法其实就是\n\n */\n while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n\n if (isUndef(oldStartVnode)) {\n // 如果旧的开始节点不存在或者为空\n // 如果旧的开始节点指针往中间偏移\n oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n } else if (isUndef(oldEndVnode)) {\n // 如果旧的结束节点不存在或者为空\n // 如果旧的结束节点指针往中间偏移\n oldEndVnode = oldCh[--oldEndIdx];\n\n } else if (sameVnode(oldStartVnode, newStartVnode)) { //sameVnode(oldVnode, vnode)2个节点的基本属性相同，那么就进入了2个节点的diff过程。\n\n\n\n // 在对比下虚拟dom \n patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n\n //开始指针 两个都往中间偏移\n oldStartVnode = oldCh[++oldStartIdx];\n newStartVnode = newCh[++newStartIdx];\n\n } else if (sameVnode(oldEndVnode, newEndVnode)) { //sameVnode(oldVnode, vnode)2个节点的基本属性相同，那么就进入了2个节点的diff过程。\n // 在对比下虚拟dom \n patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n // 结束指针 两个都往中间偏移\n oldEndVnode = oldCh[--oldEndIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right //sameVnode(oldVnode, vnode)2个节点的基本属性相同，那么就进入了2个节点的diff过程。\n\n // 交叉对比 深度优先算法入口\n patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n // 交叉对比\n canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n\n oldStartVnode = oldCh[++oldStartIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n // 交叉对比\n patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n // 交叉对比\n canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n oldEndVnode = oldCh[--oldEndIdx];\n newStartVnode = newCh[++newStartIdx];\n } else {\n // 如果没有key 则给塔新的key\n if (isUndef(oldKeyToIdx)) {\n\n // 创建key 如果没有key 则用索引作为key\n oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n }\n \n // 获取 旧的vnode key\n idxInOld = isDef(newStartVnode.key)\n ? oldKeyToIdx[newStartVnode.key]\n // 查找旧的vnode key\n : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);\n // 如果旧的 vnode key 未定义则创建新的真实dom\n if (isUndef(idxInOld)) { // New element\n //创建真实 dom 节点\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);\n } else {\n\n vnodeToMove = oldCh[idxInOld];\n if (sameVnode(vnodeToMove, newStartVnode)) {\n // 对比虚拟dom\n patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue);\n \n oldCh[idxInOld] = undefined;\n // 真实节点交换\n canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);\n } else {\n // same key but different element. treat as new element\n // 创建真实dom\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);\n }\n }\n newStartVnode = newCh[++newStartIdx];\n }\n }\n if (oldStartIdx > oldEndIdx) {\n refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n // 添加虚拟dom\n addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n } else if (newStartIdx > newEndIdx) {\n // 删除虚拟dom\n removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n }\n }\n\n```\n\n具体看我源码和流程图，这里文字就不描述这么多了，流程图是下面这中的网盘，源码是vue.js,基本每一行都有注释\n\n链接：https://pan.baidu.com/s/10IxV6mQ2TIwkRACKu2T0ng \n提取码：1fnu \n\n\n上面的vue.js 就是我基于vue源码中每行加有注释的vue.js, 其他文件就是我看vue.js源码的时候抽出来的vue.js 源码小demo。如果大家觉得不错请动动小手指，帮我点一个satr，你们的支持就是我的动力\n\n \n\n 作者：姚观寿\n\n\n\n最近失业了，想找一份前端开发工作，希望有朋友公司招聘的可以联系下我，谢谢你们，地点 深圳，或者远程都可以，前端构架，前端高级开发，组长职位都行。 我微信：18529531779 ， helloTalk 号@18529531779，邮箱：281113270@qq.com 谢谢了。\n" }, { "path": "README_EN.md", "content": "# begin\n\n vue source code spare time to see almost a year, before looking for posts on the Internet, found that many posts are very scattered, are part of a part said, a lot of chapters, so they decided to see line by line, after their own persistence and efforts, now basically read. This vue source line by line analysis, I basically every line on the annotation, plus the whole framework of the process mind map, is basically a small white can also understand the vue source code.\n\nSaid very detailed, inside the source code notes, some are their own years of experience in developing vue, some are their own context program to know, if there are shortcomings can contact me QQ group: 302817612 modification, or send an email to me 281113270@qq.com thank you. If you feel good, please move your little finger to help me click a satr, your support is my motivation.\n\nvue How to see vue source code? In fact, mvvm source code is not as mysterious as imagined, from the beginning of 12 years to the present mvvm development has more than a decade of history, from the previous direct operation of the dom jq development has more than a decade of history, but this decade of historical development, and there is not much change, the idea is still those, the module is still divided into several chunks:\n\n## 1. Template conversion:\n\nIs we write a vue template or react jsx we can understand is a template, and then it will go through the template compilation conversion, like vue is into a method paseHTML method converted into the ast tree, paseHTML inside the while loop template, Then through the RE match to the vue instructions, as well as vue properties, event methods, etc., collected into an ast tree.\n\n## 2. Corresponding data:\n\nvue is a dual data corresponding framework, the underlying use is Object.defineProperty to listen for and hijack data changes, and then call callback methods to update the view update. The principle of dual data binding is as follows: The obersve() method determines whether value has no __ob___ attribute and is not Obersve instantiated, and whether value is Vonde instantiated. If not, it calls Obersve to add the data to the observer and add the __ob__ attribute to the data. Obersve calls the defineReactive method, which is a channel connecting the Dep and wacther methods, and listens for data using the get and set methods in Object.definpropty(). In the get method, new Dep calls depend(). To add a wacther class to dep, watcher has a method to update the view. run calls update to update the vonde and then updates the view. Then the set method is to call the notify method in dep to call the run update view in wacther\n\n## 3. Virtual dom:\n\n\n\n\n\nvnode, used in vue, is via ast objects, escaped into vonde needs to render functions, such as _c('div' s('')) and such functions, compiled into vonde virtual dom. Then update the data to updata and call __patch__ to turn vonde into a true dom element through diff algorithm.\n\n## 4.diif algorithm:\n\n​ The diff algorithm of vue2 is depth-first traversal, and then the comparison algorithm compares the old vnode with the new vnode, first compares their basic attributes, such as key labels, etc. If they are the same, the diff algorithm compares the old Vnode with the new Vnode, and then there are four pointer indexes. Two new vnode start Pointers and two new vnode end Pointers, two old vnode start Pointers and old vnode end Pointers. Then first determine whether the vnode is empty, if it is empty, move to the center of the start pointer ++ end pointer --. Then after comparing the two sides, cross-compare until you can't find the same vnode, if there are more, delete it, if there are fewer, add it, and then update it to the real dom after comparing.\n\n\n\nnew Vue calls vue.prototype. _init. From this function, after merging with the $options parameter, initLifecycle initializes the life cycle, marking the initialization event, and initializing the rendering function. The initialization state is the data. Add data to the observer for double data binding.\n\n# new Vue instantiates the program entry\n\n```\n Vue.prototype._init = function (options) { //初始化函数\n //... 省略code\n \n initLifecycle(vm); //初始化生命周期 标志\n initEvents(vm); //初始化事件\n initRender(vm); // 初始化渲染\n callHook(vm, 'beforeCreate'); //触发beforeCreate钩子函数\n initInjections(vm); // resolve injections before data/props 在数据/道具之前解决注入问题 //初始化 inject\n initState(vm); // //初始化状态\n initProvide(vm); // resolve provide after data/props 解决后提供数据/道具 provide 选项应该是一个对象或返回一个对象的函数。该对象包含可注入其子孙的属性，用于组件之间通信。\n callHook(vm, 'created'); //触发created钩子函数\n \n \n //... 省略code\n // 然后挂载模板，这里大概就是把模板转换成ast的入口\n vm.$mount(vm.$options.el);\n \n }\n```\n\n\n\n# Find and mount templates\n\n vm.$mount goes to the mount template method and determines whether it has a render function or a template, and if not, uses el.outerHTML, which is essentially getting the html content of the template\n\n```\n Vue.prototype.$mount = function (el, hydrating) { \n //... 省略code\n el = el && query(el); //获取dom\n if (!options.render) {\n if (template) {\n \n }else if (template.nodeType) { \n template = template.innerHTML;\n } else if (el) {\n template = getOuterHTML(el);\n }\n ｝\n \n \n // render 函数 也是 ast 转换 方法\n var ref = compileToFunctions(\n template, //模板字符串\n {\n shouldDecodeNewlines: shouldDecodeNewlines, //flase //IE在属性值中编码换行，而其他浏览器则不会\n shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref, //true chrome在a[href]中编码内容\n delimiters: options.delimiters, //改变纯文本插入分隔符。修改指令的书写风格，比如默认是{{mgs}} delimiters: ['${', '}']之后变成这样 ${mgs}\n comments: options.comments //当设为 true 时，将会保留且渲染模板中的 HTML 注释。默认行为是舍弃它们。\n },\n this\n );\n \n \n \n \n //... 省略code\n //执行$mount方法 用$mount的方法把扩展挂载到dom上\n return mount.call(\n this,\n el, //真实的dom\n hydrating //undefined\n )\n \n ｝\n```\n\n\n\n# Compile the AST and render functions\n\nAfter you call the Vue.prototype.$mount method and get the template, you enter the following methods, which use a lot of functional programming\n\n```\ncompileToFunctions\n\ncreateCompiler\n\ncreateCompilerCreator\n\nbaseCompile\n\nparse\n\nparseHTML\n\n```\n\nThe important thing here is that parseHTML is a while (html) {// loop through the html and then through the re match to the vue directive, as well as vue properties, event methods, etc., collected into an ast tree.\n\n```\n function parseHTML(\n html, //字符串模板\n options //参数\n ) {\n var stack = []; // parseHTML 节点标签堆栈\n var expectHTML = options.expectHTML; //true\n var isUnaryTag$$1 = options.isUnaryTag || no; //函数匹配标签是否是 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen, link,meta,param,source,track,wbr'\n var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no; //函数 //判断标签是否是 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'\n var index = 0;\n var last, //\n lastTag; //\n console.log(html)\n\n\n\n while (html) { //循环html\n last = html; //\n // Make sure we're not in a plaintext content element like script/style 确保我们不在像脚本/样式这样的纯文本内容元素中\n if (\n !lastTag || //lastTag 不存在\n !isPlainTextElement(lastTag) // 如果标签不是script,style,textarea\n ) {\n\n var textEnd = html.indexOf('<'); //匹配开始标签或者结束标签的位置\n if (textEnd === 0) { //标识是开始标签\n // Comment:\n if (comment.test(html)) { //匹配 开始字符串为'); //获取注释标签的结束位置\n\n if (commentEnd >= 0) { //如果注释标签结束标签位置大于0，则有注释内容\n console.log(html.substring(4, commentEnd))\n if (options.shouldKeepComment) { //shouldKeepComment为真时候。获取注释标签内容\n\n //截取注释标签的内容\n options.comment(html.substring(4, commentEnd));\n }\n //截取字符串重新循环 while 跳出循环就是靠该函数，每次匹配到之后就截取掉字符串，知道最后一个标签被截取完没有匹配到则跳出循环\n advance(commentEnd + 3);\n continue\n }\n }\n\n //这里思路是先匹配到注释节点，在匹配到这里的ie浏览器加载样式节点\n // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n if (conditionalComment.test(html)) { //匹配开始为 匹配这样动态加ie浏览器的 字符串 \n //匹配ie浏览器动态加样式结束符号\n var conditionalEnd = html.indexOf(']>');\n\n if (conditionalEnd >= 0) {\n //截取字符串重新循环 while 跳出循环就是靠该函数，每次匹配到之后就截取掉字符串，知道最后一个标签被截取完没有匹配到则跳出循环\n advance(conditionalEnd + 2);\n continue\n }\n }\n\n // Doctype:\n //匹配html的头文件 \n var doctypeMatch = html.match(doctype);\n if (doctypeMatch) {\n //截取字符串重新循环 while 跳出循环就是靠该函数，每次匹配到之后就截取掉字符串，知道最后一个标签被截取完没有匹配到则跳出循环\n advance(doctypeMatch[0].length);\n continue\n }\n\n // End tag:\n //匹配开头必需是]*>\n var endTagMatch = html.match(endTag);\n if (endTagMatch) {\n\n var curIndex = index;\n //标签分隔函数 while 跳出循环就是靠该函数，每次匹配到之后就截取掉字符串，知道最后一个标签被截取完没有匹配到则跳出循环\n advance(endTagMatch[0].length);\n console.log(endTagMatch)\n console.log(curIndex, index)\n //查找parseHTML的stack栈中与当前tagName标签名称相等的标签，\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n parseEndTag(\n endTagMatch[1],\n curIndex,\n index\n );\n continue\n }\n\n // Start tag:\n //解析开始标记 标记开始标签\n // 获取开始标签的名称，属性集合，开始位置和结束位置，并且返回该对象\n var startTagMatch = parseStartTag();\n\n if (startTagMatch) {\n //把数组对象属性值循环变成对象，这样可以过滤相同的属性\n //为parseHTML 节点标签堆栈 插入一个桟数据\n //调用options.start 为parse函数 stack标签堆栈 添加一个标签\n handleStartTag(startTagMatch);\n //匹配tag标签是pre,textarea，并且第二个参数的第一个字符是回车键\n if (shouldIgnoreFirstNewline(lastTag, html)) {\n //去除回车键空格\n advance(1);\n }\n continue\n }\n }\n\n var text = (void 0),\n rest = (void 0),\n next = (void 0);\n if (textEnd >= 0) {\n\n rest = html.slice(textEnd); //截取字符串 var textEnd = html.indexOf('<'); //匹配开始标签或者结束标签的位置\n console.log(rest)\n\n while (\n !endTag.test(rest) && //匹配开头必需是]*>)', 'i'));\n var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {\n endTagLength = endTag.length;\n if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {\n text = text\n .replace(//g, '$1') // #7298\n .replace(//g, '$1');\n }\n //匹配tag标签是pre,textarea，并且第二个参数的第一个字符是回车键\n if (shouldIgnoreFirstNewline(stackedTag, text)) {\n text = text.slice(1);\n }\n if (options.chars) {\n options.chars(text);\n }\n return ''\n });\n index += html.length - rest$1.length;\n html = rest$1;\n parseEndTag(stackedTag, index - endTagLength, index);\n }\n\n if (html === last) {\n options.chars && options.chars(html);\n if (\"development\" !== 'production' && !stack.length && options.warn) {\n options.warn((\"Mal-formatted tag at end of template: \\\"\" + html + \"\\\"\"));\n }\n break\n }\n }\n\n\n\n\n\n\n // Clean up any remaining tags\n //查找parseHTML的stack栈中与当前tagName标签名称相等的标签，\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n parseEndTag();\n //while 跳出循环就是靠该函数，每次匹配到之后就截取掉字符串，知道最后一个标签被截取完没有匹配到则跳出循环\n function advance(n) {\n index += n; //让索引叠加\n html = html.substring(n); //截取当前索引 和 后面的字符串。\n }\n\n //获取开始标签的名称，收集属性集合，开始位置和结束位置，并且返回该对象\n function parseStartTag() {\n var start = html.match(startTagOpen); //匹配开始标签 匹配开头必需是< 后面可以忽略是任何字符串 ^<((?:[a-zA-Z_][\\\\w\\\\-\\\\.]*\\\\:)?[a-zA-Z_][\\\\w\\\\-\\\\.]*)\n console.log(start)\n console.log(start[0].length)\n\n if (start) {\n var match = {\n tagName: start[1], //标签名称\n attrs: [], //标签属性集合\n start: index //标签的开始索引\n };\n //标记开始标签的位置，截取了开始标签\n advance(start[0].length);\n var end, attr;\n\n while (\n !(end = html.match(startTagClose)) //没有到 关闭标签 > 标签\n && (attr = html.match(attribute)) //收集属性\n ) {\n console.log(html)\n //截取属性标签\n advance(attr[0].length);\n match.attrs.push(attr); //把属性收集到一个集合\n }\n if (end) {\n match.unarySlash = end[1]; //如果是/>标签 则unarySlash 是/。 如果是>标签 则unarySlash 是空\n console.log(end)\n\n //截取掉开始标签，并且更新索引\n advance(end[0].length);\n match.end = index; //开始标签的结束位置\n return match\n }\n }\n }\n\n //把数组对象属性值循环变成对象，这样可以过滤相同的属性\n //为parseHTML 节点标签堆栈 插入一个桟数据\n //调用options.start 为parse函数 stack标签堆栈 添加一个标签\n function handleStartTag(match) {\n /*\n * match = {\n tagName: start[1], //标签名称\n attrs: [], //标签属性集合\n start: index， //开始标签的开始索引\n match:index ， //开始标签的 结束位置\n unarySlash:'' //如果是/>标签 则unarySlash 是/。 如果是>标签 则unarySlash 是空\n };\n * */\n\n var tagName = match.tagName; //开始标签名称\n var unarySlash = match.unarySlash; //如果是/>标签 则unarySlash 是/。 如果是>标签 则unarySlash 是空\n console.log(expectHTML)\n console.log('lastTag==')\n console.log(lastTag)\n console.log(tagName)\n\n if (expectHTML) { //true\n\n if (\n lastTag === 'p' //上一个标签是p\n /*\n 判断标签是否是\n 'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +\n 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +\n 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +\n 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +\n 'title,tr,track'\n */\n && isNonPhrasingTag(tagName)\n ) {\n //查找parseHTML的stack栈中与当前tagName标签名称相等的标签，\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n parseEndTag(lastTag);\n }\n if (\n canBeLeftOpenTag$$1(tagName) && //判断标签是否是 'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'\n lastTag === tagName //上一个标签和现在标签相同
  • 编译成
  • 但是这种情况是不会出现的 因为浏览器解析的时候会自动补全如果是
  • 我是li标签
  • 浏览器自动解析成
  • 我是li标签
    • \n ) {\n //查找parseHTML的stack栈中与当前tagName标签名称相等的标签，\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n parseEndTag(tagName);\n }\n }\n\n var unary = isUnaryTag$$1(tagName) || //函数匹配标签是否是 'area,base,br,col,embed,frame,hr,img,input,isindex,keygen, link,meta,param,source,track,wbr'\n !!unarySlash; //如果是/> 则为真\n\n var l = match.attrs.length;\n var attrs = new Array(l); //数组属性对象转换正真正的数组对象\n for (var i = 0; i < l; i++) {\n var args = match.attrs[i]; //获取属性对象\n // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n //对FF bug进行黑客攻击:https://bugzilla.mozilla.org/show_bug.cgi?id=369778\n if (\n IS_REGEX_CAPTURING_BROKEN && //这个应该是 火狐浏览器私有 标志\n args[0].indexOf('\"\"') === -1\n ) {\n if (args[3] === '') {\n delete args[3];\n }\n if (args[4] === '') {\n delete args[4];\n }\n if (args[5] === '') {\n delete args[5];\n }\n }\n var value = args[3] || args[4] || args[5] || '';\n var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'\n ? options.shouldDecodeNewlinesForHref // true chrome在a[href]中编码内容\n : options.shouldDecodeNewlines; //flase //IE在属性值中编码换行，而其他浏览器则不会\n\n attrs[i] = { //把数组对象属性值循环变成对象，这样可以过滤相同的属性\n name: args[1], //属性名称\n //属性值\n value: decodeAttr(value, shouldDecodeNewlines) //替换html 中的特殊符号，转义成js解析的字符串,替换 把 <替换 < ， > 替换 > ， "替换 \"， &替换 & ， 替换\\n ， 替换\\t\n\n };\n\n }\n\n console.log('==!unary==')\n console.log(!unary)\n\n if (!unary) { //如果不是单标签\n\n // 为parseHTML 节点标签堆栈 插入一个桟数据\n stack.push({ //标签堆栈\n tag: tagName, //开始标签名称\n lowerCasedTag: tagName.toLowerCase(), //变成小写记录标签\n attrs: attrs //获取属性\n });\n //设置结束标签\n lastTag = tagName;\n console.log('== parseHTML handleStartTag stack==')\n console.log(stack)\n\n }\n\n\n //\n if (options.start) {\n\n //标签开始函数， 创建一个ast标签dom， 判断获取v-for属性是否存在如果有则转义 v-for指令 把for，alias，iterator1，iterator2属性添加到虚拟dom中\n //获取v-if属性，为el虚拟dom添加 v-if，v-eles，v-else-if 属性\n //获取v-once 指令属性，如果有有该属性 为虚拟dom标签 标记事件 只触发一次则销毁\n //校验属性的值，为el添加muted， events，nativeEvents，directives， key， ref，slotName或者slotScope或者slot，component或者inlineTemplate 标志 属性\n // 标志当前的currentParent当前的 element\n //为parse函数 stack标签堆栈 添加一个标签\n options.start(\n tagName, //标签名称\n attrs, //标签属性\n unary, // 如果不是单标签则为真\n match.start, //开始标签的开始位置\n match.end //开始标签的结束的位置\n );\n }\n\n\n }\n\n\n\n //查找parseHTML的stack栈中与当前tagName标签名称相等的标签，\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n function parseEndTag(\n tagName, //标签名称\n start, //结束标签开始位置\n end //结束标签结束位置\n ) {\n var pos,\n lowerCasedTagName;\n if (start == null) { //如果没有传开始位置\n start = index; //就那当前索引\n }\n if (end == null) { //如果没有传结束位置\n end = index; //就那当前索引\n }\n\n if (tagName) { //结束标签名称\n lowerCasedTagName = tagName.toLowerCase(); //将字符串转化成小写\n }\n\n // Find the closest opened tag of the same type 查找最近打开的相同类型的标记\n if (tagName) {\n // 获取stack堆栈最近的匹配标签\n for (pos = stack.length - 1; pos >= 0; pos--) {\n //找到最近的标签相等\n if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n break\n }\n }\n } else {\n // If no tag name is provided, clean shop\n //如果没有提供标签名称，请清理商店\n pos = 0;\n }\n\n\n if (pos >= 0) { //这里就获取到了stack堆栈的pos索引\n // Close all the open elements, up the stack 关闭所有打开的元素，向上堆栈\n console.log(pos)\n\n for (var i = stack.length - 1; i >= pos; i--) {\n\n if (\"development\" !== 'production' && //如果stack中找不到tagName 标签的时候就输出警告日志，找不到标签\n (i > pos || !tagName) &&\n options.warn\n ) {\n options.warn(\n (\"tag <\" + (stack[i].tag) + \"> has no matching end tag.\")\n );\n }\n if (options.end) {\n console.log(options.end)\n //调用options.end函数，删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n options.end(\n stack[i].tag,//结束标签名称\n start, //结束标签开始位置\n end //结束标签结束位置\n );\n }\n }\n // Remove the open elements from the stack\n //从堆栈中删除打开的元素\n // console.log(stack[pos].tag)\n // 为parseHTML 节点标签堆栈 出桟当前匹配到的标签\n stack.length = pos;\n //获取到上一个标签，就是当前节点的父节点\n lastTag = pos && stack[pos - 1].tag;\n console.log(stack)\n console.log(lastTag)\n\n\n\n\n } else if (lowerCasedTagName === 'br') {\n if (options.start) {\n //标签开始函数， 创建一个ast标签dom， 判断获取v-for属性是否存在如果有则转义 v-for指令 把for，alias，iterator1，iterator2属性添加到虚拟dom中\n //获取v-if属性，为el虚拟dom添加 v-if，v-eles，v-else-if 属性\n //获取v-once 指令属性，如果有有该属性 为虚拟dom标签 标记事件 只触发一次则销毁\n //校验属性的值，为el添加muted， events，nativeEvents，directives， key， ref，slotName或者slotScope或者slot，component或者inlineTemplate 标志 属性\n // 标志当前的currentParent当前的 element\n //为parse函数 stack标签堆栈 添加一个标签\n options.start(\n tagName,\n [], true,\n start,\n end\n );\n }\n } else if (lowerCasedTagName === 'p') {\n if (options.start) {\n //标签开始函数， 创建一个ast标签dom， 判断获取v-for属性是否存在如果有则转义 v-for指令 把for，alias，iterator1，iterator2属性添加到虚拟dom中\n //获取v-if属性，为el虚拟dom添加 v-if，v-eles，v-else-if 属性\n //获取v-once 指令属性，如果有有该属性 为虚拟dom标签 标记事件 只触发一次则销毁\n //校验属性的值，为el添加muted， events，nativeEvents，directives， key， ref，slotName或者slotScope或者slot，component或者inlineTemplate 标志 属性\n // 标志当前的currentParent当前的 element\n //为parse函数 stack标签堆栈 添加一个标签\n options.start(\n tagName,\n [], false,\n start,\n end);\n }\n if (options.end) {\n //删除当前节点的子节点中的最后一个如果是空格或者空的文本节点则删除，\n //为stack出栈一个当前标签，为currentParent变量获取到当前节点的父节点\n options.end(\n tagName,\n start,\n end\n );\n }\n }\n console.log(lastTag)\n\n }\n }\n```\n\n\n\n一些匹配模板正则\n\n```\n var onRE = /^@|^v-on:/;//判断是否是 @或者v-on:属性开头的\n var dirRE = /^v-|^@|^:/; //判断是否是 v-或者@或者: 属性开头的\n var forAliasRE = /([^]*?)\\s+(?:in|of)\\s+([^]*)/; //匹配 含有 字符串 in 字符串 或者 字符串 of 字符串\n var forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/; //匹配上, 但是属于两边是 [{ , 点 , }] 所以匹配上 ,+字符串\n var stripParensRE = /^\\(|\\)$/g; //匹配括号 ()\n\n var argRE = /:(.*)$/; //匹配字符串是否含有:\n var bindRE = /^:|^v-bind:/; //开始匹配是 :或者是v-bind\n var modifierRE = /\\.[^.]+/g; // 匹配以点开头的分组 不属于点 data.object.info.age 匹配到 ['.object'，'.info' , '.age']\n\n var decodeHTMLCached = cached(he.decode); //获取 真是dom的textContent文本\n```\n\n\n\n## Dual data response\n\nThe dual data binding entry method is in the defineReactive function, whether it is prop or state or property listener set method or initInjections entry.\n\nFirst he instantiates var dep = new Dep(); Depending on the collection Dep, the get method adds one\n\n​ //添加一个dep\n​ dep.depend();\n\n​ if (childOb) { //如果子节点存在也添加一个dep\n​ childOb.dep.depend();\n​ if (Array.isArray(value)) { //判断是否是数组 如果是数组\n​ dependArray(value); //则数组也添加dep\n​ }\n​ }\n\n\n\nThe set method is the trigger for updating the view\n\n//observe Add an observer\n\n// Then add dependencies\n\n childOb = !shallow && observe(newVal);\n //更新数据\n dep.notify();\n\n\n\n```\n /**\n * Define a reactive property on an Object.\n * 在对象上定义一个无功属性。\n * 更新数据\n * 通过defineProperty的set方法去通知notify()订阅者subscribers有新的值修改\n * 添加观察者 get set方法\n */\n function defineReactive(obj, //对象\n key,//对象的key\n val, //监听的数据 返回的数据\n customSetter, // 日志函数\n shallow //是否要添加__ob__ 属性\n ) {\n //实例化一个主题对象，对象中有空的观察者列表\n var dep = new Dep();\n //获取描述属性\n var property = Object.getOwnPropertyDescriptor(obj, key);\n var _property = Object.getOwnPropertyNames(obj); //获取实力对象属性或者方法，包括定义的描述属性\n console.log(property);\n console.log(_property);\n\n if (property && property.configurable === false) {\n return\n }\n\n // cater for pre-defined getter/setters\n\n var getter = property && property.get;\n console.log('arguments.length=' + arguments.length)\n\n if (!getter && arguments.length === 2) {\n val = obj[key];\n }\n var setter = property && property.set;\n console.log(val)\n //判断value 是否有__ob__ 实例化 dep对象,获取dep对象 为 value添加__ob__ 属性递归把val添加到观察者中 返回 new Observer 实例化的对象\n var childOb = !shallow && observe(val);\n //定义描述\n Object.defineProperty(obj, key, {\n enumerable: true,\n configurable: true,\n get: function reactiveGetter() {\n\n var value = getter ? getter.call(obj) : val;\n if (Dep.target) { //Dep.target 静态标志 标志了Dep添加了Watcher 实例化的对象\n //添加一个dep\n dep.depend();\n if (childOb) { //如果子节点存在也添加一个dep\n childOb.dep.depend();\n if (Array.isArray(value)) { //判断是否是数组 如果是数组\n dependArray(value); //则数组也添加dep\n }\n }\n }\n return value\n },\n set: function reactiveSetter(newVal) {\n var value = getter ? getter.call(obj) : val;\n /* eslint-disable no-self-compare 新旧值比较 如果是一样则不执行了*/\n if (newVal === value || (newVal !== newVal && value !== value)) {\n return\n }\n /* eslint-enable no-self-compare\n * 不是生产环境的情况下\n * */\n if (\"development\" !== 'production' && customSetter) {\n customSetter();\n }\n if (setter) {\n //set 方法 设置新的值\n setter.call(obj, newVal);\n } else {\n //新的值直接给他\n val = newVal;\n }\n console.log(newVal)\n\n //observe 添加 观察者\n childOb = !shallow && observe(newVal);\n //更新数据\n dep.notify();\n }\n });\n }\n\n```\n\n\n\n\n\n\n\n## Depends on collecting Dep\n\n In the vue data get, whoever reads the data will collect it. Therefore, dep is a set. When the data is set, the notify method of each dep is triggered by traversing the dep to update through the view\nThe main function of dep is to act only as a collection, so how do you update the view after collecting the dependencies\nSo you need to define a new Watcher class that will update the view\nEach dependency collected by the dep is actually a Watcher\n\n```\n //主题对象Dep构造函数 主要用于添加发布事件后，用户更新数据的 响应式原理之一函数\n var Dep = function Dep() {\n //uid 初始化为0\n this.id = uid++;\n /* 用来存放Watcher对象的数组 */\n this.subs = [];\n };\n\n Dep.prototype.addSub = function addSub(sub) {\n /* 在subs中添加一个Watcher对象 */\n this.subs.push(sub);\n };\n\n Dep.prototype.removeSub = function removeSub(sub) {\n /*删除 在subs中添加一个Watcher对象 */\n remove(this.subs, sub);\n };\n //this$1.deps[i].depend();\n //为Watcher 添加 为Watcher.newDeps.push(dep); 一个dep对象\n Dep.prototype.depend = function depend() {\n //添加一个dep target 是Watcher dep就是dep对象\n if (Dep.target) {\n //像指令添加依赖项\n Dep.target.addDep(this);\n }\n };\n /* 通知所有Watcher对象更新视图 */\n Dep.prototype.notify = function notify() {\n // stabilize the subscriber list first\n var subs = this.subs.slice();\n for (var i = 0, l = subs.length; i < l; i++) {\n //更新数据\n subs[i].update();\n }\n };\n\n // the current target watcher being evaluated.\n // this is globally unique because there could be only one\n // watcher being evaluated at any time.\n //当前正在评估的目标监视程序。\n //这在全球是独一无二的，因为只有一个\n //观察者在任何时候都被评估。\n Dep.target = null;\n var targetStack = [];\n\n function pushTarget(_target) {\n //target 是Watcher dep就是dep对象\n if (Dep.target) { //静态标志 Dep当前是否有添加了target\n //添加一个pushTarget\n targetStack.push(Dep.target);\n }\n Dep.target = _target;\n }\n\n //\n function popTarget() {\n // 出盏一个pushTarget\n Dep.target = targetStack.pop();\n }\n```\n\n## Data detection Watcher\n\n Watcher's main function is to interface to the Dep notification, and then call the update method to update the view\nThe callback is triggered in the update method, and the callback function is actually the generated render function\n\nUpon calling the render function, the values in the function will get the changed value, so a new vnode will be generated\nAfter the new vnode is generated, it is the patch process. The new vnode is compared with the old vnode. Finally, the vnode after comparison is converted into the actual dom and added to the node to which the template is mounted\nAfter the new template is mounted, delete the old template so that the view is updated\n\n```\n * *观察者分析表达式，收集依赖项，\n *并在表达式值更改时触发回调。\n *这用于$watch() api和指令。\n * 当前vue实例、updateComponent函数、空函数。\n */\n var Watcher = function Watcher(\n vm, //vm dom\n expOrFn, //获取值的函数，或者是更新viwe试图函数\n cb, //回调函数,回调值给回调函数\n options, //参数\n isRenderWatcher//是否渲染过得观察者\n ) {\n console.log('====Watcher====')\n this.vm = vm;\n //是否是已经渲染过得观察者\n if (isRenderWatcher) { //把当前 Watcher 对象赋值给 vm._watcher上\n vm._watcher = this;\n }\n //把观察者添加到队列里面 当前Watcher添加到vue实例上\n vm._watchers.push(this);\n // options\n if (options) { //如果有参数\n this.deep = !!options.deep; //实际\n this.user = !!options.user; //用户\n this.lazy = !!options.lazy; //懒惰 ssr 渲染\n this.sync = !!options.sync; //如果是同步\n } else {\n\n this.deep = this.user = this.lazy = this.sync = false;\n }\n this.cb = cb; //回调函数\n this.id = ++uid$1; // uid for batching uid为批处理 监听者id\n this.active = true; //激活\n this.dirty = this.lazy; // for lazy watchers 对于懒惰的观察者\n this.deps = []; // 观察者队列\n this.newDeps = []; // 新的观察者队列\n // 内容不可重复的数组对象\n this.depIds = new _Set();\n this.newDepIds = new _Set();\n // 把函数变成字符串形式\n this.expression = expOrFn.toString();\n // parse expression for getter\n //getter的解析表达式\n if (typeof expOrFn === 'function') {\n //获取值的函数\n this.getter = expOrFn;\n } else {\n //如果是keepAlive 组件则会走这里\n //path 因该是路由地址\n if (bailRE.test(path)) { // 匹配上 返回 true var bailRE = /[^\\w.$]/; //匹配不是 数字字母下划线 $符号 开头的为true\n return\n }\n\n // //匹配不上 path在已点分割\n // var segments = path.split('.');\n // return function (obj) {\n //\n // for (var i = 0; i < segments.length; i++) {\n // //如果有参数则返回真\n // if (!obj) {\n // return\n // }\n // //将对象中的一个key值 赋值给该对象 相当于 segments 以点拆分的数组做obj 的key\n // obj = obj[segments[i]];\n // }\n // //否则返回一个对象\n // return obj\n // }\n\n //匹配不是 数字字母下划线 $符号 开头的为true\n\n this.getter = parsePath(expOrFn);\n if (!this.getter) { //如果不存在 则给一个空的数组\n this.getter = function () {\n };\n \"development\" !== 'production' && warn(\n \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n 'Watcher only accepts simple dot-delimited paths. ' +\n 'For full control, use a function instead.',\n vm\n );\n }\n }\n this.value = this.lazy ? // lazy为真的的时候才能获取值 这个有是组件才为真\n undefined :\n this.get(); //计算getter，并重新收集依赖项。 获取值\n };\n\n```\n\nget is triggered when the Watcher instance constructor executes\nAfter the get is triggered, the Watcher instance is collected\nupdate is the method that is triggered when a Dep notification is received\nThe run method is called in update\nThe cb callback method is called inside the run method\nThe cb back method is actually the template compile-time render method\n\n\n\n\n\n# Virtual DOM\n\nVirtual DOM in vue actually identifies a dom by defining a Vnode class and adding some dom attributes to the class\n\nThe main effect is to reduce the manipulation of the actual dom to reduce the cost of browser performance\n\n```\n /*\n * 创建标准的vue vnode\n *\n * */\n\n var VNode = function VNode(\n tag, /*当前节点的标签名*/\n data, /*当前节点对应的对象，包含了具体的一些数据信息，是一个VNodeData类型，可以参考VNodeData类型中的数据信息*/\n children, //子节点\n text, //文本\n elm, /*当前节点的dom */\n context, /*编译作用域*/\n componentOptions, /*组件的option选项*/\n asyncFactory/*异步工厂*/) {\n /*当前节点的标签名*/\n this.tag = tag;\n\n /*当前节点对应的对象，包含了具体的一些数据信息，是一个VNodeData类型，可以参考VNodeData类型中的数据信息*/\n this.data = data;\n\n /*当前节点的子节点，是一个数组*/\n this.children = children;\n\n /*当前节点的文本*/\n this.text = text;\n\n /*当前虚拟节点对应的真实dom节点*/\n this.elm = elm;\n\n /*当前节点的名字空间*/\n this.ns = undefined;\n\n /*编译作用域 vm*/\n this.context = context;\n\n this.fnContext = undefined;\n this.fnOptions = undefined;\n this.fnScopeId = undefined;\n\n /*节点的key属性，被当作节点的标志，用以优化*/\n this.key = data && data.key;\n\n /*组件的option选项*/\n this.componentOptions = componentOptions;\n\n /*当前节点对应的组件的实例*/\n this.componentInstance = undefined;\n\n /*当前节点的父节点*/\n this.parent = undefined;\n\n /*简而言之就是是否为原生HTML或只是普通文本，innerHTML的时候为true，textContent的时候为false*/\n this.raw = false;\n\n /*静态节点标志*/\n this.isStatic = false;\n\n /*是否作为跟节点插入*/\n this.isRootInsert = true;\n\n /*是否为注释节点*/\n this.isComment = false;\n\n /*是否为克隆节点*/\n this.isCloned = false;\n\n /*是否有v-once指令*/\n this.isOnce = false;\n\n /*异步工厂*/\n this.asyncFactory = asyncFactory;\n\n this.asyncMeta = undefined;\n this.isAsyncPlaceholder = false;\n };\n```\n\n# diff algorithm\n\npatch, sameVnode, patchVnode, updateChildren these methods\n\nThe entry point is patch and then the sameVnode is called\n\n```\n //sameVnode(oldVnode, vnode)2个节点的基本属性相同，那么就进入了2个节点的diff过程。\n function sameVnode(a, b) {\n return (\n\n a.key === b.key && ( //如果a的key 等于b的key\n (\n\n a.tag === b.tag && // 如果a的tag 等于b的tag\n a.isComment === b.isComment && // 如果a和b 都是注释节点\n isDef(a.data) === isDef(b.data) && //如果a.data 和 b.data 都定义后，是组件，或者是都含有tag属性\n sameInputType(a, b) //相同的输入类型。判断a和b的属性是否相同\n ) || (\n isTrue(a.isAsyncPlaceholder) && //判断是否是异步的\n a.asyncFactory === b.asyncFactory &&\n isUndef(b.asyncFactory.error)\n )\n )\n )\n }\n```\n\nIf the sameVnode condition is valid, enter the patchVnode method.\n\nThe patchVnode method is mainly used to add and delete vnodes and update key. Then determine when neither virtual dom is empty and they are not equal oldCh! == ch enters the updateChildren diff update algorithm.\n\n```\n // 对比 虚拟dom\n function patchVnode(\n oldVnode, // 旧的虚拟dom\n vnode, // 新的虚拟dom\n insertedVnodeQueue, // 删除虚拟dom队列\n removeOnly\n ) {\n if (oldVnode === vnode) { //如果他们相等\n return\n }\n\n var elm = vnode.elm = oldVnode.elm; //获取真实的dom\n\n // 判断是否有isAsyncPlaceholder 属性\n if (isTrue(oldVnode.isAsyncPlaceholder)) {\n //判断数据 是否不等于 undefined或者null\n if (isDef(vnode.asyncFactory.resolved)) {\n // ssr 渲染\n hydrate(oldVnode.elm, vnode, insertedVnodeQueue);\n } else {\n vnode.isAsyncPlaceholder = true;\n }\n return\n }\n\n // reuse element for static trees.\n // note we only do this if the vnode is cloned -\n // if the new node is not cloned it means the render functions have been\n // reset by the hot-reload-api and we need to do a proper re-render.\n //为静态树重用元素。\n //注意，只有当vnode被克隆时，我们才这样做\n //如果新节点没有克隆，则表示渲染函数已经克隆\n //由hot-reload api重置，我们需要做一个适当的重新渲染。\n if (isTrue(vnode.isStatic) &&\n isTrue(oldVnode.isStatic) &&\n vnode.key === oldVnode.key &&\n (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))\n ) {\n vnode.componentInstance = oldVnode.componentInstance;\n return\n }\n\n var i;\n var data = vnode.data;\n // 钩子函数\n if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n i(oldVnode, vnode);\n }\n\n var oldCh = oldVnode.children;\n var ch = vnode.children;\n //循环组件实例 是否定义有 tag标签\n if (isDef(data) && isPatchable(vnode)) {\n // 触发钩子函数 更新钩子函数\n for (i = 0; i < cbs.update.length; ++i) {\n cbs.update[i](oldVnode, vnode);\n }\n // 触发钩子函数\n if (isDef(i = data.hook) && isDef(i = i.update)) {\n i(oldVnode, vnode);\n }\n }\n\n //如果是文本虚拟dom\n if (isUndef(vnode.text)) {\n // 两个虚拟dom都存在\n if (isDef(oldCh) && isDef(ch)) {\n // 如果他们不相等\n if (oldCh !== ch) {\n // diff算法更新\n updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);\n }\n } else if (isDef(ch)) { // 如果是有新的虚拟dom\n // 如果是文本虚拟dom 则 设置 空\n if (isDef(oldVnode.text)) {\n nodeOps.setTextContent(elm, '');\n }\n // 添加 vnode\n addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n } else if (isDef(oldCh)) { // 如果旧的有 新的虚拟dom没有则删除 虚拟dom\n removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n } else if (isDef(oldVnode.text)) { // 如果是文本虚拟dom则设置文本\n nodeOps.setTextContent(elm, '');\n }\n\n\n } else if (oldVnode.text !== vnode.text) {\n // 如果新旧的文本不相同则设置文本\n nodeOps.setTextContent(elm, vnode.text);\n }\n if (isDef(data)) {\n // 触发钩子\n if (isDef(i = data.hook) && isDef(i = i.postpatch)) {\n i(oldVnode, vnode);\n }\n }\n }\n\n```\n\n\n\n# ddif algorithm updateChildren\n\ndiif algorithm, the diff algorithm of vue2 is a depth-first algorithm for traversal, and then the comparison algorithm compares the old vnode with the new vnode, first compares their basic attributes, such as key labels, etc. If they are the same, the diff algorithm compares the old Vnode with the new Vnode, and then has four pointer indexes. Two new vnode start Pointers and two new vnode end Pointers, two old vnode start Pointers and old vnode end Pointers. Then first determine whether the vnode is empty, if it is empty, move to the center of the start pointer ++ end pointer --. Then, after comparing the two sides, cross-compare until the same vnode is not found. If there are more Vnodes, delete them; if there are fewer, add them. After comparing, call patchVnode to add or delete virtual dom. Then if there are Vnodes that are not the same, updateChildren is called, so deep recursion, also called depth-first search, is done, and then the child Vnodes are not updated to the real dom.\n\n```\n\n // ddif 算法\n function updateChildren(\n parentElm, // 父亲dom\n oldCh, // 旧的虚拟dom\n newCh, // 新的虚拟dom\n insertedVnodeQueue,\n removeOnly\n ) {\n var oldStartIdx = 0; // 旧的虚拟dom开始指针 \n var newStartIdx = 0; // 新的虚拟dom开始指针 \n var oldEndIdx = oldCh.length - 1; // 旧的虚拟dom结束指针 \n var newEndIdx = newCh.length - 1;// 新的虚拟dom结束指针 \n\n var oldStartVnode = oldCh[0]; // 旧的虚拟dom开始节点\n var newStartVnode = newCh[0]; // 新的虚拟dom开始节点\n\n var oldEndVnode = oldCh[oldEndIdx]; // 旧的虚拟dom结束节点\n var newEndVnode = newCh[newEndIdx];// 新的虚拟dom结束节点\n\n var oldKeyToIdx, idxInOld, vnodeToMove, refElm;\n\n // removeOnly is a special flag used only by \n // to ensure removed elements stay in correct relative positions\n // during leaving transitions\n var canMove = !removeOnly;\n\n {\n // 检查同一个兄弟节点是否有重复的key，如果有则发出警告日志\n checkDuplicateKeys(newCh);\n }\n\n /*\n diff 算法开始\n 这里diff算法其实就是\n\n */\n while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n\n if (isUndef(oldStartVnode)) {\n // 如果旧的开始节点不存在或者为空\n // 如果旧的开始节点指针往中间偏移\n oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n } else if (isUndef(oldEndVnode)) {\n // 如果旧的结束节点不存在或者为空\n // 如果旧的结束节点指针往中间偏移\n oldEndVnode = oldCh[--oldEndIdx];\n\n } else if (sameVnode(oldStartVnode, newStartVnode)) { //sameVnode(oldVnode, vnode)2个节点的基本属性相同，那么就进入了2个节点的diff过程。\n\n\n\n // 在对比下虚拟dom \n patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n\n //开始指针 两个都往中间偏移\n oldStartVnode = oldCh[++oldStartIdx];\n newStartVnode = newCh[++newStartIdx];\n\n } else if (sameVnode(oldEndVnode, newEndVnode)) { //sameVnode(oldVnode, vnode)2个节点的基本属性相同，那么就进入了2个节点的diff过程。\n // 在对比下虚拟dom \n patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n // 结束指针 两个都往中间偏移\n oldEndVnode = oldCh[--oldEndIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right //sameVnode(oldVnode, vnode)2个节点的基本属性相同，那么就进入了2个节点的diff过程。\n\n // 交叉对比 深度优先算法入口\n patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n // 交叉对比\n canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n\n oldStartVnode = oldCh[++oldStartIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n // 交叉对比\n patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n // 交叉对比\n canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n oldEndVnode = oldCh[--oldEndIdx];\n newStartVnode = newCh[++newStartIdx];\n } else {\n // 如果没有key 则给塔新的key\n if (isUndef(oldKeyToIdx)) {\n\n // 创建key 如果没有key 则用索引作为key\n oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n }\n \n // 获取 旧的vnode key\n idxInOld = isDef(newStartVnode.key)\n ? oldKeyToIdx[newStartVnode.key]\n // 查找旧的vnode key\n : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);\n // 如果旧的 vnode key 未定义则创建新的真实dom\n if (isUndef(idxInOld)) { // New element\n //创建真实 dom 节点\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);\n } else {\n\n vnodeToMove = oldCh[idxInOld];\n if (sameVnode(vnodeToMove, newStartVnode)) {\n // 对比虚拟dom\n patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue);\n \n oldCh[idxInOld] = undefined;\n // 真实节点交换\n canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);\n } else {\n // same key but different element. treat as new element\n // 创建真实dom\n createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);\n }\n }\n newStartVnode = newCh[++newStartIdx];\n }\n }\n if (oldStartIdx > oldEndIdx) {\n refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n // 添加虚拟dom\n addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n } else if (newStartIdx > newEndIdx) {\n // 删除虚拟dom\n removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n }\n }\n\n```\n\nSpecifically look at my source code and flow chart, here the text does not describe so much, the flow chart is the following network disk, source code is vue.js, basically every line has comments\n\nlink：https://pan.baidu.com/s/10IxV6mQ2TIwkRACKu2T0ng \npassword：1fnu \n\nThe above vue.js is my vue.js based on each line of vue source code with comments, and the other files are the vue.js source code small demo that I pulled out when I looked at Vue.js source code. If you feel good, please move your little finger to help me click a satr, your support is my motivation，thank you\n\n\n\nAuthor: Yao Guanshou\n\n\n\n\n\nI've been unemployed recently and I'm looking for a front-end development job. I hope any friends whose companies are recruiting can contact me. Thank you. The location can be Shenzhen or remote. Front-end architecture, senior front-end development, and team leader positions are all fine. My wechat: 18529531779, helloTalk account @18529531779, email: 281113270@qq.com, thank you.\n" }, { "path": "Reflect.ownKeys.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "Set.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "StrictChecking.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "String方法之fromCharCode()和charCodeAt().html", "content": "\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "Symbol.html", "content": "\r\n\r\n\r\n\t\r\n\t\t \r\n\r\n\t\r\n\r\n \r\n\t\r\n\t \r\n\r\n\t\r\n\r\n" }, { "path": "Symbol1.html", "content": "\r\n\r\n\r\n\t\r\n\t\t \r\n\r\n\t\r\n\r\n \r\n\t\r\n\t \r\n\r\n\t\r\n\r\n" }, { "path": "Symbol2.html", "content": "\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "Symbol3.html", "content": "\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "_Set.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "__proto__.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "_c.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "add.txt", "content": "" }, { "path": "add1.txt", "content": "add111111111111111111111" }, { "path": "advance.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "appear.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "argMatch.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "arrObj.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "array.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "attribute.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "bailRE.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "buildRegex.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "callbacks.slice(0).html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "camelize.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "charCodeAt.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "classify.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "classifyRE.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n \r\n\r\n" }, { "path": "classifyRE1.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n \r\n\r\n" }, { "path": "comments.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n
    \r\n
    \r\n \r\n

    Hello Vue!

    \r\n
    \r\n

    渲染后HTML:

    \r\n \r\n\r\n\r\n\r\n" }, { "path": "contextmenu.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n \r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "createElementNS.html", "content": "\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "ddf.html", "content": "

    Vue mvvm simple model

    \r\n
    \r\n

    \r\n

    \r\n \r\n
    \r\n" }, { "path": "def.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "defineProperty.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "exec.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "exex.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "forIteratorRE.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "formatComponentName.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "genCheckboxModel.js", "content": "var $$a = item.selected,\r\n $$el = $event.target,\r\n $$c = $$el.checked ? (true) : (false);\r\nif (Array.isArray($$a)) {\r\n var $$v = \"index\",\r\n $$i = _i($$a, $$v);\r\n if ($$el.checked) {\r\n $$i < 0 && ($set(item, \"selected\", $$a.concat([$$v])))\r\n } else {\r\n $$i > -1 && ($set(item, \"selected\", $$a.slice(0, $$i).concat($$a.slice($$i + 1))))\r\n }\r\n} else {\r\n $set(item, \"selected\", $$c)\r\n}" }, { "path": "genStaticKeys.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "getComputedStyle.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n
    dummy
    \r\n
    \r\n\r\n\r\n" }, { "path": "getHookArgumentsLength.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "getOwnPropertyNames.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "getShouldDecode.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "getTransitionInfo.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n
    \r\n\r\n
    \r\n \r\n\r\n" }, { "path": "getTransitionInfo获取css3 Transition 信息.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n
    \r\n\r\n
    \r\n
    \r\n\r\n
    \r\n \r\n\r\n" }, { "path": "getTransitionInfo获取css3 Transition 信息2.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n
    \r\n
    1
    \r\n
    \r\n \r\n\r\n" }, { "path": "getType.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n\r\n" }, { "path": "getTypeIndex.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "hookRE.html", "content": "\r\n \r\n \r\n \r\n \r\n \r\n \r\n" }, { "path": "hyphenate.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "hyphenateRE.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "ieNSBug.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "index.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n \r\n\r\n
    \r\n

    Hello App!

    \r\n

    \r\n \r\n \r\n \r\n Go to Foo\r\n Go to Bar\r\n

    \r\n \r\n \r\n \r\n
    \r\n\r\n\r\n\r\n" }, { "path": "indexOf.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "inline-template.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
    \r\n header\r\n \r\n foot\r\n
    \r\n
    \r\n header\r\n \r\n
    \r\n

    These are compiled as the component's own template

    \r\n

    Not parent's transclusion content

    \r\n

    {{message}}

    \r\n
    \r\n     \r\n foot\r\n
    \r\n\r\n\r\n\r\n" }, { "path": "is.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n\r\n
    \r\n \r\n \r\n\r\n \r\n\r\n
    \r\n

    is 与 :is 的用法 ,区别如下：

    \r\n
    \r\n
    \r\n
    \r\n
    \r\n\r\n\r\n\r\n" }, { "path": "isReserved.html", "content": "\r\n\r\n \r\n\r\n\r\n\r\n\r\n" }, { "path": "isUnknownElement.html", "content": "\r\n\r\n \r\n \r\n Title\r\n \r\n \r\n \r\n \r\n\r\n" }, { "path": "javascript 匿名函数自执行调用.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n" }, { "path": "js 字符串截取方法.html", "content": "\r\n\r\n \r\n\r\n\r\n\r\n\r\n" }, { "path": "js 数组截取.html", "content": "\r\n\r\n \r\n\r\n\r\n\r\n\r\n" }, { "path": "js_watch.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "js_watch1.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "js中with、this的用法.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "js命令者.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "js如何判断数组含有某值，in，includes，inArray，indexOf方案对比.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "lastIndexOf.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "length.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "length0.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "modifierRE.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "mount.html", "content": "\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "new Array(val).html", "content": "\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "new Proxy.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "newFunction.html", "content": "\r\n\r\n\r\n\r\n\r\n\r\n new function 用来检测js错误 可以替代eval() 字符串转js代码检查 字符串编译解析成js指向Function，防止有些前端编译工具报错\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "nodeType.html", "content": "\r\n\r\n\r\n

    请点击按钮来获得 body 元素子节点的节点类型。

    \r\n\r\n\r\n\r\n\r\n\r\n

    注释：元素中的空格被视作文本，而文本被视作文本节点。

    \r\n\r\n\r\n\r\n" }, { "path": "normalizeArrayChildren.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "object.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "object.keys.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "once.html", "content": "\r\n\r\n\r\n \r\n Title\r\n \r\n\r\n\r\n
    \r\n \r\n
    \r\n
    \r\n {{ message }}\r\n This will never change: {{message}}\r\n This will never change: {{message}}\r\n\r\n
    \r\n\r\n\r\n\r\n\r\n" }, { "path": "parseFilters.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "parseModel.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "parseModifiers.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "parsePath.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "parseStyleText.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "parseText.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "performance.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "prohibitedKeywordRE.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "promise.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "proxy.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "repeat.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "requestAnimationFrame.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n
    \r\n\r\n
    \r\n \r\n\r\n" }, { "path": "requestAnimationFrame2.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n
    \r\n\r\n
    \r\n \r\n\r\n" }, { "path": "setget.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "simpleCheckRE.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "slice splice.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "split.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "startTagClose.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "stopImmediatePropagation.html", "content": "\r\n\r\n\r\nTitle\r\n\r\n \r\n\r\n\r\n
    \r\n

    paragraph

    \r\n
    \r\n\r\n\r\n" }, { "path": "stripStringRE.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "toUnicodeFun.html", "content": "\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n" }, { "path": "transformModel.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n \r\n\r\n" }, { "path": "transition.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "unaryOperatorsRE.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "unaryOperatorsRE匹配字符串前一个字符串是什么.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "unaryOperatorsRE匹配字符串前一个字符串是什么2.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "vm._watcher === watcher.html", "content": "\r\n\r\n\r\n \r\n Title\r\n\r\n\r\n\r\n\r\n" }, { "path": "vue.js", "content": "/*!\n * Vue.js v2.5.16\n * (c) 2014-2018 Evan You\n * Released under the MIT License.\n * development 开发\n * production 生产\n /*\n * 兼容 amd cmd 模块写法\n * */\n(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n typeof define === 'function' && define.amd ? define(factory) :\n (global.Vue = factory());\n}(this, (function () {\n 'use strict';\n\n /* */\n //Object.freeze()阻止修改现有属性的特性和值，并阻止添加新属性。\n var emptyObject = Object.freeze({});\n\n // these helpers produces better vm code in JS engines due to their\n // explicitness and function inlining\n // these helpers produces better vm code in JS engines due to their\n // explicitness and function inlining\n //判断数据 是否是undefined或者null\n function isUndef(v) {\n return v === undefined || v === null\n }\n\n //判断数据 是否不等于 undefined或者null\n function isDef(v) {\n return v !== undefined && v !== null\n }\n\n //判断是否真的等于true\n function isTrue(v) {\n return v === true\n }\n\n // 判断是否是false\n function isFalse(v) {\n\n return v === false\n }\n\n /**\n * Check if value is primitive\n * //判断数据类型是否是string，number，symbol，boolean\n */\n function isPrimitive(value) {\n //判断数据类型是否是string，number，symbol，boolean\n return (\n typeof value === 'string' ||\n typeof value === 'number' ||\n // $flow-disable-line\n typeof value === 'symbol' ||\n typeof value === 'boolean'\n )\n }\n\n /**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\n function isObject(obj) {\n //判断是否是对象\n return obj !== null && typeof obj === 'object'\n }\n\n /**\n * Get the raw type string of a value e.g. [object Object]\n */\n //获取toString 简写\n var _toString = Object.prototype.toString;\n\n function toRawType(value) {\n //类型判断 返会Array ，Function，String,Object,Re 等\n return _toString.call(value).slice(8, -1)\n }\n\n /**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\n function isPlainObject(obj) {\n //判断是否是对象\n return _toString.call(obj) === '[object Object]'\n }\n\n function isRegExp(v) {\n //判断是否是正则对象\n return _toString.call(v) === '[object RegExp]'\n }\n\n /**\n * Check if val is a valid array index.\n */\n /**\n * Check if val is a valid array index.\n * 检查VAL是否是有效的数组索引。\n */\n function isValidArrayIndex(val) {\n //isFinite 检测是否是数据\n //Math.floor 向下取整\n var n = parseFloat(String(val));\n //isFinite 如果 number 是有限数字（或可转换为有限数字），那么返回 true。否则，如果 number 是 NaN（非数字），或者是正、负无穷大的数，则返回 false。\n return n >= 0 && Math.floor(n) === n && isFinite(val)\n }\n\n /**\n * Convert a value to a string that is actually rendered.\n */\n function toString(val) {\n\n //将对象或者其他基本数据 变成一个 字符串\n return val == null\n ? ''\n : typeof val === 'object'\n ? JSON.stringify(val, null, 2)\n : String(val)\n }\n\n /**\n * Convert a input value to a number for persistence.\n * If the conversion fails, return original string.\n */\n function toNumber(val) {\n //字符串转数字，如果失败则返回字符串\n var n = parseFloat(val);\n return isNaN(n) ? val : n\n }\n\n /**\n * Make a map and return a function for checking if a key\n * is in that map.\n *\n * //map 对象中的[name1,name2,name3,name4] 变成这样的map{name1:true,name2:true,name3:true,name4:true}\n * 并且传进一个key值取值，这里用到策略者模式\n */\n function makeMap(str,\n expectsLowerCase) {\n var map = Object.create(null); //创建一个新的对象\n var list = str.split(','); //按字符串,分割\n for (var i = 0; i < list.length; i++) {\n map[list[i]] = true; //map 对象中的[name1,name2,name3,name4] 变成这样的map{name1:true,name2:true,name3:true,name4:true}\n }\n return expectsLowerCase\n ? function (val) {\n return map[val.toLowerCase()];\n } //返回一个柯里化函数 toLowerCase转换成小写\n : function (val) {\n return map[val];\n } //返回一个柯里化函数 并且把map中添加一个 属性建\n }\n\n /**\n * Check if a tag is a built-in tag.\n * 检查标记是否为内置标记。\n */\n var isBuiltInTag = makeMap('slot,component', true);\n\n /**\n * Check if a attribute is a reserved attribute.\n * 检查属性是否为保留属性。\n * isReservedAttribute=function(vale){ map{key:true,ref:true,slot-scope:true,is:true,vaule:undefined} }\n */\n var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');\n\n /**\n * Remove an item from an array\n * //删除数组\n */\n function remove(arr, item) {\n if (arr.length) {\n var index = arr.indexOf(item);\n if (index > -1) {\n return arr.splice(index, 1)\n }\n }\n }\n\n /**\n * Check whether the object has the property.\n *检查对象属性是否是实例化还是原型上面的\n */\n var hasOwnProperty = Object.prototype.hasOwnProperty;\n\n function hasOwn(obj, key) {\n return hasOwnProperty.call(obj, key)\n }\n\n /**\n * Create a cached version of a pure function.\n */\n /**\n * Create a cached version of a pure function.\n * 创建纯函数的缓存版本。\n * 创建一个函数，缓存，再return 返回柯里化函数\n * 闭包用法\n */\n /***********************************************************************************************\n *函数名 ：cached\n *函数功能描述 ： 创建纯函数的缓存版本。 创建一个函数，缓存，再return 返回柯里化函数 闭包用法\n *函数参数 ： fn 函数\n *函数返回值 ： fn\n *作者 ：\n *函数创建日期 ：\n *函数修改日期 ：\n *修改人 ：\n *修改原因 ：\n *版本 ：\n *历史版本 ：\n ***********************************************************************************************/\n\n /*\n * var aFn = cached(function(string){\n *\n * return string\n * })\n * aFn(string1);\n * aFn(string2);\n * aFn(string);\n * aFn(string1);\n * aFn(string2);\n *\n * aFn 函数会多次调用 里面就能体现了\n * 用对象去缓存记录函数\n * */\n\n function cached(fn) {\n var cache = Object.create(null);\n return (function cachedFn(str) {\n var hit = cache[str];\n return hit || (cache[str] = fn(str))\n })\n }\n\n /**\n * Camelize a hyphen-delimited string.\n * 用连字符分隔的字符串。\n * camelize = cachedFn(str)=>{ var hit = cache[str];\n return hit || (cache[str] = fn(str))}\n\n 调用一个camelize 存一个建进来 调用两次 如果建一样就返回 hit\n\n 横线-的转换成驼峰写法\n 可以让这样的的属性 v-model 变成 vModel\n */\n var camelizeRE = /-(\\w)/g;\n var camelize = cached(function (str) {\n return str.replace(camelizeRE, function (_, c) {\n return c ? c.toUpperCase() : '';\n })\n });\n\n /**\n * Capitalize a string. 将首字母变成大写。\n */\n var capitalize = cached(function (str) {\n return str.charAt(0).toUpperCase() + str.slice(1)\n });\n\n /**\n * Hyphenate a camelCase string.\n * \\B的用法\n \\B是非单词分界符，即可以查出是否包含某个字，如“ABCDEFGHIJK”中是否包含“BCDEFGHIJK”这个字。\n */\n var hyphenateRE = /\\B([A-Z])/g;\n var hyphenate = cached(function (str) {\n //大写字母，加完减号又转成小写了 比如把驼峰 aBc 变成了 a-bc\n //匹配大写字母并且两面不是空白的 替换成 '-' + '字母' 在全部转换成小写\n return str.replace(hyphenateRE, '-$1').toLowerCase();\n });\n\n /**\n * Simple bind polyfill for environments that do not support it... e.g.\n * PhantomJS 1.x. Technically we don't need this anymore since native bind is\n * now more performant in most browsers, but removing it would be breaking for\n * code that was able to run in PhantomJS 1.x, so this must be kept for\n * backwards compatibility.\n * 改变this 上下文\n * 执行方式\n */\n\n /* istanbul ignore next */\n //绑定事件 并且改变上下文指向\n function polyfillBind(fn, ctx) {\n function boundFn(a) {\n var l = arguments.length;\n return l\n ? l > 1\n ? fn.apply(ctx, arguments)\n : fn.call(ctx, a)\n : fn.call(ctx)\n }\n\n boundFn._length = fn.length;\n return boundFn\n }\n\n //执行方式\n function nativeBind(fn, ctx) {\n return fn.bind(ctx)\n }\n\n //bing 改变this上下文\n var bind = Function.prototype.bind\n ? nativeBind\n : polyfillBind;\n\n /**\n * Convert an Array-like object to a real Array.\n * 将假的数组转换成真的数组\n */\n function toArray(list, start) {\n start = start || 0;\n var i = list.length - start;\n var ret = new Array(i);\n while (i--) {\n ret[i] = list[i + start];\n }\n return ret\n }\n\n /**\n * Mix properties into target object.\n * * 浅拷贝\n */\n /***********************************************************************************************\n *函数名 ：extend\n *函数功能描述 ： 浅拷贝\n *函数参数 ： to 超类， _from 子类\n *函数返回值 ： 合并类\n *作者 ：\n *函数创建日期 ：\n *函数修改日期 ：\n *修改人 ：\n *修改原因 ：\n *版本 ：\n *历史版本 ：\n ***********************************************************************************************/\n //对象浅拷贝，参数（to, _from）循环_from的值，会覆盖掉to的值\n function extend(to, _from) {\n for (var key in _from) {\n to[key] = _from[key];\n }\n return to\n }\n\n /**\n * Merge an Array of Objects into a single Object.\n *\n */\n /***********************************************************************************************\n *函数名 ：toObject\n *函数功能描述 ： 和并对象数组合并成一个对象\n *函数参数 ： arr 数组对象类\n *函数返回值 ：\n *作者 ：\n *函数创建日期 ：\n *函数修改日期 ：\n *修改人 ：\n *修改原因 ：\n *版本 ：\n *历史版本 ：\n ***********************************************************************************************/\n\n function toObject(arr) {\n var res = {};\n for (var i = 0; i < arr.length; i++) {\n if (arr[i]) {\n extend(res, arr[i]);\n }\n }\n return res\n }\n\n /**\n * Perform no operation.\n * Stubbing args to make Flow happy without leaving useless transpiled code\n * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)\n\n */\n function noop(a, b, c) {\n }\n\n /**\n * Always return false.\n * 返回假的\n */\n var no = function (a, b, c) {\n return false;\n };\n\n /**\n * Return same value\n *返回相同值\n */\n var identity = function (_) {\n return _;\n };\n\n /**\n * Generate a static keys string from compiler modules.\n *\n * [{ staticKeys:1},{staticKeys:2},{staticKeys:3}]\n * 连接数组对象中的 staticKeys key值，连接成一个字符串 str=‘1,2,3’\n */\n function genStaticKeys(modules) {\n return modules.reduce(\n function (keys, m) {\n //累加staticKeys的值变成数组\n return keys.concat(m.staticKeys || [])\n },\n []\n ).join(',') //转换成字符串\n }\n\n /**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n * 检测a和b的数据类型，是否是不是数组或者对象，对象的key长度一样即可，数组长度一样即可\n */\n function looseEqual(a, b) {\n if (a === b) {\n return true\n } //如果a和b是完全相等 则true\n var isObjectA = isObject(a);\n var isObjectB = isObject(b);\n if (isObjectA && isObjectB) { //如果a和都是对象则让下走\n try {\n var isArrayA = Array.isArray(a);\n var isArrayB = Array.isArray(b);\n if (isArrayA && isArrayB) { //如果a和b都是数组\n // every 条件判断\n return a.length === b.length && a.every(function (e, i) { //如果a长度和b长度一样的时候\n return looseEqual(e, b[i]) //递归\n })\n } else if (!isArrayA && !isArrayB) { //或者a和b都不是数组\n var keysA = Object.keys(a); // 获取到a的key值 变成一个数组\n var keysB = Object.keys(b); // 获取到b的key值 变成一个数组\n //他们的对象key值长度是一样的时候 则加载every 条件函数\n return keysA.length === keysB.length && keysA.every(function (key) {\n //递归 a和b的值\n return looseEqual(a[key], b[key])\n })\n } else {\n //如果不是对象跳槽循环\n /* istanbul ignore next */\n return false\n }\n } catch (e) {\n //如果不是对象跳槽循环\n /* istanbul ignore next */\n return false\n }\n } else if (!isObjectA && !isObjectB) { //b和a 都不是对象的时候\n //把a和b变成字符串，判断他们是否相同\n return String(a) === String(b)\n } else {\n return false\n }\n }\n\n // 判断 arr数组中的数组 是否和val相等。\n // 或者 arr数组中的对象，或者对象数组 是否和val 相等\n function looseIndexOf(arr, val) {\n for (var i = 0; i < arr.length; i++) {\n if (looseEqual(arr[i], val)) {\n return i\n }\n }\n return -1\n }\n\n /**\n * Ensure a function is called only once.\n * 确保该函数只调用一次 闭包函数\n */\n function once(fn) {\n var called = false;\n return function () {\n if (!called) {\n called = true;\n fn.apply(this, arguments);\n }\n }\n }\n\n //ssr标记属性\n var SSR_ATTR = 'data-server-rendered';\n\n var ASSET_TYPES = [\n 'component', //组建指令\n 'directive', //定义指令 指令\n 'filter' //过滤器指令\n ];\n\n\n var LIFECYCLE_HOOKS = [\n 'beforeCreate', // 生命周期 开始实例化 vue 指令\n 'created', //生命周期 结束实例化完 vue 指令\n 'beforeMount', //生命周期 开始渲染虚拟dom ，挂载event 事件 指令\n 'mounted', //生命周期 渲染虚拟dom ，挂载event 事件 完 指令\n 'beforeUpdate', //生命周期 开始更新view 数据指令\n 'updated', //生命周期 结束更新view 数据指令\n 'beforeDestroy', //生命周期 开始销毁 new 实例 指令\n 'destroyed', //生命周期 结束销毁 new 实例 指令\n 'activated', //keep-alive组件激活时调用。\n 'deactivated', //deactivated keep-alive组件停用时调用。\n 'errorCaptured' // 具有此钩子的组件捕获其子组件树（不包括其自身）中的所有错误（不包括在异步回调中调用的那些）。\n ];\n /* */\n\n var config = ({\n /**\n * Option merge strategies (used in core/util/options)\n */\n // $flow-disable-line\n //合并对象 策略\n optionMergeStrategies: Object.create(null),\n\n /**\n * Whether to suppress warnings.\n * * 是否禁止警告。\n */\n silent: false,\n\n /**\n * Show production mode tip message on boot?\n * 在引导时显示生产模式提示消息？\n * webpack打包判断执行环境是不是生产环境，如果是生产环境会压缩并且没有提示警告之类的东西\n */\n productionTip: \"development\" !== 'production',\n /**\n * Whether to enable devtools\n * 是否启用DevTools\n */\n devtools: \"development\" !== 'production',\n\n /**\n * Whether to record perf\n * 是否记录PERF\n */\n performance: false,\n\n /**\n * Error handler for watcher errors\n *监视器错误的错误处理程序\n */\n errorHandler: null,\n\n /**\n * Warn handler for watcher warns\n * 观察加警告处理。\n */\n warnHandler: null,\n\n /**\n * Ignore certain custom elements\n * 忽略某些自定义元素\n */\n ignoredElements: [],\n\n /**\n * Custom user key aliases for v-on\n * 用于V-on的自定义用户密钥别名 键盘码\n */\n // $flow-disable-line\n keyCodes: Object.create(null),\n\n /**\n * Check if a tag is reserved so that it cannot be registered as a\n * component. This is platform-dependent and may be overwritten.\n * 检查是否保留了一个标签，使其不能注册为组件。这是平台相关的，可能会被覆盖。\n */\n isReservedTag: no,\n\n /**\n * Check if an attribute is reserved so that it cannot be used as a component\n * prop. This is platform-dependent and may be overwritten.\n * 检查属性是否被保留，使其不能用作组件支持。这是平台相关的，可能会被覆盖。\n */\n isReservedAttr: no,\n\n /**\n * Check if a tag is an unknown element.\n * Platform-dependent.\n * Check if a tag is an unknown element. Platform-dependent.\n * 检查标签是否为未知元素依赖于平台的检查，如果标签是未知元素。平台相关的\n *\n */\n isUnknownElement: no,\n\n /**\n * Get the namespace of an element\n * 获取元素的命名空间\n */\n getTagNamespace: noop,\n\n /**\n * Parse the real tag name for the specific platform.\n * 解析真实的标签平台\n */\n parsePlatformTagName: identity,\n\n /**\n * Check if an attribute must be bound using property, e.g. value\n * Platform-dependent.\n * 检查属性是否必须使用属性绑定，例如依赖于依赖于平台的属性。\n */\n mustUseProp: no,\n\n /**\n * Exposed for legacy reasons\n * 因遗产原因暴露\n * 声明周期对象\n */\n _lifecycleHooks: LIFECYCLE_HOOKS\n })\n\n /* */\n\n /**\n * Check if a string starts with $ or _\n * 检查一个字符串是否以$或者_开头\n */\n function isReserved(str) {\n var c = (str + '').charCodeAt(0);\n return c === 0x24 || c === 0x5F\n }\n\n /**\n * Define a property.\n * 用defineProperty 定义属性\n * 详细地址 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty\n 第一个参数是对象\n 第二个是key\n 第三个是vue\n 第四个是 是否可以枚举\n */\n function def(obj, key, val, enumerable) {\n\n Object.defineProperty(obj, key, {\n value: val, //值\n enumerable: !!enumerable, //定义了对象的属性是否可以在 for...in 循环和 Object.keys() 中被枚举。\n writable: true, //可以 改写 value\n configurable: true //configurable特性表示对象的属性是否可以被删除，以及除writable特性外的其他特性是否可以被修改。\n });\n }\n\n\n /**\n * Parse simple path.\n * 解析。\n */\n var bailRE = /[^\\w.$]/; //匹配不是 数字字母下划线 $符号 开头的为true\n\n function parsePath(path) {\n console.log(path)\n\n if (bailRE.test(path)) { //匹配上 返回 true\n return\n }\n //匹配不上 path在已点分割\n var segments = path.split('.');\n return function (obj) {\n\n for (var i = 0; i < segments.length; i++) {\n //如果没有参数则返回\n if (!obj) {\n return\n }\n //将对象中的一个key值 赋值给该对象 相当于 obj = obj[segments[segments.length-1]];\n obj = obj[segments[i]];\n }\n //否则返回一个对象\n return obj\n }\n }\n\n /* */\n\n // can we use __proto__?\n var hasProto = '__proto__' in {};\n\n // Browser environment sniffing\n //判断设备和浏览器\n var inBrowser = typeof window !== 'undefined';\n\n //如果不是浏览器\n var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform; //weex 环境 一个 vue做app包的框架\n var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();//weex 环境 一个 vue做app包的框架\n\n //window.navigator.userAgent属性包含了浏览器类型、版本、操作系统类型、浏览器引擎类型等信息，通过这个属性来判断浏览器类型\n var UA = inBrowser && window.navigator.userAgent.toLowerCase(); //获取浏览器\n var isIE = UA && /msie|trident/.test(UA); //ie\n var isIE9 = UA && UA.indexOf('msie 9.0') > 0; //ie9\n var isEdge = UA && UA.indexOf('edge/') > 0; //ie10 以上\n var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android'); //安卓\n var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios'); //ios\n var isChrome = UA && /chrome\\/\\d+/.test(UA) && !isEdge; //谷歌浏览器\n\n // Firefox has a \"watch\" function on Object.prototype...\n var nativeWatch = ({}).watch;\n\n //兼容火狐浏览器写法\n var supportsPassive = false;\n if (inBrowser) {\n try {\n var opts = {};\n Object.defineProperty(opts, 'passive', ({\n get: function get() {\n /* istanbul ignore next */\n supportsPassive = true;\n }\n })); // https://github.com/facebook/flow/issues/285\n window.addEventListener('test-passive', null, opts);\n } catch (e) {\n }\n }\n\n // this needs to be lazy-evaled because vue may be required before\n // vue-server-renderer can set VUE_ENV\n //vue 服务器渲染 可以设置 VUE_ENV\n var _isServer;\n //判断是不是node 服务器环境\n var isServerRendering = function () {\n if (_isServer === undefined) {\n /* istanbul ignore if */\n //如果不是浏览器 并且global 对象存在，那么有可能是node 脚本\n if (!inBrowser && typeof global !== 'undefined') {\n //\n // detect presence of vue-server-renderer and avoid\n // Webpack shimming the process\n //_isServer 设置是服务器渲染\n _isServer = global['process'].env.VUE_ENV === 'server';\n } else {\n _isServer = false;\n }\n }\n return _isServer\n };\n\n // detect devtools\n //检测开发者工具。\n var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n /* istanbul ignore next */\n function isNative(Ctor) {\n //或者判断该函数是不是系统内置函数\n //判断一个函数中是否含有 'native code' 字符串 比如\n // function code(){\n // var native='native code'\n // }\n // 或者\n // function code(){\n // var native='native codeasdfsda'\n // }\n\n return typeof Ctor === 'function' && /native code/.test(Ctor.toString())\n }\n\n //判断是否支持Symbol 数据类型\n var hasSymbol =\n //Symbol es6新出来的一种数据类型，类似于string类型，声明唯一的数据值\n typeof Symbol !== 'undefined' && isNative(Symbol) &&\n // Reflect.ownKeys\n // Reflect.ownKeys方法用于返回对象的所有属性，基本等同于Object.getOwnPropertyNames与Object.getOwnPropertySymbols之和。\n typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);\n\n var _Set;\n /* istanbul ignore if */ // $flow-disable-line\n //ES6 提供了新的数据结构 Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。\n // Set 本身是一个构造函数，用来生成 Set 数据结构。\n //判断是否有set这个方法\n if (typeof Set !== 'undefined' && isNative(Set)) {\n // use native Set when available.\n _Set = Set;\n } else {\n // a non-standard Set polyfill that only works with primitive keys.\n //如果没有他自己写一个\n _Set = (function () {\n function Set() {\n this.set = Object.create(null);\n }\n\n Set.prototype.has = function has(key) {\n return this.set[key] === true\n };\n Set.prototype.add = function add(key) {\n this.set[key] = true;\n };\n Set.prototype.clear = function clear() {\n this.set = Object.create(null);\n };\n\n return Set;\n }());\n }\n\n var warn = noop;\n var tip = noop;\n\n var generateComponentTrace = (noop); // work around flow check 绕流检查\n var formatComponentName = (noop);\n\n {\n //判断是否有console 打印输出属性\n var hasConsole = typeof console !== 'undefined';\n\n var classifyRE = /(?:^|[-_])(\\w)/g;\n //非捕获 匹配不分组 。 就是可以包含，但是不匹配上\n //过滤掉class中的 -_ 符号 并且把字母开头的改成大写\n var classify = function (str) {\n return str.replace(classifyRE,\n function (c) {\n return c.toUpperCase();\n }).replace(/[-_]/g, '');\n };\n\n\n /***********************************************************************************************\n *函数名 ：warn\n *函数功能描述 ： 警告信息提示\n *函数参数 ： msg： 警告信息， vm：vue对象\n *函数返回值 ： void\n *作者 ：\n *函数创建日期 ：\n *函数修改日期 ：\n *修改人 ：\n *修改原因 ：\n *版本 ：\n *历史版本 ：\n ***********************************************************************************************/\n warn = function (msg, vm) {\n //vm 如果没有传进来就给空， 不然给执行generateComponentTrace 收集 vue错误码\n var trace = vm ? generateComponentTrace(vm) : '';\n //warnHandler 如果存在 则调用他\n if (config.warnHandler) {\n config.warnHandler.call(null, msg, vm, trace);\n } else if (hasConsole && (!config.silent)) {\n //如果config.warnHandler 不存在则 console 内置方法打印\n console.error((\"[Vue warn]: \" + msg + trace));\n }\n };\n\n //也是个警告输出方法\n tip = function (msg, vm) {\n\n if (hasConsole && (!config.silent)) {\n //\n console.warn(\"[Vue tip]: \" + msg + (\n vm ? generateComponentTrace(vm) : ''\n ));\n }\n };\n\n /***********************************************************************************************\n *函数名 ：formatComponentName\n *函数功能描述 ： 格式组件名\n *函数参数 ： msg： 警告信息， vm：vue对象\n *函数返回值 ： void\n *作者 ：\n *函数创建日期 ：\n *函数修改日期 ：\n *修改人 ：\n *修改原因 ：\n *版本 ：\n *历史版本 ：\n ***********************************************************************************************/\n\n\n formatComponentName = function (vm, includeFile) {\n\n if (vm.$root === vm) {\n return ''\n }\n /*\n * 如果 vm === 'function' && vm.cid != null 条件成立 则options等于vm.options\n * 当vm === 'function' && vm.cid != null 条件不成立的时候 vm._isVue ? vm.$options || vm.constructor.options : vm || {};\n * vm._isVue为真的时候 vm.$options || vm.constructor.options ，vm._isVue为假的时候 vm || {}\n * */\n var options =\n typeof vm === 'function' && vm.cid != null\n ? vm.options : vm._isVue ? vm.$options || vm.constructor.options : vm || {};\n\n var name = options.name || options._componentTag;\n console.log('name=' + name);\n\n var file = options.__file;\n\n if (!name && file) {\n //匹配.vue 后缀的文件名\n //如果文件名中含有vue的文件将会被匹配出来 但是会多虑掉 \\符号\n var match = file.match(/([^/\\\\]+)\\.vue$/);\n name = match && match[1];\n }\n\n //可能返回 classify(name)\n //name 组件名称或者是文件名称\n /*\n * classify 去掉-_连接 大些字母连接起来\n * 如果name存在则返回name\n * 如果name不存在那么返回‘’+ 如果file存在并且includeFile！==false的时候 返回\" at \" + file 否则为空\n *\n * */\n return (\n (name ? (\"<\" + (classify(name)) + \">\") : \"\") +\n (file && includeFile !== false ? (\" at \" + file) : '')\n )\n };\n\n /*\n *重复 递归 除2次 方法+ str\n * */\n var repeat = function (str, n) {\n var res = '';\n while (n) {\n if (n % 2 === 1) {\n res += str;\n }\n if (n > 1) {\n str += str;\n }\n n >>= 1;\n //16 8\n //15 7 相当于除2 向下取整2的倍数\n //console.log( a >>= 1)\n }\n return res\n };\n /***********************************************************************************************\n *函数名 ：generateComponentTrace\n *函数功能描述 ： 生成组建跟踪 vm=vm.$parent递归收集到msg出处。\n *函数参数 ： vm 组建\n *函数返回值 ：\n *作者 ：\n *函数创建日期 ：\n *函数修改日期 ：\n *修改人 ：\n *修改原因 ：\n *版本 ：\n *历史版本 ：\n ***********************************************************************************************/\n generateComponentTrace = function (vm) {\n if (vm._isVue && vm.$parent) { //如果_isVue 等于真，并且有父亲节点的\n var tree = []; //记录父节点\n var currentRecursiveSequence = 0;\n while (vm) { //循环 vm 节点\n if (tree.length > 0) {//tree如果已经有父节点的\n var last = tree[tree.length - 1];\n if (last.constructor === vm.constructor) { //上一个节点等于父节点 个人感觉这里用户不会成立\n currentRecursiveSequence++;\n vm = vm.$parent;\n continue\n } else if (currentRecursiveSequence > 0) { //这里也不会成立\n tree[tree.length - 1] = [last, currentRecursiveSequence];\n currentRecursiveSequence = 0;\n }\n }\n tree.push(vm); //把vm添加到队列中\n vm = vm.$parent;\n }\n return '\\n\\nfound in\\n\\n' + tree\n .map(function (vm, i) {\n //如果i是0 则输出 ‘---->’\n //如果i 不是0的时候输出组件名称\n return (\"\" + (i === 0 ?\n '---> ' : repeat(' ', 5 + i * 2)) +\n (\n Array.isArray(vm) ?\n ((formatComponentName(vm[0])) + \"... (\" + (vm[1]) + \" recursive calls)\")\n : formatComponentName(vm)\n )\n );\n })\n .join('\\n')\n } else {\n //如果没有父组件则输出一个组件名称\n return (\"\\n\\n(found in \" + (formatComponentName(vm)) + \")\")\n }\n };\n\n\n }\n\n /* */\n\n /* */\n\n\n var uid = 0;\n\n /**\n * A dep is an observable that can have multiple dep是可观察到的，可以有多个\n * directives subscribing to it.订阅它的指令。\n *\n */\n //主题对象Dep构造函数 主要用于添加发布事件后，用户更新数据的 响应式原理之一函数\n var Dep = function Dep() {\n //uid 初始化为0\n this.id = uid++;\n /* 用来存放Watcher对象的数组 */\n this.subs = [];\n };\n\n Dep.prototype.addSub = function addSub(sub) {\n /* 在subs中添加一个Watcher对象 */\n this.subs.push(sub);\n };\n\n Dep.prototype.removeSub = function removeSub(sub) {\n /*删除 在subs中添加一个Watcher对象 */\n remove(this.subs, sub);\n };\n //this$1.deps[i].depend();\n //为Watcher 添加 为Watcher.newDeps.push(dep); 一个dep对象\n Dep.prototype.depend = function depend() {\n //添加一个dep target 是Watcher dep就是dep对象\n if (Dep.target) {\n //像指令添加依赖项\n Dep.target.addDep(this);\n }\n };\n /* 通知所有Watcher对象更新视图 */\n Dep.prototype.notify = function notify() {\n // stabilize the subscriber list first\n var subs = this.subs.slice();\n for (var i = 0, l = subs.length; i < l; i++) {\n //更新数据\n subs[i].update();\n }\n };\n\n // the current target watcher being evaluated.\n // this is globally unique because there could be only one\n // watcher being evaluated at any time.\n //当前正在评估的目标监视程序。\n //这在全球是独一无二的，因为只有一个\n //观察者在任何时候都被评估。\n Dep.target = null;\n var targetStack = [];\n\n function pushTarget(_target) {\n //target 是Watcher dep就是dep对象\n if (Dep.target) { //静态标志 Dep当前是否有添加了target\n //添加一个pushTarget\n targetStack.push(Dep.target);\n }\n Dep.target = _target;\n }\n\n //\n function popTarget() {\n // 出盏一个pushTarget\n Dep.target = targetStack.pop();\n }\n\n /*\n * 创建标准的vue vnode\n *\n * */\n\n var VNode = function VNode(\n tag, /*当前节点的标签名*/\n data, /*当前节点对应的对象，包含了具体的一些数据信息，是一个VNodeData类型，可以参考VNodeData类型中的数据信息*/\n children, //子节点\n text, //文本\n elm, /*当前节点的dom */\n context, /*编译作用域*/\n componentOptions, /*组件的option选项*/\n asyncFactory/*异步工厂*/) {\n /*当前节点的标签名*/\n this.tag = tag;\n\n /*当前节点对应的对象，包含了具体的一些数据信息，是一个VNodeData类型，可以参考VNodeData类型中的数据信息*/\n this.data = data;\n\n /*当前节点的子节点，是一个数组*/\n this.children = children;\n\n /*当前节点的文本*/\n this.text = text;\n\n /*当前虚拟节点对应的真实dom节点*/\n this.elm = elm;\n\n /*当前节点的名字空间*/\n this.ns = undefined;\n\n /*编译作用域 vm*/\n this.context = context;\n\n this.fnContext = undefined;\n this.fnOptions = undefined;\n this.fnScopeId = undefined;\n\n /*节点的key属性，被当作节点的标志，用以优化*/\n this.key = data && data.key;\n\n /*组件的option选项*/\n this.componentOptions = componentOptions;\n\n /*当前节点对应的组件的实例*/\n this.componentInstance = undefined;\n\n /*当前节点的父节点*/\n this.parent = undefined;\n\n /*简而言之就是是否为原生HTML或只是普通文本，innerHTML的时候为true，textContent的时候为false*/\n this.raw = false;\n\n /*静态节点标志*/\n this.isStatic = false;\n\n /*是否作为跟节点插入*/\n this.isRootInsert = true;\n\n /*是否为注释节点*/\n this.isComment = false;\n\n /*是否为克隆节点*/\n this.isCloned = false;\n\n /*是否有v-once指令*/\n this.isOnce = false;\n\n /*异步工厂*/\n this.asyncFactory = asyncFactory;\n\n this.asyncMeta = undefined;\n this.isAsyncPlaceholder = false;\n };\n //当且仅当该属性描述符的类型可以被改变并且该属性可以从对应对象中删除。默认为 false\n var prototypeAccessors = { child: { configurable: true } };\n\n // DEPRECATED: alias for componentInstance for backwards compat.\n /* istanbul ignore next */\n\n prototypeAccessors.child.get = function () {\n return this.componentInstance\n };\n /*设置所有VNode.prototype 属性方法 都为\n {\n 'child':{\n configurable: true,\n get:function(){\n return this.componentInstance\n }\n }\n }\n */\n Object.defineProperties(VNode.prototype, prototypeAccessors);\n\n //创建一个节点 空的vnode\n var createEmptyVNode = function (text) {\n if (text === void 0) text = '';\n\n var node = new VNode();\n node.text = text;\n node.isComment = true;\n return node\n };\n\n //创建一个文本节点\n function createTextVNode(val) {\n\n return new VNode(\n undefined,\n undefined,\n undefined,\n String(val)\n )\n }\n\n // optimized shallow clone\n // used for static nodes and slot nodes because they may be reused across\n // multiple renders, cloning them avoids errors when DOM manipulations rely\n // on their elm reference.\n //优化浅克隆\n //用于静态节点和时隙节点，因为它们可以被重用。\n //多重渲染，克隆它们避免DOM操作依赖时的错误\n //他们的榆树参考。\n\n //克隆节点 把节点变成静态节点\n function cloneVNode(vnode, deep) {\n //\n var componentOptions = vnode.componentOptions;\n /*组件的option选项*/\n var cloned = new VNode(\n vnode.tag,\n vnode.data,\n vnode.children,\n vnode.text,\n vnode.elm,\n vnode.context,\n componentOptions,\n vnode.asyncFactory\n );\n cloned.ns = vnode.ns;/*当前节点的名字空间*/\n cloned.isStatic = vnode.isStatic;/*静态节点标志*/\n cloned.key = vnode.key;/*节点的key属性，被当作节点的标志，用以优化*/\n cloned.isComment = vnode.isComment;/*是否为注释节点*/\n cloned.fnContext = vnode.fnContext; //函数上下文\n cloned.fnOptions = vnode.fnOptions; //函数Options选项\n cloned.fnScopeId = vnode.fnScopeId; //函数范围id\n cloned.isCloned = true;\n /*是否为克隆节点*/\n if (deep) { //如果deep存在\n if (vnode.children) { //如果有子节点\n //深度拷贝子节点\n cloned.children = cloneVNodes(vnode.children, true);\n }\n if (componentOptions && componentOptions.children) {\n //深度拷贝子节点\n componentOptions.children = cloneVNodes(componentOptions.children, true);\n }\n }\n return cloned\n }\n\n //克隆多个节点 为数组的\n function cloneVNodes(vnodes, deep) {\n var len = vnodes.length;\n var res = new Array(len);\n for (var i = 0; i < len; i++) {\n res[i] = cloneVNode(vnodes[i], deep);\n }\n return res\n }\n\n\n /*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\n var arrayProto = Array.prototype;\n var arrayMethods = Object.create(arrayProto);\n\n var methodsToPatch = [\n 'push',\n 'pop',\n 'shift',\n 'unshift',\n 'splice',\n 'sort',\n 'reverse'\n ];\n\n /**\n * Intercept mutating methods and emit events\n */\n /***********************************************************************************************\n *函数名 ：methodsToPatch\n *函数功能描述 ： 更新数据时候如果是数组拦截方法，如果在数据中更新用的是'push','pop','shift','unshift','splice','sort','reverse' 方法则会调用这里\n *函数参数 ：\n *函数返回值 ：\n *作者 ：\n *函数创建日期 ：\n *函数修改日期 ：\n *修改人 ：\n *修改原因 ：\n *版本 ：\n *历史版本 ：\n ***********************************************************************************************/\n\n\n methodsToPatch.forEach(function (method) {\n console.log('methodsToPatch')\n\n // cache original method\n var original = arrayProto[method];\n console.log('==method==')\n console.log(method)\n console.log('==original==')\n console.log(original)\n\n def(arrayMethods, method, function mutator() {\n console.log('==def_original==')\n console.log(original)\n\n var args = [], len = arguments.length;\n while (len--) args[len] = arguments[len];\n\n var result = original.apply(this, args);\n var ob = this.__ob__;\n console.log('this.__ob__')\n console.log(this.__ob__)\n\n\n var inserted;\n switch (method) {\n case 'push':\n case 'unshift':\n inserted = args;\n break\n case 'splice':\n inserted = args.slice(2);\n break\n }\n if (inserted) {\n //观察数组数据\n ob.observeArray(inserted);\n }\n // notify change\n //更新通知\n ob.dep.notify();\n console.log('====result====')\n console.log(result)\n return result\n });\n });\n\n /* */\n // 方法返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的数组,只包括实例化的属性和方法，不包括原型上的。\n var arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n\n /**\n * In some cases we may want to disable observation inside a component's\n * update computation.\n *在某些情况下，我们可能希望禁用组件内部的观察。\n *更新计算。\n */\n var shouldObserve = true; //标志是否禁止还是添加到观察者模式\n function toggleObserving(value) {\n shouldObserve = value;\n }\n\n /**\n * Observer class that is attached to each observed\n * object. Once attached, the observer converts the target\n * object's property keys into getter/setters that\n * collect dependencies and dispatch updates.\n * *每个观察到的观察者类\n *对象。一旦被连接，观察者就转换目标。\n *对象的属性键为吸收器/设置器\n *收集依赖关系并发送更新。\n *\n * 实例化 dep对象,获取dep对象 为 value添加__ob__ 属性\n */\n var Observer = function Observer(value) {\n\n\n this.value = value;\n this.dep = new Dep();\n this.vmCount = 0;\n //设置监听 value 必须是对象\n def(value, '__ob__', this);\n if (Array.isArray(value)) { //判断是不是数组\n var augment = hasProto //__proto__ 存在么 高级浏览器都会有这个\n ? protoAugment\n : copyAugment;\n augment(value, arrayMethods, arrayKeys);\n this.observeArray(value);\n } else {\n this.walk(value);\n }\n };\n\n /**\n * Walk through each property and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n * *遍历每个属性并将其转换为\n * getter / setter。此方法只应在调用时调用\n *值类型是Object。\n */\n Observer.prototype.walk = function walk(obj) {\n var keys = Object.keys(obj);\n for (var i = 0; i < keys.length; i++) {\n defineReactive(obj, keys[i]);\n }\n };\n\n /**\n * Observe a list of Array items.\n * 观察数组项的列表。\n * 把数组拆分一个个 添加到观察者 上面去\n */\n Observer.prototype.observeArray = function observeArray(items) {\n for (var i = 0, l = items.length; i < l; i++) {\n console.log('items[i]')\n console.log(items[i])\n\n observe(items[i]);\n }\n };\n\n // helpers\n\n /**\n * Augment an target Object or Array by intercepting\n * the prototype chain using __proto__\n * 通过拦截来增强目标对象或数组\n * 使用原型原型链\n * target 目标对象\n * src 原型 对象或者属性、\n * keys key\n *\n */\n function protoAugment(target, src, keys) {\n /* eslint-disable no-proto */\n target.__proto__ = src;\n /* eslint-enable no-proto */\n }\n\n /**\n * Augment an target Object or Array by defining\n * hidden properties.\n * 复制扩充\n * 定义添加属性 并且添加 监听\n *target 目标对象\n * src对象\n * keys 数组keys\n */\n /* istanbul ignore next */\n function copyAugment(target, src, keys) {\n for (var i = 0, l = keys.length; i < l; i++) {\n var key = keys[i];\n def(target, key, src[key]);\n }\n }\n\n /**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n *尝试为值创建一个观察者实例，\n *如果成功观察，返回新的观察者；\n *或现有的观察员，如果值已经有一个。\n *\n * 判断value 是否有__ob__ 实例化 dep对象,获取dep对象 为 value添加__ob__ 属性 返回 new Observer 实例化的对象\n */\n function observe(value, asRootData) {\n\n if (!isObject(value) || value instanceof VNode) {\n //value 不是一个对象 或者 实例化 的VNode\n console.log(value)\n\n return\n }\n var ob;\n\n if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n console.log('hasOwn value')\n console.log(value)\n\n\n ob = value.__ob__;\n } else if (\n shouldObserve && //shouldObserve 为真\n !isServerRendering() && //并且不是在服务器node环境下\n (Array.isArray(value) || isPlainObject(value)) && //是数组或者是对象\n Object.isExtensible(value) && //Object.preventExtensions(O) 方法用于锁住对象属性，使其不能够拓展，也就是不能增加新的属性，但是属性的值仍然可以更改，也可以把属性删除，Object.isExtensible用于判断对象是否可以被拓展\n !value._isVue //_isVue为假\n ) {\n console.log('new Observer value')\n console.log(value)\n //实例化 dep对象 为 value添加__ob__ 属性\n ob = new Observer(value);\n }\n console.log(value)\n //如果是RootData，即咱们在新建Vue实例时，传到data里的值，只有RootData在每次observe的时候，会进行计数。 vmCount是用来记录此Vue实例被使用的次数的， 比如，我们有一个组件logo，页面头部和尾部都需要展示logo，都用了这个组件，那么这个时候vmCount就会计数，值为2\n\n if (asRootData && ob) { //是根节点数据的话 并且 ob 存在\n ob.vmCount++; //统计有几个vm\n }\n // * 实例化 dep对象,获取dep对象 为 value添加__ob__ 属性\n return ob\n }\n\n /**\n * Define a reactive property on an Object.\n * 在对象上定义一个无功属性。\n * 更新数据\n * 通过defineProperty的set方法去通知notify()订阅者subscribers有新的值修改\n * 添加观察者 get set方法\n */\n function defineReactive(obj, //对象\n key,//对象的key\n val, //监听的数据 返回的数据\n customSetter, // 日志函数\n shallow //是否要添加__ob__ 属性\n ) {\n //实例化一个主题对象，对象中有空的观察者列表\n var dep = new Dep();\n //获取描述属性\n var property = Object.getOwnPropertyDescriptor(obj, key);\n var _property = Object.getOwnPropertyNames(obj); //获取实力对象属性或者方法，包括定义的描述属性\n console.log(property);\n console.log(_property);\n\n if (property && property.configurable === false) {\n return\n }\n\n // cater for pre-defined getter/setters\n\n var getter = property && property.get;\n console.log('arguments.length=' + arguments.length)\n\n if (!getter && arguments.length === 2) {\n val = obj[key];\n }\n var setter = property && property.set;\n console.log(val)\n //判断value 是否有__ob__ 实例化 dep对象,获取dep对象 为 value添加__ob__ 属性递归把val添加到观察者中 返回 new Observer 实例化的对象\n var childOb = !shallow && observe(val);\n //定义描述\n Object.defineProperty(obj, key, {\n enumerable: true,\n configurable: true,\n get: function reactiveGetter() {\n\n var value = getter ? getter.call(obj) : val;\n if (Dep.target) { //Dep.target 静态标志 标志了Dep添加了Watcher 实例化的对象\n //添加一个dep\n dep.depend();\n if (childOb) { //如果子节点存在也添加一个dep\n childOb.dep.depend();\n if (Array.isArray(value)) { //判断是否是数组 如果是数组\n dependArray(value); //则数组也添加dep\n }\n }\n }\n return value\n },\n set: function reactiveSetter(newVal) {\n var value = getter ? getter.call(obj) : val;\n /* eslint-disable no-self-compare 新旧值比较 如果是一样则不执行了*/\n if (newVal === value || (newVal !== newVal && value !== value)) {\n return\n }\n /* eslint-enable no-self-compare\n * 不是生产环境的情况下\n * */\n if (\"development\" !== 'production' && customSetter) {\n customSetter();\n }\n if (setter) {\n //set 方法 设置新的值\n setter.call(obj, newVal);\n } else {\n //新的值直接给他\n val = newVal;\n }\n console.log(newVal)\n\n //observe 添加 观察者\n childOb = !shallow && observe(newVal);\n //更新数据\n dep.notify();\n }\n });\n }\n\n /**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * already exist.\n **在对象上设置属性。添加新属性和\n *触发器更改通知，如果该属性不\n *已经存在。\n */\n //如果是数组 并且key是数字 就更新数组\n //如果是对象则重新赋值\n //如果 (target).__ob__ 存在则表明该数据以前添加过观察者对象中 //通知订阅者ob.value更新数据 添加观察者 define set get 方法\n function set(target, key, val) {\n if (\"development\" !== 'production' &&\n //判断数据 是否是undefined或者null\n (isUndef(target) || isPrimitive(target)) //判断数据类型是否是string，number，symbol，boolean\n ) {\n //必须是对象数组才可以 否则发出警告\n warn((\"Cannot set reactive property on undefined, null, or primitive value: \" + ((target))));\n }\n\n //如果是数组 并且key是数字\n if (Array.isArray(target) && isValidArrayIndex(key)) {\n //设置数组的长度\n target.length = Math.max(target.length, key);\n //像数组尾部添加一个新数据，相当于push\n target.splice(key, 1, val);\n return val\n }\n //判断key是否在target 上，并且不是在Object.prototype 原型上，而不是通过父层原型链查找的\n if (key in target && !(key in Object.prototype)) {\n target[key] = val; //赋值\n return val\n }\n var ob = (target).__ob__; //声明一个对象ob 值为该target对象中的原型上面的所有方法和属性 ，表明该数据加入过观察者中\n //vmCount 记录vue被实例化的次数\n //是不是vue\n if (target._isVue || (ob && ob.vmCount)) {\n //如果不是生产环境，发出警告\n \"development\" !== 'production' && warn(\n 'Avoid adding reactive properties to a Vue instance or its root $data ' +\n 'at runtime - declare it upfront in the data option.'\n );\n return val\n }\n //如果ob不存在 说明他没有添加观察者 则直接赋值\n if (!ob) {\n target[key] = val;\n return val\n }\n //通知订阅者ob.value更新数据 添加观察者 define set get 方法\n defineReactive(ob.value, key, val);\n //通知订阅者ob.value更新数据\n ob.dep.notify();\n return val\n }\n\n /**\n * Delete a property and trigger change if necessary.\n * 删除属性并在必要时触发更改数据。\n */\n function del(target, key) {\n //如果不是生产环境\n\n if (\"development\" !== 'production' &&\n (isUndef(target) || isPrimitive(target))\n ) {\n //无法删除未定义的、空的或原始值的无功属性：\n warn((\"Cannot delete reactive property on undefined, null, or primitive value: \" + ((target))));\n }\n\n //如果是数据则用splice方法删除\n if (Array.isArray(target) && isValidArrayIndex(key)) {\n target.splice(key, 1);\n return\n }\n\n\n var ob = (target).__ob__;\n //vmCount 记录vue被实例化的次数\n //是不是vue\n if (target._isVue || (ob && ob.vmCount)) {\n //如果是开发环境就警告\n \"development\" !== 'production' && warn(\n 'Avoid deleting properties on a Vue instance or its root $data ' +\n '- just set it to null.'\n );\n return\n }\n //如果不是target 实例化不删除原型方法\n if (!hasOwn(target, key)) {\n return\n }\n //删除对象中的属性或者方法\n delete target[key];\n if (!ob) {\n return\n }\n //更新数据\n ob.dep.notify();\n }\n\n /**\n * Collect dependencies on array elements when the array is touched, since\n * we cannot intercept array element access like property getters.\n * 在数组被触摸时收集数组元素的依赖关系，因为\n * 我们不能拦截数组元素访问，如属性吸收器。\n * 参数是数组\n */\n function dependArray(value) {\n for (var e = (void 0), i = 0, l = value.length; i < l; i++) {\n e = value[i];\n //添加一个dep\n e && e.__ob__ && e.__ob__.dep.depend();\n //递归\n if (Array.isArray(e)) {\n dependArray(e);\n }\n }\n }\n\n /* */\n\n /**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n * *选项重写策略是处理的函数\n\n *如何合并父选项值和子选项\n\n *值为最终值。\n */\n //选择策略\n var strats = config.optionMergeStrategies;\n\n /**\n * Options with restrictions\n * 选择与限制\n */\n {\n strats.el = strats.propsData = function (parent, child, vm, key) {\n if (!vm) {\n warn(\n \"option \\\"\" + key + \"\\\" can only be used during instance \" +\n 'creation with the `new` keyword.'\n );\n }\n //默认开始\n return defaultStrat(parent, child)\n };\n }\n\n /**\n * Helper that recursively merges two data objects together.\n * 递归合并数据 深度拷贝\n */\n function mergeData(to, from) {\n if (!from) {\n return to\n }\n var key, toVal, fromVal;\n var keys = Object.keys(from); //获取对象的keys 变成数组\n for (var i = 0; i < keys.length; i++) {\n key = keys[i]; //获取对象的key\n toVal = to[key]; //\n fromVal = from[key]; //获取对象的值\n if (!hasOwn(to, key)) { //如果from对象的key在to对象中没有\n set(to, key, fromVal);\n } else if (isPlainObject(toVal) && isPlainObject(fromVal)) {\n //深层递归\n mergeData(toVal, fromVal);\n }\n }\n return to\n }\n\n /**\n * Data\n * mergeDataOrFn递归合并数据 深度拷贝。如果vm不存在，并且childVal不存在就返回parentVal。如果vm不存在并且parentVal不存在则返回childVal。如果vm不存在parentVal和childVal都存在则返回mergedDataFn。如果vm存在则返回 mergedInstanceDataFn函数\n */\n function mergeDataOrFn(\n parentVal,\n childVal,\n vm\n ) {\n //vm不存在的时候\n if (!vm) {\n // in a Vue.extend merge, both should be functions Vue。扩展合并，两者都应该是函数\n if (!childVal) {\n return parentVal\n }\n if (!parentVal) {\n return childVal\n }\n // when parentVal & childVal are both present,\n // we need to return a function that returns the\n // merged result of both functions... no need to\n // check if parentVal is a function here because\n // it has to be a function to pass previous merges.\n //当父母和孩子都在场时，\n //我们需要返回一个函数，该函数返回\n //两个函数的合并结果…不需要\n //检查parentVal是否是一个函数，因为\n //它必须是一个函数来传递以前的合并。\n return function mergedDataFn() {\n //如果childVal，parentVal是函数 先改变this\n return mergeData(\n typeof childVal === 'function' ? childVal.call(this, this) : childVal,\n typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal\n )\n }\n } else {\n //如果vm 存在 则是合并vm的数据\n return function mergedInstanceDataFn() {\n // instance merge\n var instanceData = typeof childVal === 'function'\n ? childVal.call(vm, vm)\n : childVal;\n\n var defaultData = typeof parentVal === 'function'\n ? parentVal.call(vm, vm)\n : parentVal;\n\n if (instanceData) {\n return mergeData(instanceData, defaultData)\n } else {\n return defaultData\n }\n }\n }\n }\n\n strats.data = function (\n parentVal,\n childVal,\n vm\n ) {\n if (!vm) {\n if (childVal && typeof childVal !== 'function') {\n \"development\" !== 'production' && warn(\n 'The \"data\" option should be a function ' +\n 'that returns a per-instance value in component ' +\n 'definitions.',\n vm\n );\n\n return parentVal\n }\n return mergeDataOrFn(parentVal, childVal)\n }\n\n return mergeDataOrFn(parentVal, childVal, vm)\n };\n\n /**\n * Hooks and props are merged as arrays.\n * 钩子和道具被合并成数组。\n * 判断childVal存在么？如果不存在 则返回parentVal\n * 如果childVal存在 则判断parentVal存在么。如果parentVal存在则返回 parentVal.concat(childVal)，如果不存在，则判断childVal是不是数组如果是数组直接返回去，\n * 如果不是数组把childVal变成数组在返回出去\n */\n function mergeHook(\n parentVal,\n childVal\n ) {\n return childVal ? (parentVal ?\n parentVal.concat(childVal) :\n (Array.isArray(childVal) ?\n childVal :\n [childVal]\n )\n ) : parentVal\n }\n\n LIFECYCLE_HOOKS.forEach(function (hook) {\n strats[hook] = mergeHook;\n });\n\n /**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n *\n ＊资产\n *当存在虚拟机（实例创建）时，我们需要做\n *构造函数选项之间的三路合并，实例\n *选项和父选项。\n * 创建一个res对象，获取parentVal对象中的数据。如果parentVal存在则获取parentVal对象 的数据存在res中的 __props__ 中，如果没有则创建一个空的对象。\n * 如果childVal 存在，则用浅拷贝吧 childVal 合并到res中，返回res对象\n */\n function mergeAssets(\n parentVal,\n childVal,\n vm,\n key\n ) {\n var res = Object.create(parentVal || null);\n if (childVal) {\n \"development\" !== 'production' && assertObjectType(key, childVal, vm);\n return extend(res, childVal)\n } else {\n return res\n }\n }\n\n //为每一个组件指令添加一个\n ASSET_TYPES.forEach(function (type) {\n strats[type + 's'] = mergeAssets;\n });\n\n /**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n * *观察者散列不应该覆盖一个\n *另一个，所以我们将它们合并为数组。\n *\n * 循环childVal。获取到子节点childVal的key如果在父亲节点上面有，则先获取到父亲节点的值，如果父亲节点的上没有值得获取子节点的值。 变成数组存在ret对象中。\n */\n strats.watch = function (\n parentVal, //父节点值\n childVal, //子节点值\n vm, //vm vue实例化的对象\n key) { // key值\n // work around Firefox's Object.prototype.watch... 在Firefox的对象周围工作。原型\n //// Firefox has a \"watch\" function on Object.prototype...\n //var nativeWatch = ({}).watch;\n if (parentVal === nativeWatch) {\n parentVal = undefined;\n }\n if (childVal === nativeWatch) {\n childVal = undefined;\n }\n /* istanbul ignore if */\n if (!childVal) { //如果子节点不存在 则创建一个 对象\n return Object.create(parentVal || null)\n }\n {\n //检测childVal是不是对象\n assertObjectType(key, childVal, vm);\n }\n if (!parentVal) { //如果父节点不存在 则返回子节点\n return childVal\n }\n var ret = {};\n extend(ret, parentVal); //合并对象 一个新的对象\n for (var key$1 in childVal) { //循环子节点\n var parent = ret[key$1]; // 把子节点的kye放到父节点中\n var child = childVal[key$1]; //获取子节点的值\n if (parent && !Array.isArray(parent)) { //如果子节点的key放到父节点中能获取到子节点 ，并且子节点不是一个数组\n parent = [parent]; //\n }\n ret[key$1] = parent ? parent.concat(child)\n : Array.isArray(child) ?\n child :\n [child];\n }\n return ret\n };\n\n /**\n * Other object hashes.\n */\n strats.props =\n strats.methods =\n strats.inject =\n strats.computed = function (\n parentVal,\n childVal,\n vm,\n key\n ) {\n if (childVal && \"development\" !== 'production') {\n //判断是否是对象\n assertObjectType(key, childVal, vm);\n }\n if (!parentVal) {\n return childVal\n }\n var ret = Object.create(null);\n //对象浅拷贝，参数（to, _from）循环_from的值，会覆盖掉to的值\n extend(ret, parentVal);\n if (childVal) {\n //对象浅拷贝，参数（to, _from）循环_from的值，会覆盖掉to的值\n extend(ret, childVal);\n }\n return ret\n };\n strats.provide = mergeDataOrFn;\n\n /**\n * Default strategy.\n * 如果没有子节点就返回父节点，如果有子节点就返回子节点\n */\n var defaultStrat = function (parentVal, childVal) {\n return childVal === undefined ? parentVal : childVal\n };\n\n /**\n * Validate component names\n *验证组件名称\n */\n function checkComponents(options) {\n for (var key in options.components) {\n // 验证组件名称 必须是大小写，并且是-横杆\n validateComponentName(key);\n }\n }\n\n //验证组件名称 必须是大小写，并且是-横杆\n function validateComponentName(name) {\n if (!/^[a-zA-Z][\\w-]*$/.test(name)) {\n warn(\n 'Invalid component name: \"' + name + '\". Component names ' +\n 'can only contain alphanumeric characters and the hyphen, ' +\n 'and must start with a letter.'\n );\n }\n if (isBuiltInTag(name) || config.isReservedTag(name)) {\n warn(\n 'Do not use built-in or reserved HTML elements as component ' +\n 'id: ' + name\n );\n }\n }\n\n /**\n * Ensure all props option syntax are normalized into the\n * 确保所有props选项语法都规范化为\n * Object-based format.\n * 基于对象格式\n *\n * 检查 props 数据类型\n * normalizeProps 检查 props 数据类型，并把type标志打上。如果是数组循环props属性数组，如果val是string则把它变成驼峰写法 res[name] = {type: null}; 。如果是对象也循环props把key变成驼峰，并且判断val是不是对象如果是对象则 res[name] 是{type: val}否则 res[name] 是val。\n *\n */\n function normalizeProps(options, vm) {\n //参数中有没有props\n var props = options.props;\n if (!props) {\n return\n }\n var res = {};\n var i, val, name;\n\n //如果props 是一个数组\n if (Array.isArray(props)) {\n i = props.length;\n while (i--) {\n val = props[i];\n if (typeof val === 'string') {\n //把含有横岗的字符串 变成驼峰写法\n name = camelize(val);\n\n res[name] = { type: null };\n } else {\n //当使用数组语法时，道具必须是字符串。 如果是props 是数组必须是字符串\n warn('props must be strings when using array syntax.');\n }\n }\n } else if (isPlainObject(props)) { //如果是对象\n for (var key in props) { //for in 提取值\n val = props[key];\n name = camelize(key); //把含有横岗的字符串 变成驼峰写法\n res[name] = isPlainObject(val) //判断值是不是对象\n ? val\n : { type: val };\n }\n } else {\n //如果不是对象和数组则警告\n warn(\n \"Invalid value for option \\\"props\\\": expected an Array or an Object, \" +\n \"but got \" + (toRawType(props)) + \".\",\n vm\n );\n }\n options.props = res;\n }\n\n /**\n * Normalize all injections into Object-based format\n * 将所有注入规范化为基于对象的格式\n *\n *\n * 将数组转化成对象 比如 [1,2,3]转化成\n * normalized[1]={from: 1}\n * normalized[2]={from: 2}\n * normalized[3]={from: 3}\n *\n *\n * *\n */\n function normalizeInject(options, vm) {\n // provide 和 inject 主要为高阶插件/组件库提供用例。并不推荐直接用于应用程序代码中。\n // 这对选项需要一起使用，以允许一个祖先组件向其所有子孙后代注入一个依赖，不论组件层次有多深，并在起上下游关系成立的时间里始终生效。如果你熟悉 React，这与 React 的上下文特性很相似。\n\n var inject = options.inject;\n if (!inject) {\n return\n }\n var normalized = options.inject = {};\n if (Array.isArray(inject)) { //如果是数组\n for (var i = 0; i < inject.length; i++) {\n // * 将数组转化成对象 比如 [1,2,3]转化成\n // * normalized[1]={from: 1}\n // * normalized[2]={from: 2}\n // * normalized[3]={from: 3}\n normalized[inject[i]] = { from: inject[i] };\n }\n } else if (isPlainObject(inject)) { //如果是对象\n for (var key in inject) {\n var val = inject[key];\n normalized[key] = isPlainObject(val) ? extend({ from: key }, val) : { from: val };\n }\n } else {\n warn(\n \"Invalid value for option \\\"inject\\\": expected an Array or an Object, \" +\n \"but got \" + (toRawType(inject)) + \".\",\n vm\n );\n }\n }\n\n /**\n * Normalize raw function directives into object format.\n *\n * 将原始函数指令归一化为对象格式。\n *\n *\n * normalizeDirectives获取到指令对象值。循环对象指令的值，如果是函数则把它变成dirs[key] = {bind: def, update: def} 这种形式\n */\n function normalizeDirectives(options) {\n //获取参数中的指令\n var dirs = options.directives;\n console.log(options)\n\n if (dirs) { //如果指令存在\n for (var key in dirs) { //循环该指令\n var def = dirs[key]; //获取到指令的值\n console.log(def)\n\n if (typeof def === 'function') { //如果是函数\n //为该函数添加一个对象和值\n dirs[key] = { bind: def, update: def };\n }\n }\n }\n }\n\n //判断是否是对象\n function assertObjectType(name, value, vm) {\n if (!isPlainObject(value)) {\n warn(\n \"Invalid value for option \\\"\" + name + \"\\\": expected an Object, \" +\n \"but got \" + (toRawType(value)) + \".\",\n vm\n );\n }\n }\n\n /**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n * 将两个对象合成一个对象 将父值对象和子值对象合并在一起，并且优先取值子值，如果没有则取子值\n *\n * 用于实例化和继承的核心实用程序。\n */\n function mergeOptions(parent, //父值\n child, //子值 优选取子值\n vm) {\n\n {\n //检验子组件\n checkComponents(child);\n }\n\n if (typeof child === 'function') {\n //如果child 是函数则获取他的参数\n child = child.options;\n }\n //检查 props 数据类型\n normalizeProps(child, vm);\n\n // 将数组转化成对象 比如 [1,2,3]转化成\n normalizeInject(child, vm);\n\n // * normalizeDirectives获取到指令对象值。循环对象指令的值，如果是函数则把它变成dirs[key] = {bind: def, update: def} 这种形式\n normalizeDirectives(child);\n\n //子组件是否有需要合并的对象继承 方式\n var extendsFrom = child.extends;\n\n if (extendsFrom) {\n //如果有则递归\n parent = mergeOptions(parent, extendsFrom, vm);\n }\n\n //如果 子组件有mixins 数组 则也递归合并，继承 方式 mixins 必须是数组\n if (child.mixins) {\n for (var i = 0, l = child.mixins.length; i < l; i++) {\n parent = mergeOptions(parent, child.mixins[i], vm);\n }\n }\n var options = {};\n var key;\n for (key in parent) { //循环合并后的key\n mergeField(key);\n }\n for (key in child) { //循环子组件的\n if (!hasOwn(parent, key)) {\n mergeField(key);\n }\n }\n\n //获取到key 去读取strats类的方法\n // strats类 有方法 el，propsData，data，provide，watch，props，methods，inject，computed，components，directives，filters 。\n // strats类里面的方法都是 合并数据 如果没有子节点childVal，\n // 就返回父节点parentVal，如果有子节点childVal就返回子节点childVal。\n function mergeField(key) {\n //defaultStrat 获取子值还是父组的值\n var strat = strats[key] || //\n defaultStrat; //* 如果没有子节点就返回父节点，如果有子节点就返回子节点\n //获取子值还是父组的值\n options[key] = strat(parent[key], child[key], vm, key);\n }\n\n //返回参数\n return options\n }\n\n /**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n * 检测指令是否在 组件对象上面 ,返回注册指令或者组建的对象, 包括检查directives ， filters ，components\n *\n */\n function resolveAsset(options, //参数\n type, // 类型：directives ， filters ，components\n id, // 指令的key 属性\n warnMissing //警告的信息 true\n ) {\n console.log('==resolveAsset==')\n console.log(options)\n console.log(type)\n console.log(id)\n console.log(warnMissing)\n\n\n\n /* istanbul ignore if 如果id不是字符串 */\n if (typeof id !== 'string') {\n return\n }\n var assets = options[type]; //\n console.log('==assets==')\n console.log(assets)\n\n // check local registration variations first\n //首先检查本地注册的变化 检查id是否是assets 实例化的属性或者方法\n if (hasOwn(assets, id)) {\n return assets[id]\n }\n // 可以让这样的的属性 v-model 变成 vModel 变成驼峰\n var camelizedId = camelize(id);\n\n console.log('==camelizedId==')\n console.log(camelizedId)\n\n // 检查camelizedId是否是assets 实例化的属性或者方法\n if (hasOwn(assets, camelizedId)) {\n return assets[camelizedId]\n }\n console.log('==assets==')\n console.log(assets)\n\n // 将首字母变成大写 变成 VModel\n var PascalCaseId = capitalize(camelizedId);\n console.log('==PascalCaseId==')\n console.log(PascalCaseId)\n // 检查PascalCaseId是否是assets 实例化的属性或者方法\n if (hasOwn(assets, PascalCaseId)) {\n return assets[PascalCaseId]\n }\n console.log('==assets==')\n console.log(assets)\n\n console.log('==id-camelizedId-PascalCaseId==')\n console.log(assets)\n console.log(assets[id])\n console.log(assets[camelizedId])\n console.log(assets[PascalCaseId])\n\n // fallback to prototype chain 回到原型链\n var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n\n //如果检查不到id 实例化则如果是开发环境则警告\n if (\"development\" !== 'production' && warnMissing && !res) {\n warn(\n 'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n options\n );\n }\n console.log('==res==')\n console.log(res)\n //返回注册指令或者组建的对象\n return res\n }\n\n /*\n *验证支柱 验证 prosp 是否是规范数据 并且为props 添加 value.__ob__ 属性，把prosp添加到观察者中\n * 校验 props 参数 就是组建 定义的props 类型数据，校验类型\n *\n * 判断prop.type的类型是不是Boolean或者String，如果不是他们两类型，调用getPropDefaultValue获取默认值并且把value添加到观察者模式中\n *\n *\n */\n function validateProp(\n key, //key\n propOptions, //原始props 参数\n propsData, //转义过的组件props数据\n vm // VueComponent 组件构造函数\n ) { //vm this属性\n\n\n var prop = propOptions[key]; //获取组件定义的props 属性\n var absent = !hasOwn(propsData, key); // 如果该为假的那么可能 a-b 这样的key才能获取到值\n var value = propsData[key]; // 获取值\n // boolean casting\n //Boolean 传一个布尔值 但是 一般是函数或者数组函数才有意义，而且是函数声明的函数并不是 函数表达式prop.type 也需要是函数\n //返回的是相同的索引 判断 属性类型定义的是否是Boolean\n var booleanIndex = getTypeIndex(Boolean, prop.type);\n if (booleanIndex > -1) { //如果是boolean值\n\n if (absent && !hasOwn(prop, 'default')) { //如果key 不是propsData 实例化，或者 没有定义default 默认值的时候 设置value 为false\n value = false;\n } else if (\n value === '' //如果value 是空\n || value === hyphenate(key) //或者key转出 - 形式和value 相等的时候\n ) { //\n // only cast empty string / same name to boolean if 仅将空字符串/相同名称转换为boolean if\n // boolean has higher priority 获取到相同的\n //判断prop.type 的类型是否是string字符串类型\n var stringIndex = getTypeIndex(String, prop.type);\n\n if (\n stringIndex < 0 || //如果匹配不到字符串\n booleanIndex < stringIndex) { //或者布尔值索引小于字符串 索引的时候\n value = true;\n }\n }\n }\n // check default value 检查默认值\n if (value === undefined) { //如果没有值 value 也不是boolean， 也不是string的时候\n // 有可能是 函数\n value = getPropDefaultValue(vm, prop, key);\n // since the default value is a fresh copy, 由于默认值是一个新的副本，\n // make sure to observe it. 一定要遵守。\n var prevShouldObserve = shouldObserve;\n toggleObserving(true);\n console.log('===value===')\n console.log(value);\n //为 value添加 value.__ob__ 属性，把value添加到观察者中\n observe(value);\n toggleObserving(prevShouldObserve);\n }\n {\n console.log(prop,\n key,\n value,\n vm,\n absent)\n\n //检查prop 是否合格\n assertProp(\n prop, //属性的type值\n key, //props属性中的key\n value, //view 属性的值\n vm, // VueComponent 组件构造函数\n absent //false\n );\n }\n return value\n }\n\n /**\n * Get the default value of a prop.\n *获取prop 属性默认的vue值\n */\n function getPropDefaultValue(vm, prop, key) {\n // no default, return undefined\n //判断该对象prop 中的default 是否是prop 实例化的\n if (!hasOwn(prop, 'default')) {\n return undefined\n }\n var def = prop.default;\n // warn against non-factory defaults for Object & Array\n //警告对象和数组的非工厂默认值\n if (\"development\" !== 'production' && isObject(def)) {\n warn(\n 'Invalid default value for prop \"' + key + '\": ' +\n 'Props with type Object/Array must use a factory function ' +\n 'to return the default value.',\n vm\n );\n }\n // the raw prop value was also undefined from previous render,\n //原始PROP值也未从先前的渲染中定义，\n // return previous default value to avoid unnecessary watcher trigger\n //返回先前的默认值以避免不必要的监视触发器\n if (vm && vm.$options.propsData &&\n vm.$options.propsData[key] === undefined &&\n vm._props[key] !== undefined\n ) {\n return vm._props[key]\n }\n // call factory function for non-Function types\n //非功能类型调用工厂函数\n // a value is Function if its prototype is function even across different execution context\n //一个值是函数，即使它的原型在不同的执行上下文中也是函数。\n //getType检查函数是否是函数声明 如果是函数表达式或者匿名函数是匹配不上的\n //判断def 是不是函数 如果是则执行，如果不是则返回props的PropDefaultValue\n return typeof def === 'function' && getType(prop.type) !== 'Function'\n ? def.call(vm)\n : def\n }\n\n /**\n * Assert whether a prop is valid.\n * 断言一个属性是否有效。\n *\n *\n *\n * prop, //属性的type值\n key, //props属性中的key\n value, //view 属性的值\n vm, //组件构造函数\n absent //false\n */\n\n\n\n function assertProp(\n prop, //属性的type值\n name, //props属性中的key\n value, //view 属性的值\n vm, //组件构造函数\n absent//false\n ) {\n //必须有required 和 absent\n if (prop.required && absent) {\n warn(\n 'Missing required prop: \"' + name + '\"',\n vm\n );\n return\n }\n //如果vual 为空 或者 不是必填项 则不执行下面代码\n if (value == null && !prop.required) {\n return\n }\n //类型\n var type = prop.type;\n\n //如果类型为真 或者类型 不存在\n var valid = !type || type === true;\n\n var expectedTypes = [];\n\n if (type) { //如果type存在\n if (!Array.isArray(type)) { //如果不是数组\n type = [type]; //再包裹成数组\n }\n for (var i = 0; i < type.length && !valid; i++) {\n var assertedType = assertType(value, type[i]);\n expectedTypes.push(assertedType.expectedType || '');\n valid = assertedType.valid;\n }\n }\n if (!valid) {\n warn(\n \"Invalid prop: type check failed for prop \\\"\" + name + \"\\\".\" +\n \" Expected \" + (expectedTypes.map(capitalize).join(', ')) +\n \", got \" + (toRawType(value)) + \".\",\n vm\n );\n return\n }\n var validator = prop.validator;\n if (validator) {\n if (!validator(value)) {\n warn(\n 'Invalid prop: custom validator check failed for prop \"' + name + '\".',\n vm\n );\n }\n }\n }\n\n //检测数据类型 是否是String|Number|Boolean|Function|Symbol 其中的一个数据类型\n var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;\n\n //获取type类型\n function assertType(value, type) {\n var valid;\n //getType检查函数是否是函数声明 如果是函数表达式或者匿名函数是匹配不上的\n //type 必须是String|Number|Boolean|Function|Symbol 构造函数\n var expectedType = getType(type);\n\n //检测改函数是什么类型\n if (simpleCheckRE.test(expectedType)) { //type 必须是String|Number|Boolean|Function|Symbol 构造函数 这里才为真 (String|Number|Boolean|Function|Symbol)\n var t = typeof value;\n //转换成小写\n valid = t === expectedType.toLowerCase(); //布尔值\n // for primitive wrapper objects 对于原始包装对象\n if (!valid && t === 'object') {\n valid = value instanceof type;\n }\n } else if (expectedType === 'Object') {\n //检测是否是真正的对象\n valid = isPlainObject(value);\n } else if (expectedType === 'Array') {\n //检测是否是真正的数组\n valid = Array.isArray(value);\n } else {\n //判断 value 是否是type中的实例化对象\n valid = value instanceof type;\n }\n //返回出去值\n return {\n valid: valid,\n expectedType: expectedType\n }\n }\n\n /**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n * 检查函数是否是函数声明 如果是函数表达式或者匿名函数是匹配不上的\n *\n *\n */\n function getType(fn) {\n var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n return match ? match[1] : ''\n }\n\n //判断两个函数声明是否是相等\n function isSameType(a, b) {\n return getType(a) === getType(b)\n }\n\n\n //判断expectedTypes 中的函数和 type 函数是否有相等的如有有则返回索引index 如果没有则返回-1\n\n function getTypeIndex(type, expectedTypes) {\n //如果不是数组直接比较 如果真则返回0\n if (!Array.isArray(expectedTypes)) {\n return isSameType(expectedTypes, type) ? 0 : -1\n }\n for (var i = 0, len = expectedTypes.length; i < len; i++) {\n //如果是数组则寻找索引\n if (isSameType(expectedTypes[i], type)) {\n return i\n }\n }\n return -1\n }\n\n /*\n\n 向外暴露了一个 handleError 方法，在需要捕获异常的\b地方调用。\n handleError 方法中首先获取到报错的组件，之后递归查找当前组件的父组件，\n 依次调用\b errorCaptured 方法。在遍历调用完所有 errorCaptured 方法、或 errorCaptured 方法有报错时，\n\n 会调用 globalHandleError 方法。\n\n globalHandleError 方法调用了全局的 errorHandler 方法。\n\n 如果 errorHandler 方法自己又报错了呢？生产环境下会使用 console.error 在控制台中输出。\n\n 可以看到 errorCaptured 和 errorHandler 的触发时机都是相同的，不同的是 errorCaptured 发生在前，\n 且如果某个组件的 errorCaptured 方法返回了 false，那么这个异常信息不会再向上冒泡也不会再调用\n errorHandler 方法。\n\n */\n\n function handleError(err, vm, info) {\n if (vm) {\n var cur = vm;\n //循环父组件\n while ((cur = cur.$parent)) {\n //如果hooks 存在 则循环 所有的hooks\n var hooks = cur.$options.errorCaptured;\n if (hooks) {\n for (var i = 0; i < hooks.length; i++) {\n try {\n //调用hooks 中函数，如果发生错误则调用globalHandleError\n var capture = hooks[i].call(cur, err, vm, info) === false;\n if (capture) {\n return\n }\n } catch (e) {\n //调用全局日志输出\n globalHandleError(e, cur, 'errorCaptured hook');\n }\n }\n }\n }\n }\n //调用全局日志输出\n globalHandleError(err, vm, info);\n }\n\n function globalHandleError(err, vm, info) {\n\n //如果errorHandler 存在 则调用 errorHandler函数\n if (config.errorHandler) {\n\n try {\n return config.errorHandler.call(null, err, vm, info)\n } catch (e) {\n //错误日志信息输出\n logError(e, null, 'config.errorHandler');\n }\n }\n logError(err, vm, info);\n }\n\n //错误日志信息输出\n function logError(err, vm, info) {\n {\n warn((\"Error in \" + info + \": \\\"\" + (err.toString()) + \"\\\"\"), vm);\n }\n /* istanbul ignore else 如果是浏览器或者是 微信端，输出console */\n if ((inBrowser || inWeex) && typeof console !== 'undefined') {\n console.error(err);\n } else {\n //如果是服务器端 则抛出错误\n throw err\n }\n }\n\n /* */\n /* globals MessageChannel 全局消息通道 */\n\n //回调函数队列\n var callbacks = [];\n var pending = false;\n // 触发 callbacks 队列中的函数\n function flushCallbacks() {\n\n pending = false;\n //.slice(0) 浅拷贝\n var copies = callbacks.slice(0);\n callbacks.length = 0;\n console.log(copies)\n\n for (var i = 0; i < copies.length; i++) {\n //执行回调函数\n copies[i]();\n }\n }\n\n // Here we have async deferring wrappers using both microtasks and (macro) tasks. 在这里，我们使用了微任务和宏任务的异步包装器。\n // In < 2.4 we used microtasks everywhere, but there are some scenarios where 在< 2.4中，我们到处使用微任务，但也有一些场景。\n // microtasks have too high a priority and fire in between supposedly 微任务优先级太高，据称介于两者之间。\n // sequential events (e.g. #4521, #6690) or even between bubbling of the same 序贯事件（例如α4521，α6690），甚至在同一气泡之间\n // event (#6566). However, using (macro) tasks everywhere also has subtle problems 事件（α6566）。然而，到处使用（宏）任务也有微妙的问题。\n // when state is changed right before repaint (e.g. #6813, out-in transitions). 当状态在重新绘制之前被正确改变（例如，α6813，在过渡中出现）。\n // Here we use microtask by default, but expose a way to force (macro) task when 这里，我们默认使用微任务，但是暴露一种方法来强制（宏）任务\n // needed (e.g. in event handlers attached by v-on). 需要的（例如在事件处理程序中附加的V-on）。\n\n\n var microTimerFunc; //微计时器功能\n var macroTimerFunc; //宏计时器功能\n var useMacroTask = false; //使用宏任务\n\n // Determine (macro) task defer implementation. 确定（宏）任务延迟实现。\n // Technically setImmediate should be the ideal choice, but it's only available 技术上应该是理想的选择，但它是唯一可用的。\n // in IE. The only polyfill that consistently queues the callback after all DOM 在IE.中，唯一的填充在所有DOM之后始终排队回叫。\n // events triggered in the same loop is by using MessageChannel. 在同一循环中触发的事件是通过使用消息通道。\n /* istanbul ignore if */\n //判断setImmediate 是否存在，如果存在则判断下是是否是系统内置函数\n if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {\n //函数表达式赋值给macroTimerFunc\n macroTimerFunc = function () {\n\n setImmediate(flushCallbacks);\n };\n } else if (typeof MessageChannel !== 'undefined' && (\n isNative(MessageChannel) ||\n // PhantomJS\n MessageChannel.toString() === '[object MessageChannelConstructor]'\n )) {\n //如果有 消息体 内置函数则实例化\n var channel = new MessageChannel();\n //获取端口2\n var port = channel.port2;\n\n //设置端口1 的接受函数为flushCallbacks\n channel.port1.onmessage = flushCallbacks;\n\n //端口2推送信息给端口1\n macroTimerFunc = function () {\n\n port.postMessage(1);\n };\n } else {\n /* istanbul ignore next */\n // 异步执行\n macroTimerFunc = function () {\n\n setTimeout(flushCallbacks, 0);\n };\n }\n\n // Determine microtask defer implementation.\n //确定微任务延迟执行。\n /* istanbul ignore next, $flow-disable-line */\n if (typeof Promise !== 'undefined' && isNative(Promise)) {\n // 声明一个成功的 Promise\n var p = Promise.resolve();\n //microTimerFunc 一个异步 队列函数\n microTimerFunc = function () {\n p.then(flushCallbacks);\n // in problematic UIWebViews, Promise.then doesn't completely break, but 在有问题的UIWebVIEW中，Promise.then并没有完全崩溃，而是\n // it can get stuck in a weird state where callbacks are pushed into the 它可能会陷入一种怪异的状态，其中回调被推到\n // microtask queue but the queue isn't being flushed, until the browser 微任务队列，但队列没有刷新，直到浏览器\n // needs to do some other work, e.g. handle a timer. Therefore we can 需要做一些其他的工作，例如处理计时器。因此我们可以\n // \"force\" the microtask queue to be flushed by adding an empty timer. [强制]通过添加空计时器来刷新微任务队列。\n //如果是ios 执行下 noop 空函数\n if (isIOS) {\n setTimeout(noop);\n }\n };\n } else {\n // fallback to macro\n //回归宏\n\n microTimerFunc = macroTimerFunc;\n }\n\n /**\n * Wrap a function so that if any code inside triggers state change, 包装一个函数，如果内部的任何代码触发状态改变，\n * the changes are queued using a (macro) task instead of a microtask. 使用宏（宏）任务而不是微任务对这些队列进行排队\n */\n function withMacroTask(fn) {\n //宏任务\n return fn._withTask || (fn._withTask = function () {\n useMacroTask = true;\n var res = fn.apply(null, arguments);\n useMacroTask = false;\n return res\n })\n }\n\n //为callbacks 收集队列cb 函数 并且根据 pending 状态是否要触发callbacks 队列函数\n function nextTick(cb, ctx) {\n //cb 回调函数\n //ctx this的指向\n var _resolve;\n //添加一个回调函数到队列里面去\n\n callbacks.push(function () {\n if (cb) {\n //如果cb存在 并且是一个函数就执行\n try {\n cb.call(ctx);\n } catch (e) {\n //如果不是函数则报错\n handleError(e, ctx, 'nextTick');\n }\n } else if (_resolve) {\n //_resolve 如果存在则执行\n _resolve(ctx);\n }\n });\n console.log('==callbacks==')\n console.log(callbacks)\n console.log(pending)\n\n if (!pending) {\n\n pending = true;\n //执行异步宏任务\n if (useMacroTask) {\n\n macroTimerFunc(); //异步触发 或者 实现观察者 触发 callbacks 队列中的函数\n } else {\n microTimerFunc(); //异步触发 或者 实现观察者 触发 callbacks 队列中的函数\n }\n }\n\n\n // $flow-disable-line\n if (!cb && typeof Promise !== 'undefined') {\n //如果回调函数不存在 则声明一个Promise 函数\n return new Promise(function (resolve) {\n _resolve = resolve;\n })\n }\n }\n\n /* */\n\n var mark;\n var measure;\n\n {\n //浏览器性能监控\n var perf = inBrowser && window.performance;\n /* istanbul ignore if */\n if (\n perf &&\n perf.mark &&\n perf.measure &&\n perf.clearMarks &&\n perf.clearMeasures\n ) {\n mark = function (tag) {\n return perf.mark(tag);\n };\n measure = function (name, startTag, endTag) {\n perf.measure(name, startTag, endTag);\n perf.clearMarks(startTag);\n perf.clearMarks(endTag);\n perf.clearMeasures(name);\n };\n }\n }\n\n /*\n not type checking this file because flow doesn't play well with Proxy\n 不检查此文件，因为流不能很好地使用代理\n * */\n\n var initProxy;\n\n {\n //map 对象中的[name1,name2,name3,name4] 变成这样的map{name1:true,name2:true,name3:true,name4:true}\n /*全局api 匹配'Infinity,undefined,NaN,isFinite,isNaN,' +\n 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n 'require'\n */\n var allowedGlobals = makeMap(\n 'Infinity,undefined,NaN,isFinite,isNaN,' +\n 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n 'require' // for Webpack/Browserify\n );\n\n //不存在的key 发出警告\n var warnNonPresent = function (target, key) {\n warn(\n \"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" +\n 'referenced during render. Make sure that this property is reactive, ' +\n 'either in the data option, or for class-based components, by ' +\n 'initializing the property. ' +\n 'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',\n target\n );\n };\n\n //判断 系统内置 函数有没有 es6的Proxy 代理对象api\n var hasProxy =\n typeof Proxy !== 'undefined' && isNative(Proxy);\n\n if (hasProxy) {\n //这些修改键就是 Shift、Ctrl、Alt和 Meta（在 Windows键盘中是 Windows键，在苹果机中 是 Cmd 键）它们经常被用来修改鼠标事件的行为。\n var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');\n //声明代理拦截对象\n config.keyCodes = new Proxy(config.keyCodes, {\n set: function set(target, key, value) {\n if (isBuiltInModifier(key)) { //匹配键盘上的快捷键 'stop,prevent,self,ctrl,shift,alt,meta,exact'\n //避免在配置键代码中重写内置修改器： 在一些快捷键中不需要加vue事件修饰器\n warn((\"Avoid overwriting built-in modifier in config.keyCodes: .\" + key));\n return false\n } else {\n //记录不是快捷键的键盘码\n target[key] = value;\n return true\n }\n }\n });\n }\n\n var hasHandler = {\n has: function has(target, key) {\n var has = key in target;\n //是否含有全局api 就是window 的内置函数\n //全局api\n // var allowedGlobals = makeMap(\n // 'Infinity,undefined,NaN,isFinite,isNaN,' +\n // 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n // 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n // 'require' // for Webpack/Browserify\n // );\n\n var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';\n //如果 key 在target对象中 不存在 或者 isAllowed 不是全局api 并且 第一个字符不是_的时候 发出警告\n if (!has && !isAllowed) {\n //不存在key发出警告\n warnNonPresent(target, key);\n }\n //返回true\n return has || !isAllowed\n }\n };\n\n var getHandler = {\n get: function get(target, key) {\n //key必须是等于string 并且 key在target中含有属性或者方法\n if (typeof key === 'string' && !(key in target)) {\n //如果没有则发出警告\n warnNonPresent(target, key);\n }\n //返回target值\n return target[key]\n }\n };\n\n //初始化 代理 监听\n initProxy = function initProxy(vm) {\n if (hasProxy) {\n // determine which proxy handler to use 确定使用哪个代理处理程序\n var options = vm.$options; //获取vm中的参数\n //render 渲染 如果是渲染 并且含有_withStripped\n var handlers = options.render && options.render._withStripped\n ? getHandler //获取值\n : hasHandler; //判断内部函数，这样vue中模板就可以使用内置函数\n //实例化 代理对象，只是这里添加了 警告的日志而已\n vm._renderProxy = new Proxy(vm, handlers);\n } else {\n //如果不能代理直接赋值\n vm._renderProxy = vm;\n }\n };\n }\n\n /*\n * 实例化set对象\n * */\n\n var seenObjects = new _Set();\n\n /**\n * Recursively traverse an object to evoke all converted 递归遍历对象以唤起所有转换\n * getters, so that every nested property inside the object 吸收器，以便对象内的每个嵌套属性\n * is collected as a \"deep\" dependency. 被收集为一个“深度”依赖。\n * 为 seenObjects 深度收集val 中的key\n */\n function traverse(val) {\n // 搜索seen 为seen添加depId\n //seenObjects set对象\n // 为 seenObjects 深度收集val 中的key\n\n _traverse(val, seenObjects);\n //清除对象 给对象置空\n seenObjects.clear();\n }\n\n //搜集依赖\n /*\n * 搜索seen 为seen添加depId\n * 为 seenObjects 深度收集val 中的key\n *\n * */\n //看到这里\n function _traverse(val, seen) {\n console.log(val)\n console.log(seen.add)\n\n var i, keys;\n //判断是否是数组\n var isA = Array.isArray(val);\n //isFrozen 方法判断一个对象是否被冻结。 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen\n //val 是否是被VNode 实例化\n if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {\n return\n }\n console.log(val.__ob__)\n\n //如果val 有__ob__ 属性\n if (val.__ob__) {\n var depId = val.__ob__.dep.id;\n // seen 中是否含有depId 属性或者方法\n if (seen.has(depId)) {\n return\n }\n console.log(seen.add)\n\n // seen 是 seenObjects = new _Set(); add 就是set对象中的add方法，添加为一的值得key\n //如果没有则添加进去\n seen.add(depId);\n }\n //如果是数组\n if (isA) {\n i = val.length;\n //则循环检查 回调递归\n while (i--) {\n _traverse(val[i], seen);\n }\n } else {\n\n keys = Object.keys(val);\n i = keys.length;\n //如果是对象也循环递归检查\n while (i--) {\n _traverse(val[keys[i]], seen);\n }\n }\n }\n\n /*\n *\n * // normalizeEvent函数主要用于将传入的带有特殊前缀的事件修饰符分解为具有特定值的事件对象\n * cachedFn\n *\n function cached(fn) {\n var cache = Object.create(null);\n return (function cachedFn(str) {\n var hit = cache[str];\n return hit || (cache[str] = fn(str))\n })\n }\n * normalizeEvent 得到的是一个函数 如果传入的 name 中 在cache 对象中有值 则返回这个值\n * 如果该对象没有值则 调用该函数 并且用返回值 记录 当前执行函数返回值记录起来\n * */\n //该函数是过滤 vue 事件中的修饰符\n var normalizeEvent = cached(function (name) {\n //判断第一个字符是否是'&\n var passive = name.charAt(0) === '&';\n //slice()，返回一个新的字符串，该方法可从已有的数组中,或者字符串中返回选定的元素。\n name = passive ? name.slice(1) : name;\n\n //判断第一个字符串是否是~\n var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first\n\n //slice()，返回一个新的字符串，该方法可从已有的数组中,或者字符串中返回选定的元素。\n name = once$$1 ? name.slice(1) : name;\n //判断第一个位是否是 ！\n var capture = name.charAt(0) === '!';\n //slice()，返回一个新的字符串，该方法可从已有的数组中,或者字符串中返回选定的元素。\n name = capture ? name.slice(1) : name;\n return {\n name: name,\n once: once$$1,\n capture: capture,\n passive: passive\n }\n });\n\n //createFnInvoker 创建一个调用程序 创建一个钩子函数\n //createFnInvoker，如果事件只是个函数就为为事件添加多一个静态类， invoker.fns = fns; 把真正的事件放在fns。而 invoker 则是转义fns然后再运行fns\n function createFnInvoker(fns) {\n function invoker() {\n //获取传进来的参数，是一个数组\n var arguments$1 = arguments;\n\n //静态方法传进来的函数 赋值给fns\n var fns = invoker.fns;\n\n //判断fns 是否是一个数组\n if (Array.isArray(fns)) {\n //如果是数组 浅拷贝\n var cloned = fns.slice();\n //执行fns 数组中的函数 并且把 invoker arguments$1参数一个个传给fns 函数中\n for (var i = 0; i < cloned.length; i++) {\n\n cloned[i].apply(null, arguments$1);\n }\n } else {\n // return handler return value for single handlers\n //如果fns 不是数组函数，而是一个函数 则执行arguments$1参数一个个传给fns 函数中\n return fns.apply(null, arguments)\n }\n }\n\n invoker.fns = fns;\n return invoker //静态类\n }\n\n\n //更新事件 并且为新的值 添加函数 旧的值删除函数等功能\n function updateListeners(\n on, //新的事件\n oldOn, //旧的事件\n add, //添加事件函数\n remove$$1, //删除事件函数\n vm//vue 实例化对象\n ) {\n var name, def, cur, old, event;\n\n for (name in on) { // 遍历on\n def = cur = on[name]; //on 新的事件值\n old = oldOn[name]; //oldOn 对象中的 与 name 匹配 并且赋值 old 估计这个是旧的值\n event = normalizeEvent(name); //normalizeEvent 如果是事件，则过滤 事件修饰符\n\n /* istanbul ignore if */\n // isUndef 判断值存在 并且是空的 return v === undefined || v === null\n if (isUndef(cur)) {\n //如果不是生产环境\n \"development\" !== 'production' && warn(\n \"Invalid handler for event \\\"\" + (event.name) + \"\\\": got \" + String(cur),\n vm\n );\n } else if (isUndef(old)) { //判断旧的值是否存在 为空的时候 没有定义旧的事件\n\n if (isUndef(cur.fns)) { //如果函数不存在 则绑定函数\n //函数 获取钩子函数\n // 创建函数调用器并重新复制给cur和on[name]\n cur = on[name] = createFnInvoker(cur); //这个时候cur.fns就存在了\n }\n\n\n\n name = '&' + name; // mark the event as passive 将事件标记为被动的\n //添加事件\n add(\n event.name, //事件名称\n cur, // 转义过的事件 执行静态类\n event.once, //是否只触发一次的状态\n event.capture, // 事件俘获或是冒泡行为\n event.passive, // 检测事件修饰符 是否是 '&'\n event.params //事件参数\n );\n\n } else if (cur !== old) {\n //如果新的值不等于旧的值\n //则更新新旧值\n old.fns = cur;\n on[name] = old;\n }\n }\n for (name in oldOn) {\n //循环旧的值 为空的时候\n if (isUndef(on[name])) {\n //获取事件\n event = normalizeEvent(name);\n //删除旧的值的事件\n remove$$1(event.name, oldOn[name], event.capture);\n }\n }\n }\n\n /*\n *\n * 合并vue vnode 钩子函数，\n * def[hookKey] = invoker; //把钩子函数用对象存起来\n * */\n\n function mergeVNodeHook(def, hookKey, hook) {\n //判断def 是否 是vnode 实例化的对象\n if (def instanceof VNode) {\n // 重新赋值def 把def.data.hook 赋值给def\n def = def.data.hook || (def.data.hook = {});\n }\n\n var invoker;\n //获取旧的oldHook 钩子\n var oldHook = def[hookKey];\n\n function wrappedHook() {\n //执行钩子函数\n hook.apply(this, arguments);\n // important: remove merged hook to ensure it's called only once\n // and prevent memory leak\n //重要：删除合并钩子以确保只调用一次\n //和防止内存泄漏\n remove(invoker.fns, wrappedHook);\n }\n\n if (isUndef(oldHook)) { //如果旧的钩子函数没有 为空的时候\n // no existing hook 无现有钩 则创建一个钩子函数\n invoker = createFnInvoker([wrappedHook]);\n } else {\n /* istanbul ignore if 如果有老的钩子函数，并且fns钩子函数存在 并且已经合并过*/\n if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {\n // already a merged invoker 已合并的调用程序\n invoker = oldHook; //直接老的钩子函数直接覆盖新的钩子函数\n //为钩子函数的fns 添加一个函数\n invoker.fns.push(wrappedHook);\n } else {\n // existing plain hook\n invoker = createFnInvoker([oldHook, wrappedHook]);\n }\n }\n\n invoker.merged = true;\n //把钩子函数用对象存起来\n def[hookKey] = invoker;\n }\n\n /*\n extractPropsFromVNodeData 从 props属性中获取vnode数据\n extractPropsFromVNodeData循环propOptions对象，把驼峰的key转换成横杠的key。校验props属性的key是否和attrs属性值相同，如果相同删除掉attrs属性的同样key的值。获取props属性的值添加搞res对象中，返回出去\n *\n * */\n function extractPropsFromVNodeData(\n data, //tag标签属性数据\n Ctor, //组件构造函数VueComponent\n tag //tag标签名称\n ) {\n // we are only extracting raw values here.\n // validation and default values are handled in the child\n // component itself.\n //我们只是在这里提取原始值。\n //验证和默认值在孩子中被处理\n //组件本身。\n\n //获取Ctor 参数中的 props\n var propOptions = Ctor.options.props; //获取组件的props属性\n console.log(Ctor.options)\n\n //如果propOptions 属性是空或者不存在 这不执行下面代码\n if (isUndef(propOptions)) {\n return\n }\n\n\n var res = {};\n var attrs = data.attrs;\n var props = data.props;\n\n //如果data中的属性attrs或者props 属性 数据存在\n if (isDef(attrs) || isDef(props)) {\n //遍历propOptions props属性中的值\n for (var key in propOptions) {\n\n //altKey获取到一个函数，该函数功能是把 abCd 驼峰字母改写成 ab-c 如果是 aB cd 则是 ab cd\n //大写字母，加完减号又转成小写了 比如把驼峰 aBc 变成了 a-bc\n //匹配大写字母并且两面不是空白的 替换成 '-' + '字母' 在全部转换成小写\n\n var altKey = hyphenate(key);\n\n\n {\n //把key 转换成小写\n var keyInLowerCase = key.toLowerCase();\n //如果他们key不相同 并且 属性attrs存在 并且keyInLowerCase 属性存在 attrs对象中\n if (\n key !== keyInLowerCase &&\n attrs && hasOwn(attrs, keyInLowerCase)\n ) {\n //输出一个警告信息\n tip(\n \"Prop \\\"\" + keyInLowerCase + \"\\\" is passed to component \" +\n (formatComponentName(tag || Ctor)) + \", but the declared prop name is\" +\n \" \\\"\" + key + \"\\\". \" +\n \"Note that HTML attributes are case-insensitive and camelCased \" +\n \"props need to use their kebab-case equivalents when using in-DOM \" +\n \"templates. You should probably use \\\"\" + altKey + \"\\\" instead of \\\"\" + key + \"\\\".\"\n );\n }\n }\n //检查属性\n checkProp(\n res, //空对象\n props, //props 属性\n key, //propOptions 的原始key\n altKey, //转换后的 横杆key\n true\n ) ||\n checkProp(\n res,\n attrs,\n key,\n altKey,\n false\n );\n }\n }\n return res\n }\n\n\n //检查 属性 检查key和altKey 在hash属性对象中有没有，如果有则赋值给res对象\n function checkProp(\n res, //需要添加值的对象\n hash, // 属性对象\n key, // 原始key\n altKey, //转换后的 横杆key\n preserve //是否要删除hash 对象中的属性或者方法 状态 布尔值\n ) {\n //hash 值存在\n if (isDef(hash)) {\n //如果是hash对象中含有key 属性或者方法\n if (hasOwn(hash, key)) {\n //添加res值\n res[key] = hash[key];\n //preserve 不存在的时候则在hash对象中删除该key 属性或者方法\n if (!preserve) {\n delete hash[key];\n }\n return true\n } else if (hasOwn(hash, altKey)) { //如果是hash对象中含有altKey 属性或者方法\n //添加res值\n res[key] = hash[altKey];\n //preserve 不存在的时候则在hash对象中删除该key 属性或者方法\n if (!preserve) {\n delete hash[altKey];\n }\n return true\n }\n }\n return false\n }\n\n /* */\n\n // The template compiler attempts to minimize the need for normalization by 模板编译器试图最小化对规范化的需要。\n // statically analyzing the template at compile time. 在编译时静态分析模板。\n //\n // For plain HTML markup, normalization can be completely skipped because the 对于普通HTML标记，可以完全跳过标准化，因为\n // generated render function is guaranteed to return Array. There are 生成的渲染函数保证返回数组。有\n // two cases where extra normalization is needed: 需要额外标准化的两种情况：\n\n // 1. When the children contains components - because a functional component 当儿童包含组件时，因为函数组件\n // may return an Array instead of a single root. In this case, just a simple 可以返回数组而不是单个根。在这种情况下，只是一个简单的例子\n // normalization is needed - if any child is an Array, we flatten the whole 规范化是必要的-如果任何一个孩子是一个数组，我们扁平化整个\n // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep 和Array.prototype.concat在一起。保证仅为1级深\n // because functional components already normalize their own children. 因为功能组件已经规范了他们自己的孩子。\n\n //循环子节点children，把他连在一起，其实就是把伪数组变成真正的数组\n function simpleNormalizeChildren(children) {\n for (var i = 0; i < children.length; i++) {\n if (Array.isArray(children[i])) {\n return Array.prototype.concat.apply([], children)\n }\n }\n return children\n }\n\n // 2. When the children contains constructs that always generated nested Arrays, 2。当子类包含总是生成嵌套数组的结构时，\n // e.g.