Vue.prototype._render = function (): VNode {
 const vm: Component = this
 const { render, _parentVnode } = vm.$options
 // ... 
 // set parent vnode. this allows render functions to have access
 // to the data on the placeholder node.
 vm.$vnode = _parentVnode
 // render self
 let vnode
 try {
  vnode = render.call(vm._renderProxy, vm.$createElement)
 } catch (e) {
  handleError(e, vm, `render`)
  // return error render result,
  // or previous vnode to prevent render error causing blank component
  /* istanbul ignore else */
  if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
  try {
   vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e)
  } catch (e) {
   handleError(e, vm, `renderError`)
   vnode = vm._vnode
  }
  } else {
  vnode = vm._vnode
  }
 }
 // if the returned array contains only a single node, allow it
 if (Array.isArray(vnode) && vnode.length === 1) {
  vnode = vnode[0]
 }
 // return empty vnode in case the render function errored out
 if (!(vnode instanceof VNode)) {
  if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
  warn(
   'Multiple root nodes returned from render function. Render function ' +
   'should return a single root node.',
   vm
  )
  }
  vnode = createEmptyVNode()
 }
 // set parent
 vnode.parent = _parentVnode
 return vnode
 }

/* istanbul ignore else */
if (process.env.NODE_ENV !== 'production') {
 initProxy(vm)
} else {
 vm._renderProxy = vm
}

let initProxy
// ...
initProxy = function initProxy (vm) {
 if (hasProxy) {
 // determine which proxy handler to use
 const options = vm.$options
 const handlers = options.render && options.render._withStripped
  "htmlcode">

const hasProxy =
 typeof Proxy !== 'undefined' && isNative(Proxy)




用来判断浏览器是否支持es6的Proxy。


Proxy作用是在访问一个对象时，对其进行拦截，new Proxy的第一个参数表示所要拦截的对象，第二个参数是用来定制拦截行为的对象。
开发环境，如果支持Proxy就会对vm实例进行拦截，否则和生产环境相同，直接将vm赋值给vm._renderProxy。具体的拦截行为通过handlers对象指定。


当手写render函数时，handlers = hasHandler，通过template生成的render函数，handlers = getHandler。 hasHandler代码：




const hasHandler = {
 has (target, key) {
 const has = key in target
 const isAllowed = allowedGlobals(key) ||
  (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data))
 if (!has && !isAllowed) {
  if (key in target.$data) warnReservedPrefix(target, key)
  else warnNonPresent(target, key)
 }
 return has || !isAllowed
 }
}




getHandler代码




const getHandler = {
 get (target, key) {
 if (typeof key === 'string' && !(key in target)) {
  if (key in target.$data) warnReservedPrefix(target, key)
  else warnNonPresent(target, key)
 }
 return target[key]
 }
}




hasHandler，getHandler分别是对vm对象的属性的读取和propKey in proxy的操作进行拦截，并对vm的参数进行校验，再调用 warnNonPresent 和 warnReservedPrefix 进行Warn警告。


可见，initProxy方法的主要作用就是在开发时，对vm实例进行拦截发现问题并抛出错误，方便开发者及时修改问题。

参数 vm.$createElement
vm.$createElement就是手写render函数时传入的createElement函数，它定义在initRender方法中，initRender在new Vue初始化时执行，参数是实例vm。




export function initRender (vm: Component) {
 // ...
 // bind the createElement fn to this instance
 // so that we get proper render context inside it.
 // args order: tag, data, children, normalizationType, alwaysNormalize
 // internal version is used by render functions compiled from templates
 vm._c = (a, b, c, d) => createElement(vm, a, b, c, d, false)
 // normalization is always applied for the public version, used in
 // user-written render functions.
 vm.$createElement = (a, b, c, d) => createElement(vm, a, b, c, d, true)
 // ...
}


从代码的注释可以看出: vm.$createElement是为开发者手写render函数提供的方法，vm._c是为通过编译template生成的render函数使用的方法。它们都会调用createElement方法。


02  createElement方法
createElement方法定义在 src/core/vdom/create-element.js 文件中




const SIMPLE_NORMALIZE = 1
const ALWAYS_NORMALIZE = 2
// wrapper function for providing a more flexible interface
// without getting yelled at by flow
export function createElement (
 context: Component,
 tag: any,
 data: any,
 children: any,
 normalizationType: any,
 alwaysNormalize: boolean
): VNode | Array<VNode> {
 if (Array.isArray(data) || isPrimitive(data)) {
 normalizationType = children
 children = data
 data = undefined
 }
 if (isTrue(alwaysNormalize)) {
 normalizationType = ALWAYS_NORMALIZE
 }
 return _createElement(context, tag, data, children, normalizationType)
}


createElement方法主要是对参数做一些处理，再调用_createElement方法创建vnode。


下面看一下vue文档中createElement能接收的参数。




// @returns {VNode}
createElement(
 // {String | Object | Function}
 // 一个 HTML 标签字符串，组件选项对象，或者
 // 解析上述任何一种的一个 async 异步函数。必需参数。
 'div',

 // {Object}
 // 一个包含模板相关属性的数据对象
 // 你可以在 template 中使用这些特性。可选参数。
 {
 },

 // {String | Array}
 // 子虚拟节点 (VNodes)，由 `createElement()` 构建而成，
 // 也可以使用字符串来生成“文本虚拟节点”。可选参数。
 [
 '先写一些文字',
 createElement('h1', '一则头条'),
 createElement(MyComponent, {
  props: {
  someProp: 'foobar'
  }
 })
 ]
)


文档中除了第一个参数是必选参数，其他都是可选参数。也就是说使用createElement方法的时候，可以不传第二个参数，只传第一个参数和第三个参数。刚刚说的参数处理就是对这种情况做处理。




if (Array.isArray(data) || isPrimitive(data)) {
 normalizationType = children
 children = data
 data = undefined
}




通过判断data是否是数组或者是基础类型，如果满足这个条件，说明这个位置传的参数是children，然后对参数依次重新赋值。这种方式被称为重载。


重载：函数名相同,函数的参数列表不同(包括参数个数和参数类型)，至于返回类型可同可不同。
处理好参数后调用_createElement方法创建vnode。下面是_createElement方法的核心代码。




export function _createElement (
 context: Component,
 tag"htmlcode">

// 1. When the children contains components - because a functional component
// may return an Array instead of a single root. In this case, just a simple
// normalization is needed - if any child is an Array, we flatten the whole
// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
// because functional components already normalize their own children.
export function simpleNormalizeChildren (children: any) {
 for (let i = 0; i < children.length; i++) {
  if (Array.isArray(children[i])) {
   return Array.prototype.concat.apply([], children)
  }
 }
 return children
}

// 2. When the children contains constructs that always generated nested Arrays,
// e.g. <template>, <slot>, v-for, or when the children is provided by user
// with hand-written render functions / JSX. In such cases a full normalization
// is needed to cater to all possible types of children values.
export function normalizeChildren (children: any): "htmlcode">

export default class VNode {
 tag: string | void;
 data: VNodeData | void;
 children: "color: #ff0000">03   vnode && vdom

createElement 返回的vnode并不是真正的dom元素，VNode的全称叫做“虚拟节点 (Virtual Node)”，它所包含的信息会告诉 Vue 页面上需要渲染什么样的节点，及其子节点。我们常说的“虚拟 DOM（Virtual Dom）”是对由 Vue 组件树建立起来的整个 VNode 树的称呼。


04  心得
读源码切忌只看源码，一定要结合具体的使用一起分析，这样才能更清楚的了解某段代码的意图。就像本文render函数，如果从来没有使用过render函数，直接就阅读这块源码可能会比较吃力，不妨先看看文档，写个demo，看看具体的使用，再对照使用来分析源码，这样很多比较困惑的问题就迎刃而解了。
总结
以上所述是小编给大家介绍的vue 中Virtual Dom被创建的方法,希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对网站的支持！

如果你觉得本文对你有帮助，欢迎转载，烦请注明出处，谢谢！

                                
                                

                                    vue,Virtual,Dom 
                                

                                    标签：
                                        
vue,Virtual,Dom
                                     

                                
蝙蝠岛资源网 Design By www.hbtsch.com