Vue中的虚拟dom，手把手教你在前端-Studio上分析内存泄漏

本文链接：https://blog.csdn.net/rr8f2haQf/article/details/136852531

data: any,

children: any,

normalizationType: any,

alwaysNormalize: boolean

): VNode | Array {

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 方法的封装，对参数的传入进行了判断

export function _createElement(

context: Component,

tag?: string | Class | Function | Object,

data?: VNodeData,

children?: any,

normalizationType?: number

): VNode | Array {

if (isDef(data) && isDef((data: any).ob)) {

process.env.NODE_ENV !== ‘production’ && warn(

Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n +

‘Always create fresh vnode data objects in each render!’,

context`

)

return createEmptyVNode()

}

// object syntax in v-bind

if (isDef(data) && isDef(data.is)) {

tag = data.is

}

if (!tag) {

// in case of component :is set to falsy value

return createEmptyVNode()

}

…

// support single function children as default scoped slot

if (Array.isArray(children) &&

typeof children[0] === ‘function’

) {

data = data || {}

data.scopedSlots = { default: children[0] }

children.length = 0

}

if (normalizationType === ALWAYS_NORMALIZE) {

children = normalizeChildren(children)

} else if ( === SIMPLE_NORMALIZE) {

children = simpleNormalizeChildren(children)

}

// 创建VNode

…

}

可以看到_createElement接收5个参数：

context 表示 VNode 的上下文环境，是 Component 类型
tag 表示标签，它可以是一个字符串，也可以是一个 Component
data 表示 VNode 的数据，它是一个 VNodeData 类型
children 表示当前 VNode的子节点，它是任意类型的
normalizationType 表示子节点规范的类型，类型不同规范的方法也就不一样，主要是参考 render 函数是编译生成的还是用户手写的

根据normalizationType 的类型，children会有不同的定义

if (normalizationType === ALWAYS_NORMALIZE) {

children = normalizeChildren(children)

} else if ( === SIMPLE_NORMALIZE) {

children = simpleNormalizeChildren(children)

}

simpleNormalizeChildren方法调用场景是 render 函数是编译生成的

normalizeChildren方法调用场景分为下面两种：

render 函数是用户手写的

编译 slot、v-for 的时候会产生嵌套数组

无论是simpleNormalizeChildren还是normalizeChildren都是对children进行规范（使children 变成了一个类型为 VNode 的 Array），这里就不展开说了

规范化children的源码位置在：src/core/vdom/helpers/normalzie-children.js

在规范化children后，就去创建VNode

let vnode, ns

// 对tag进行判断

if (typeof tag === ‘string’) {

let Ctor

ns = (context. $KaTeX parse error: Expected 'EOF', got '&' at position 7: vnode &̲& context.$ vnode.ns) || config.getTagNamespace(tag)

if (config.isReservedTag(tag)) {

// 如果是内置的节点，则直接创建一个普通VNode

vnode = new VNode(

config.parsePlatformTagName(tag), data, children,

undefined, undefined, context

)

} else if (isDef(Ctor = resolveAsset(context.$options, ‘components’, tag))) {

// component

// 如果是component类型，则会通过createComponent创建VNode节点

vnode = createComponent(Ctor, data, context, children, tag)

} else {

vnode = new VNode(

tag, data, children,

undefined, undefined, context

)

}

} else {

// direct component options / constructor

vnode = createComponent(tag, data, context, children)

}

createComponent同样是创建VNode

源码位置：src/core/vdom/create-component.js

export function createComponent (

Ctor: Class | Function | Object | void,

data: ?VNodeData,

context: Component,

children: ?Array,

tag?: string

): VNode | Array | void {

if (isUndef(Ctor)) {

return

}

// 构建子类构造函数

const baseCtor = context.$options._base

// plain options object: turn it into a constructor

if (isObject(Ctor)) {

Ctor = baseCtor.extend(Ctor)

}

// if at this stage it’s not a constructor or an async component factory,

// reject.

if (typeof Ctor !== ‘function’) {

if (process.env.NODE_ENV !== ‘production’) {

warn(Invalid Component definition: ${String(Ctor)}, context)

}

return

}

// async component

let asyncFactory

if (isUndef(Ctor.cid)) {

asyncFactory = Ctor

Ctor = resolveAsyncComponent(asyncFactory, baseCtor, context)

if (Ctor === undefined) {

return createAsyncPlaceholder(

asyncFactory,

data,

context,

children,

tag

)

}

data = data || {}

// resolve constructor options in case global mixins are applied after

// component constructor creation

resolveConstructorOptions(Ctor)

// transform component v-model data into props & events

if (isDef(data.model)) {

transformModel(Ctor.options, data)

}

// extract props

const propsData = extractPropsFromVNodeData(data, Ctor, tag)

// functional component

if (isTrue(Ctor.options.functional)) {

return createFunctionalComponent(Ctor, propsData, data, context, children)

}

// extract listeners, since these needs to be treated as

// child component listeners instead of DOM listeners

const listeners = data.on

// replace with listeners with .native modifier

// so it gets processed during parent component patch.

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Web前端开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。