vue动态绑定v-model属性名方式
vue动态绑定v-model属性名
1.目标
2.方案
vue双向绑定原理(v-model)
表单绑定
组件使用v-model
vue动态绑定v-model属性名 1.目标首先配置列，根据配置渲染表单，每个表单项绑定配置中的属性
2.方案<template v-for="(item) in showQueryColumns" >
<el-col :key="item.prop" :xs = "24" :sm = "12" :md="12" :lg = "12" :xl = "6">
<!--字符串类型-->
<el-form-item v-if="item.type==='string'" :label="$t(item.i18n)" :prop="item.prop">
<el-input v-model="form[item.prop]" clearable></el-input>
</el-form-item>
</el-col>
</template>
v-model绑定的必须是属性，可以使用方括号，取指定对象的属性
亲测有效
vue双向绑定原理(v-model)之前有整理过Vue响应式原理，响应式主要的效果是数据改变了就会引起页面修改。关于v-model我们也不陌生，vue的双向绑定指令，页面修改会引起数据修改，数据修改页面也会跟着改变。我们直到数据->页面是由vue的响应式原理实现的，那么该怎么做到页面->数据的修改呢？
表单绑定v-model一般我们是在表单元素上进行使用，因为视图能影响数据，本质上是这个视图需要可交互，因此表单是实现这一交互的前提。表单的使用是以<input>、<textarea>、<select>为核心。具体的使用细节这里就不一一细说了。
这里我们从模板解析开始分析，vue对v-model做了什么操作。
这里我们来看一些绑定在input上的v-model都经历了什么。
// 普通输入框
<input type="text" v-model="value1">
AST树的解析
模版的编译阶段，会调用var ast = parse(template.trim(), options)生成AST树，parse函数的起他细节这里不展开分析，我们只说模板属性上的解析processAttrs函数。
vue模板属性有两部分组成，一部分是指令，另一部分是普通的html标签属性。对于指令，出去v-on和v-bind，其他普通指令会执行addDirective过程。
// 处理模板属性
function processAttrs(el) {
var list = el.attrsList;
var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
for (i = 0, l = list.length; i < l; i++) {
name = rawName = list[i].name; // v-on:click
value = list[i].value; // doThis
if (dirRE.test(name)) { // 1.针对指令的属性处理
···
if (bindRE.test(name)) { // v-bind分支
···
} else if(onRE.test(name)) { // v-on分支
···
} else { // 除了v-bind，v-on之外的普通指令
···
// 普通指令会在AST树上添加directives属性
addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
if (name === 'model') {
checkForAliasModel(el, value);
}
}
} else {
// 2. 普通html标签属性
}
}
}
在AST产生阶段对事件指令v-on的处理是为AST树添加events属性。类似的，普通指令会在AST树上添加directives属性，我们可以看一下addDirective函数
// 添加directives属性
function addDirective (el,name,rawName,value,arg,isDynamicArg,modifiers,range) {
(el.directives || (el.directives = [])).push(rangeSetItem({
name: name,
rawName: rawName,
value: value,
arg: arg,
isDynamicArg: isDynamicArg,
modifiers: modifiers // 模板中添加的修饰符，如：.lazy、.number、.trim
}, range));
el.plain = false;
}
最终AST树上会多处一个属性对象
// AST
{
directives: {
{
rawName: 'v-model',
value: 'value',
name: 'v-model',
modifiers: undefined
}
}
}
render函数生成
render函数生成阶段，generate逻辑，其中genData会对模版的各个属性进行处理，最终返回拼接好的字符串模板，而对指令的处理会进入genDirectives函数
在genDirectives函数中，会拿到之前AST树中的directives对象，并遍历解析指令对象，最终以'directives:['包裹的字符串返回。
// directives render字符串的生成
function genDirectives (el, state) {
// 拿到指令对象
var dirs = el.directives;
if (!dirs) { return }
// 字符串拼接
var res = 'directives:[';
var hasRuntime = false;
var i, l, dir, needRuntime;
for (i = 0, l = dirs.length; i < l; i++) {
dir = dirs[i];
needRuntime = true;
// 对指令ast树的重新处理
var gen = state.directives[dir.name];
if (gen) {
// compile-time directive that manipulates AST.
// returns true if it also needs a runtime counterpart.
needRuntime = !!gen(el, dir, state.warn);
}
if (needRuntime) {
hasRuntime = true;
res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
}
}
if (hasRuntime) {
return res.slice(0, -1) + ']'
}
}
这里有一句关键代码var gen = state.directives[dir.name]，这里的的dir.name为model，这个model回去执行对应的model函数。我们来看一下model函数的逻辑。
unction model (el,dir,_warn) {
warn$1 = _warn;
// 绑定的值
var value = dir.value;
var modifiers = dir.modifiers;
var tag = el.tag;
var type = el.attrsMap.type;
{
// 这里遇到type是file的html，如果还使用双向绑定会报出警告。
// 因为File inputs是只读的
if (tag === 'input' && type === 'file') {
warn$1(
"<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
"File inputs are read only. Use a v-on:change listener instead.",
el.rawAttrsMap['v-model']
);
}
}
//组件上v-model的处理
if (el.component) {
genComponentModel(el, value, modifiers);
// component v-model doesn't need extra runtime
return false
} else if (tag === 'select') {
// select表单
genSelect(el, value, modifiers);
} else if (tag === 'input' && type === 'checkbox') {
// checkbox表单
genCheckboxModel(el, value, modifiers);
} else if (tag === 'input' && type === 'radio') {
// radio表单
genRadioModel(el, value, modifiers);
} else if (tag === 'input' || tag === 'textarea') {
// 普通input，如 text, textarea
genDefaultModel(el, value, modifiers);
} else if (!config.isReservedTag(tag)) {
genComponentModel(el, value, modifiers);
// component v-model doesn't need extra runtime
return false
} else {
// 如果不是表单使用v-model，同样会报出警告，双向绑定只针对表单控件。
warn$1(
"<" + (el.tag) + " v-model=\"" + value + "\">: " +
"v-model is not supported on this element type. " +
'If you are working with contenteditable, it\'s recommended to ' +
'wrap a library dedicated for that purpose inside a custom component.',
el.rawAttrsMap['v-model']
);
}
// ensure runtime directive metadata
//
return true
}
我们可以看到对于v-model的处理，在这一步上会根据使用场景处理调用不同的处理。单是对每种类型对应的事件处理响应机制也不同。因此我们需要针对不同的表单控件生成不同的render函数，所以需要产生不同的AST属性。model针对不同类型的表单控件有不同的处理分支。我们来看普通input标签的处理，genDefalutModel分支。
function genDefaultModel (el,value,modifiers) {
var type = el.attrsMap.type;
// v-model和v-bind值相同值，有冲突会报错
{
var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
if (value$1 && !typeBinding) {
var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
warn$1(
binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
'because the latter already expands to a value binding internally',
el.rawAttrsMap[binding]
);
}
}
// modifiers存贮的是v-model的修饰符。
var ref = modifiers || {};
// lazy,trim,number是可供v-model使用的修饰符
var lazy = ref.lazy;
var number = ref.number;
var trim = ref.trim;
var needCompositionGuard = !lazy && type !== 'range';
// lazy修饰符将触发同步的事件从input改为change
var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
var valueExpression = '$event.target.value';
// 过滤用户输入的首尾空白符
if (trim) {
valueExpression = "$event.target.value.trim()";
}
// 将用户输入转为数值类型
if (number) {
valueExpression = "_n(" + valueExpression + ")";
}
// genAssignmentCode函数是为了处理v-model的格式，允许使用以下的形式： v-model="a.b" v-model="a[b]"
var code = genAssignmentCode(value, valueExpression);
if (needCompositionGuard) {
// 保证了不会在输入法组合文字过程中得到更新
code = "if($event.target.composing)return;" + code;
}
// 添加value属性
addProp(el, 'value', ("(" + value + ")"));
// 绑定事件
addHandler(el, event, code, null, true);
if (trim || number) {
addHandler(el, 'blur', '$forceUpdate()');
}
}
function genAssignmentCode (value,assignment) {
// 处理v-model的格式，v-model="a.b" v-model="a[b]"
var res = parseModel(value);
if (res.key === null) {
// 普通情形
return (value + "=" + assignment)
} else {
// 对象形式
return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
}
}
该函数主要逻辑是两个部分，一部分是针对修饰符产生不同的事件处理字符串，二是为v-model产生的AST树，添加属性和事件相关的属性。其中最核心的两行代码是：
// 添加value属性
addProp(el, 'value', ("(" + value + ")"));
// 绑定事件属性
addHandler(el, event, code, null, true);
addHandler函数会为AST树添加事件相关的属性，addProp会为AST树添加props属性。最终AST树新增了两个属性。
到这里我们会发现，通过genDirective处理后，原先的AST树新增了两个属性。所以在字符串生成阶段同样需要处理props和event的分支
function genData$2 (el, state) {
var data = '{';
// 已经分析过的genDirectives
var dirs = genDirectives(el, state);
// 处理props
if (el.props) {
data += "domProps:" + (genProps(el.props)) + ",";
}
// 处理事件
if (el.events) {
data += (genHandlers(el.events, false)) + ",";
}
}
最终render函数的结果为：
"_c('input',
{
directives:[{
name:"model",
rawName:"v-model",
value:(message),
expression:"message"
}],
attrs:{"type":"text"},
domProps:{"value":(message)},
on:{
"input":function($event){
if($event.target.composing)
return;message=$event.target.value
}
}
})"
总结
如果到这里比较迷糊的话，我们来整理一下整体的流程
在生成AST阶段，处理到属性时进入processAttrs，在该函数中判断该属性是否为指令，是指令判断是不是v-on、v-bind，如果都不是就进入addDirective
通过addDirective函数为AST树上添加了directives中的一个对象
然后根据AST树，生成render函数过程中，需要在genData中调用genDirectives，进入指令处理流程。
genDirectives拿到指令对象后，会遍历指令对象，使用state.directives[dir.name]对指令对象进行解析和处理。这里的dir.name是model。会调用一个model函数，在该函数中根据v-model的应用标签类型，处理成不同的AST属性。input输入框类型，会调用genDefaultModel函数，在其中做类型判断，修饰符处理，然后通过addProp为AST添加props属性，addHandler会为AST语法树的events属性中添加对应事件监听。
最后根据AST语法树生成render函数时，绑定的属性会以props的形式存在domProps中，另一个是以事件的形式存储input事件，并保留在on属性中
patch真实节点
当我们的render函数生成以后，执行render函数，生成对应的vnode。
有了新的vnode以后需要执行patchVnode。前面得到的指令相关的信息会保留在vnode的data属性里，所以对属性的处理也会走针对指令处理的函数incokeCreateHooks。
在该函数中对指令的处理包括：
判断vnode data上存在domProps属性，调用 updateDOMProps更新input标签的value值
调用updateAttrs函数，根据attrs属性更新节点的属性值
判断vnode data上存在on属性，调用updateDomListeners为dom添加事件监听
总结：所以v-model语法糖最终是通过监听表单控件自身的某些事件（不同类型的标签会有不同的监听事件类型，后面会列出来），去影响自身的value值。等同于
<input type="text" :value="message" @input="(e) => {this.message = e.target.value}">
不同的表单控件绑定的事件总结
上面我们讲到v-model其实是一个语法糖，他本质包含了两个操作：
v-bind绑定了一个value属性
v-on指令给当前元素绑定对应事件，默认是input事件
原理说过了我们这里来整理一下，表单绑定v-model不同的控件到底是绑定了什么事件。
change事件
select
checkbox
radio
input事件
这是默认时间，当不是上面三种表单元素时，会解析成input事件，比如text、number等input元素和textarea
组件使用v-model由上面的原理我们可以看出来组件上使用v-model也是类似的流程，本质上是子父组件通信的语法糖。看一个使用案例：
var child = {
template: '<div><input type="text" :value="value" @input="emitEvent">{{value}}</div>',
methods: {
emitEvent(e) {
this.$emit('input', e.target.value)
}
},
props: ['value']
}
new Vue({
data() {
return {
message: 'test'
}
},
components: {
child
},
template: '<div id="app"><child v-model="message"></child></div>',
el: '#app'
})
父组件上使用v-model，子组件默认会利用名为value的prop和名为input的事件。
源码这里就不详细说了，子组件的vnode会为data.props添加data.model.value，并且给data.on添加data.model.callback。因此父组件的语法糖本质上可以修改为
<child :value = "message" @input="function(e){message = e}"</child>
显然，这种写法就是事件通信的写法，这个过程又回到对事件指令的分析过程了。因此我们可以很明显的意识到，组件使用v-model本质上还是一个子父组件通信的语法糖。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持软件开发网。