精华内容
下载资源
问答
  • 主要为大家详细介绍了Vue 3.0双向绑定原理的实现方法,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 本篇文章主要介绍了详解Vue双向数据绑定原理解析 ,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • vue3双向数据绑定原理

    2021-10-12 15:44:17
    1.1 通过ref起别名,通过$refs获取实例、 绑定input事件、将值定义在响应数据rective中 <input type="text" ref="reftxt" @input="getValue" :value="txt"> 1.2 导入需要的钩子 reactive(响应数据)、toRefs...

    1.1 通过ref起别名,通过$refs获取实例、 绑定input事件、将值定义在响应数据rective中

    <input type="text" ref="reftxt" @input="getValue" :value="txt">

    1.2  导入需要的钩子 reactive(响应数据)、toRefs(将响应数据转结果对象)、    getCurrentInstance(获取实例,相当于this)

    import {reactive,toRefs,getCurrentInstance} from "vue"

    1.3 在setup方法中操作

    export default{
      name:"Home",
      setup() {  //相当于vue2 beforeCreate 和created
       const state = reactive({
         txt:'',//1.绑定
       })
       let {ctx} =getCurrentInstance()// 2.获取实例
        const getValue=()=>{
           console.log('触发了');
           //this.$refs.reftxt.value    vue2语法
           state.txt=ctx.$refs.reftxt.value //vue3语法 3. 赋值
        }
        return {  //4.返回出去
        //  state,
         ...toRefs(state),
         getValue,
        }
      }
    }

    1.4 渲染数据

    {{txt}}

    总:

    <template>
    <!-- 双向数据绑定原理 -->
      <div class="container">
    
      <input type="text" ref="reftxt" @input="getValue" :value="txt">
      {{txt}}
    
      </div>
    </template>
    
    <script >
    import {reactive,toRefs,getCurrentInstance} from "vue"
    
    export default{
      name:"Home",
      setup() {
       const state = reactive({
         txt:'',//绑定
       })
       let {ctx} =getCurrentInstance()//获取实例
        const getValue=()=>{
           console.log('触发了');
           //this.$refs.reftxt.value    vue2语法
           state.txt=ctx.$refs.reftxt.value //vue3语法
        }
        return {
        //  state,
         ...toRefs(state),
         getValue,
        }
      }
    }
    </script>

    展开全文
  • 主要为大家详细介绍了Vue数据双向绑定底层实现原理,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 我在整理javascript高级程序设计的笔记的时候看到面向对象设计那章,讲到对象属性分为数据属性和访问器属性,我们平时用的js对象90%以上都只是用到数据属性;我们向来讲解下数据属性和访问器属性到底是什么? 数据属性:...
  • 受疫情影响,今年各行业不景气,各岗位的跳槽...(一)Vue2双向数据绑定原理 简单理解: vue2数据双向绑定是由数据劫持结合发布-订阅的模式实现的,通过object.defineProperty()来劫持对象属性的getter和setter操作,

    受疫情影响,今年各行业不景气,各岗位的跳槽形势也不是很高。所以趁此机会好好蓄力,复习面试题吧。现在中高级前端面试时都会被面试官问道原理性的知识。有些人就是实践很好,但就是理论知识不行。不过要想拿高薪,理论和实践还是要双结合的。

    Vue数据双向绑定原理

    在这里是需要区分vue2和vue3的,它们底层是不同的。

    (一)Vue2双向数据绑定原理

    简单理解:

    vue2数据双向绑定是由数据劫持结合发布-订阅的模式实现的,通过object.defineProperty()来劫持对象属性的getter和setter操作,在数据变动时发布消息给订阅者,触发响应的监听回调。

    通过object.defineProperty()这个方法接收3个参数,一个是定义属性的对象,第二个是要定义或者修改属性名,第三个是将被定义或者修改的属性描述符。

    object.defineProperty(obj, name,{
        get:function resultGetter() {
            
        },
        set:function resultSetter() {
            
        }
    })
    
    重要名词:
    • observer:数据监听器,监听数据对象进行遍历,包括子属性对象的属性都加上getter和setter。
    • compile:解析模板指令,将模板中的遍历替换成数据,然后初始化渲染页面视图,并将每个指令对应节点绑定更新函数,添加监听数据的订阅者,一旦数据又变化,收到通知,更新视图。
    • watcher:订阅者是observer和compile之间的通信桥梁,在自身实例化时往消息订阅器dep里添加自己,自身必须有个updata()方法,待属性变动dep.notice()通知时,能调用自身的updata()方法,并触发compiler中绑定的回调。
    • depend: 消息订阅器,当有多个订阅者的时候,需要有一个统一维护者。depend用来收集订阅者,内部维护了一个数组。
    详细分析:
    1. 我们已经知道实现双向数据绑定,首先要对数据进行劫持监听,所以我们需要设置一个监听器observer,用来监听所有属性。
    2. 每个属性都会有一个订阅者watcher,如果一旦属性发生变化,就需要告诉订阅者watcher看是否需要更新。
    3. 因为订阅者是有很多的,所有需要一个消息订阅器depend来专门收集这些订阅者,然后在监听器和订阅者之间进行统一管理。
    4. 接着还需要一个指令解析器compile,对每个节点元素进行扫描和解析,将相关指令对应初始化成一个订阅者,并替换模板数据或者绑定响应的函数,从而更新视图。

    (一)Vue3双向数据绑定原理

    面试中面试官也会问另外一个问题:Vue响应式原理中object.defineProperty缺陷?为什么在Vue3.0采用了proxy,抛弃了object.defineProperty? 它们的回答是一样的。

    因为vue2.0 object.defineProperty只能劫持对象属性,无法监控数组下标的变化,导致通过数据下标添加的元素不能实时响应的弊端。为了解决这个问题,经vue内部处理后,可以使用push()、pop() 、shift()、unshift()、splice()、sort()、reverse()进行hack处理,所以其他数组属性也是监测不到,具有一定的局限性。
    因为object.defineProperty只能劫持对象属性,从而需要对每个对象的每个属性进行遍历。vue2.0里是通过递归+遍历data对象来实现对数据的监控的,如果属性值是对象的话,还需要深度遍历。

    而Vue3.0中的proxy不仅可以代理对象,还可以代理数组,也可以代理动态添加的属性,有13种劫持操作:
    get 获取某个key值 (接收2个参数,目标值和目标值key值)
    set 设置某个key值 (目标值、目标的key值、要改变的值、改变前的原始值)
    apply 使用in 操作符判断某个key是否存在
    deleteProperty 删除一个property
    defineProperty 定义一个新的property

    展开全文
  • vue 双向数据绑定原理

    2020-08-18 14:21:10
    vue 双向数据绑定原理
  • 一、实现原理 1. 从数据到视图的更新,是需要对...3. 设置一个解析器Compiler,解析视图DOM中所有节点的指令,并将模板中的数据进行初始化,然后初始化对应的订阅器。 二、Observer监听器 Observer是一个数据监听...

    一、实现原理

    1. 从数据到视图的更新,是需要对数据进行监听劫持,这里我们设置一个监听器Observer来实现对所有数据的监听;

    2. 设置一个订阅者Watcher,收到属性的变化通知并执行相应的函数,从而更新视图;

    3. 设置一个解析器Compiler,解析视图DOM中所有节点的指令,并将模板中的数据进行初始化,然后初始化对应的订阅器。

    二、Observer监听器

    Observer是一个数据监听器,核心是Object.defineProperty(),对所有属性监听,利用递归来遍历所有的属性值,对其进行Object.defineProperty()操作。

    // observer.js文件
    function Observer(data) {    // 监听器
    	this.walk(data)
    }
    
    Observer.prototype = {
    	walk(data) {
    		if( !data || typeof data !== 'object') {
    			return false
    		}
    
    		Object.keys(data).forEach(key => { // 遍历操作
    			this.defineProperty(data, key, data[key])
    		})
    	},
    	defineProperty(data, key, val) { // set/get方法
    		this.walk(val) // key 对应的又是 字典对象时
    		
    		Object.defineProperty(data, key, {
    			enumerable: true,
    			configurable: false,
    			get() {
    				return val
    			},
    			set(newVal) {
    				if(val !== newVal) {
    					console.log('新值: '+ newVal);
    					val = newVal
    				}
    			}
    		})
    	}
    }
    
    // 测试数据
    var zhangsan = {
    	name: '张三',
    	age: 18,
    	score:{
    		math: 100,
    		english:90
    	}
    }
    
    // 添加监听
    new Observer(zhangsan)
    zhangsan.age = 20
    zhangsan.score.english = 99
    

    确保都数据中的每个属性都转为getter/setter方法!

    三、Dep订阅器

    在最开始的结构中,通过Observer劫持并监听数据,当属性发生改变时,即通知调用到Watcher执行界面的更新。

    这先建立一个简单的概念,Observer相当于作家,Watcher相当于读者(订阅者),现在是属于直接的关系。
    但假如有新的Watcher订阅者时,怎么办呢?

    这就还需要一个订阅器Dep,订阅器Dep是用来收集所有订阅者的。
    Dep相当于是杂志社,Watcher作为订阅者,首先需要向杂志社订阅杂志,这样当有新的杂志(消息)产生时,Dep才会通知Watcher,如下图所示:
    在这里插入图片描述

    // dep.js文件
    function Dep(){	// 订阅器
    	this.subs = []
    }
    
    Dep.prototype = {
    	addSub(watcher){		// 添加订阅者
    		this.subs.push(watcher)
    	},
    	
    	notify(){	// 通知订阅者
    		this.subs.forEach(watcher=>{
    			watcher.run()
    		})
    	}
    }
    

    四、Dep订阅器如何使用

    Dep主要的功能是添加新的订阅者,以及通知订阅者。
    但什么时候添加订阅者,什么是通知订阅者呢?

    - 当数据发生改变时,即set的时就要通知订阅者; [新杂志发布(数据更新set),这就是通知订阅者]
    - 在获取数据时,即get时添加订阅者; [想要阅读杂志,这要先获取到杂志(获取数据get)]
    

    杂志社和订阅者的示例,进行对比才知道为什么放在set或get方法中!
    在获取的时(get)就需要加上条件限制,并不是所有获取的都是 添加订阅者操作。

    // Observer.prototype中的defineProperty
    defineProperty(data, key, val) { // set/get方法
    	this.walk(val) // key 对应的又是 字典对象时
    	
    	// 订阅器
            var dep = new Dep()
    	
    	Object.defineProperty(data, key, {
    		enumerable: true,
    		configurable: false,
    		get() {
    			if(条件){	// 符合某个条件说明是新的订阅者,才进行添加操作
    				dep.addSub(watcher);
    			}
    			
    			return val;
    		},
    		set(newVal) {
    			if(val !== newVal) {
    				console.log('新值: '+ newVal);
    				val = newVal;
    				
    				// 通知订阅者
    				dep.notify()
    			}
    		}
    	})
    }
    

    五、Watcher订阅者

    Watcher订阅者,在开始的时就要是添加到Dep订阅器中(杂志社当有新的杂志产生时,才知道通知谁。

    其实也就是在Observer监听器的get方法中执行时,添加Watcher订阅者操作。但get方法会被调用多次,这就可以在Dep订阅器中添加一个Dep.target标识是否为新订阅者,添加成功后再将其去掉。
    记住: 只有是新的订阅者,才是添加操作,否则不添加操作!

    // watcher.js文件
    // vm Vue的实例
    // exp data中的key
    // cb 回调函数
    function Watcher(vm, exp, cb){
        this.vm = vm
        this.exp = exp
        this.cb = cb
        
        // 获取key对应的值,同时将watcher添加到Dep的队列中
        this.value = this.get() 
    }
    
    Watcher.prototype = {
    	get(){	// 获取数据时,添加订阅者
    		// 添加一个标识的意思
    		Dep.target = this
    		
    		// 获取值,即触发get方法 [添加订阅者]
    		var val = this.vm[this.exp]
    		
    		// 已经添加完成
    		Dep.target = null
    		
    		return val
    	},
    	update(){	// 更新界面
    		this.run()
    	},
    	run(){
    		var val = this.vm[this.exp]
    		
    		if(val != this.value){	// 新值和旧值判断
    			var oldValue = this.value
    			this.value = val
    			this.cb.call(this.vm, val, oldValue) // 回调函数
    		}
    	}
    }
    

    Observer监听器中,条件就有了,添加上即可:

    // observer.js文件的 Observer.prototype
    defineProperty(data, key, val) { 
    	this.walk(val) // key 对应的又是 字典对象时
    	
    	// 订阅器
    	var dep = new Dep()
    	
    	Object.defineProperty(data, key, {
    		enumerable: true,
    		configurable: false,
    		get() {    // Dep.target存储的就是Watcher实例
    			if(Dep.target){	// 判断是否要添加(新订阅者) 
    				dep.addSub(Dep.target)
    			}
    			
    			return val;
    		},
    		set(newVal) {
    			if(val !== newVal) {
    				console.log('新值: '+ newVal)
    				val = newVal
    				
    				// 通知订阅者
    				dep.notify()
    			}
    		}
    	})
    }
    

    基本流程操作,参考下图: 在这里插入图片描述

    六、效果

    从上图中可以看到,现阶段只是实现一个简单的从数据到视图的更新,后面我们再完善解析器Compiler(备注: 此时效果还是有问题的)。

    <!DOCTYPE html>
    <html>
    
    	<head>
    		<meta charset="UTF-8">
    		<title></title>
    	</head>
    
    	<body>
    		<div id="app">
    			<h3>名字: {{name}}</h3>
    			<h3>技能: {{skill}}</h3>
    		</div>
    
    		<div>
    			请输入你的名字:<input type="text" class="text" value="" />
    			<input type="button" class="bt" value="确定" />
    		</div>
    
    		<script src="dep.js" type="text/javascript" charset="utf-8"></script>
    		<script src="watcher.js" type="text/javascript" charset="utf-8"></script>
    		<script src="observer.js" type="text/javascript" charset="utf-8"></script>
    
    		<script type="text/javascript">
    			function Vue(options) {
    				this.el = options.el // 元素
    				this.data = options.data // 数据
    				this.watcher = {} // 属性、数据、元素 的关联
    
    				Object.keys(this.data).forEach(key => { // 数据代理
    					this.proxyKeys(key);
    				})
    
    				// 监听器
    				new Observer(this.data);
    
    				// 解析DOM
    				this.compile()
    			}
    
    			Vue.prototype = {
    				proxyKeys(key) {
    					var self = this
    					Object.defineProperty(this, key, {
    						enumerable: false,
    						configurable: true,
    						get() {
    							return self.data[key]
    						},
    						set(newVal) {
    							self.data[key] = newVal
    						}
    					})
    				},
    
    				compile() { // 解析DOM即更新数据
    					// 获取到对象绑定的元素
    					var ele = document.querySelector(this.el);
    
    					// 所有子元素
    					var childEls = ele.childNodes;
    
    					// 创建fragment
    					var fragment = document.createDocumentFragment();
    
    					// 获取到第一个子元素
    					var child = ele.firstChild;
    					while(child) {
    						// 将Dom元素移入fragment中
    						// appendChild: 如果被插入的节点已经存在于当前文档的文档树中,则那个节点会首先从原先的位置移除,然后再插入到新的位置
    						fragment.appendChild(child)
    						// 再获取第一个(其实就是下一个下一个的操作)
    						child = ele.firstChild
    					}
    
    					// 遍历所有子元素
    					[].slice.call(fragment.childNodes).forEach(el => {
    						var reg = /\{\{(.*)\}\}/;
    						var text = el.textContent;
    						if(reg.test(text)) {
    							var key = reg.exec(text)[1];
    							el.textContent = this.data[key];
    
    							// 新的订阅者
    							new Watcher(this, key, value=>{
            							ele.innerHTML = value;
        							})
    						}
    					})
    
    					// 添加
    					ele.appendChild(fragment)
    				}
    			}
    
    			// 创建Vue对象
    			var myVue = new Vue({
    				el: '#app',
    				data: {
    					name: '阿童木',
    					skill: 'web前端开发',
    				}
    			})
    
    			// 修改名字
    			document.querySelector('.bt').onclick = function() {
    				myVue.data.name = document.querySelector('.text').value
    			}
    		</script>
    	</body>
    
    </html>
    
    展开全文
  • vue3双向绑定实现原理

    2021-07-15 21:48:59
    一、vue3为什么要用proxy实现双向绑定? 1.object.defineProperty的缺点: 因为es5的object.defineProperty无法监听对象属性的删除和添加 不能监听数组的变化,除了push/pop/shift/unshift/splice/spObject.definert...

    一、vue3为什么要用proxy实现双向绑定?

    1.object.defineProperty的缺点:

    因为es5的object.defineProperty无法监听对象属性的删除和添加
    不能监听数组的变化,除了push/pop/shift/unshift/splice/spObject.definert/reverse,其他都不行
    Object.defineProperty只能遍历对象属性直接修改(需要深拷贝进行修改)
    

    2.proxy的优点:

    >1、直接监听对象而非属性
    >2、直接监听数组的变化
    >3、拦截的方式有很多种(13种,set,get,has)
    >4、Proxy返回一个新对象,可以操作新对象达到目的
    

    3.proxy的缺点:

    1、 proxy有兼容性问题,不能用polyfill来兼容(polyfill主要抚平不同浏览器之间对js实现的差异)

    二、实现Vue3双向绑定

    <!DOCTYPE html>
    <html lang="en">
    
    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
    </head>
    
    <body>
        <div></div>
        <script>
            const toProxy = new WeakMap(); //存放的是代理后的对象
            const toRaw = new WeakMap();   //存放的是代理前的对象
            function trigger() {
                console.log('触发视图更新')
            }
            function isObject(target) {
                return typeof target === 'object' && target !== null;
            }
            function reactive(target) {
                if (!isObject(target)) {
                    return target;
                }
                let proxy = toProxy.get(target)
                // 如果代理表中已经存在了  就把这个结果返回
                if (proxy) {
                    return proxy
                }
                // 如果这个对象已经被代理过了  就直接返回
                if (toRaw.has(target)) {
                    return target;
                }
                const handlers = {
                    set(target, key, value, receiver) {
                        if (target.hasOwnProperty(key)) {
                            trigger()
    
                        }
                        return Reflect.set(target, key, value, receiver)
                    },
                    get(target, key, value, receiver) {
                        const res = Reflect.get(target, key, receiver)
                        if (isObject(target[key])) {
                            return reactive(res)
                        }
                        return res;
                    },
                    deleteProperty(target, key) {
                        return Reflect.deleteProperty(target, key)
                    }
                }
                let observed = new Proxy(target, handlers)
                toProxy.set(target, observed);
                toRaw.set(observed, target)
                return observed
            }
            let obj = {
                name: '温小鹿',
                arr: [1, 2, 3]
            }
            // let p = reactive(obj)
            // p.name = 'jw'
            // let arr = [1, 2 ,3];
            // let p = reactive(arr)
            // p.push(4);
            // console.log(p)
    
            let p = reactive(obj)
            p = reactive(p)
            p = reactive(p)
            p.arr.push(4)
            console.log(p)
        </script>
    </body>
    
    </html>
    

    害,基础不扎实,复习一下
    Reflect是ES6为操作对象而提供的新API,proxy对象的方法在rReflect上都能找到
    new WeakMap() 是弱引用,在内存不足的时候垃圾回收机制才会回收,可以作为缓存

    展开全文
  • vue2与vue3双向绑定写法不同 vue使用Object.defineProperty来劫持对象属性 而vue3使用Proxy代理来实现双向绑定vue2: <div class="data"></div> <label>vue2:</label> <input ...
  • Vue 双向数据绑定原理

    万次阅读 2019-03-07 14:20:57
    vue.js 则是采用数据劫持结合发布者-订阅者模式的方式,通过Object.defineProperty()来...vue实现双向数据绑定原理就是利用了 Object.defineProperty() 这个方法重新定义了对象获取属性值(get)和设置属性值(set...
  • 原理Vue2.x): Vue.js它是采用数据劫持结合发布者-订阅者模式的方式,通过Object.defineProperty()来劫持各个属性的setter,getter;在数据变动时发布消息给订阅者,触发相应的监听回调。 我们知道,实现MVVM...
  • let toProxy ...// effect 会执行两次 默认先执行一次 之后依赖的数据变化了 再次执行 // console.log(obj.name); } ) obj . name = 'lokka' ; console . log ( obj . name ) ;
  • Vue 3.0双向绑定原理的实现

    千次阅读 2019-10-21 17:19:01
    proxy方法 vue.js 是采用数据劫持结合发布者-订阅者模式的方式,通过Object.defineProperty()来劫持各个属性的setter,getter,在数据变动时发布消息给订阅者,触发相应的...可查看Vue 2.0双向绑定原理的实现 具...
  • 本文主要介绍了vue双向数据绑定原理,文章结尾附上完整demo下载。具有一定的参考价值,下面跟着小编一起来看下吧
  • 理解VUE双向数据绑定原理和实现

    千次阅读 多人点赞 2021-02-26 12:04:02
    一、原理: 1.vue 双向数据绑定是通过 数据劫持 结合...2.核心:关于VUE双向数据绑定,其核心是 Object.defineProperty()方法; 3.介绍一下Object.defineProperty()方法 (1)Object.defineProperty(obj, prop, d...
  • vue.js是采用数据劫持结合发布者-订阅者模式的方式,通过Object.defineProperty()来劫持各个属性的setter,getter,在数据变动时发布消息给订阅者,触发相应的监听回调来渲染视图。 一: 需要observer的数据对象进行...
  • 在目前的前端面试中,vue双向数据绑定已经成为了一个非常容易考到的点,即使不能当场写出来,至少也要能说出原理。本篇文章中我将会仿照vue写一个双向数据绑定的实例,名字就叫myVue吧。结合注释,希望能让大家...
  • Vue数据双向绑定原理是通过数据劫持结合发布者-订阅者模式的方式来实现的,首先是对数据进行监听,然后当监听的属性发生变化时则告诉订阅者是否要更新,若更新就会执行对应的更新函数从而更新视图 MVC模式 以往的...
  • 前言 虽然工作中一直使用Vue作为基础库,但是对于其实现机理仅限于道听途说,这样对长期的技术发展很不利。所以最近攻读了其源码的一...Vue双向数据绑定的设计思想为观察者模式,为了方便,下文中将被观察的对象称
  • 简单探讨一下vue2.x和vue3.x中实现数据绑定的原理有什么不同,首先vue2.x使用的是Object....我们通过去写一个非常非常简化版的vue框架和demo来实现这个双向数据绑定,来看下实现过程 1 我们创建一个html模...
  • 原理 1.vue 双向数据绑定是通过数据劫持,结合发布订阅模式的方式来实现的, 也就是说数据和视图同步数据...2.vue实现双向数据绑定原理就是利用了 Object.defineProperty() 这个方法重新定义了对象获取属性值(g...
  • 先声明,该代码是网上一位大佬提供的,但是学习它的代码过程中...该压缩文件内容是vue数据双向绑定的实现与原理解析,提供核心完整代码,并有我的代码注释,浅显易懂,但是需要es6的学习和有一定的javascript基础才行。
  • 简述vue双向数据绑定原理

    千次阅读 2020-03-18 20:53:29
    MVVM MVVM全称是Model View ViewModel MVVM 由三部分组成分别是: M:Model ...我们需要在View中声明View(视图)上所显示的东西 与Model的哪部分的数据进行绑定。在ViewModel更新Model上的数据时,...
  • Vue双向数据绑定原理(面试必问)

    千次阅读 2021-01-08 14:26:31
    vue.js是采用数据劫持结合发布者-订阅者模式的方式,通过Object.defineProperty()来劫持各个属性的setter,getter,在数据变动时发布消息给订阅者,触发相应的监听回调来渲染视图。 具体步骤 需要observer的数据...
  • vue.js 是采用数据劫持结合发布者-订阅者模式的方式,通过Object.defineProperty()来劫持各个属性的setter,getter,在数据变动时发布消息给订阅者,触发相应的监听回调。 具体步骤: 第一步:需要observe的数据...
  • Vue双向数据绑定原理

    千次阅读 2021-04-13 00:21:16
    VUE双向数据绑定原理 vue双向数据绑定是通过 数据劫持,并结合 发布-订阅模式的方法来实现的,也就是说数据和视图同步,数据发生变化,视图跟着变化,视图变化,数据也随之发生改变 核心:关于vue实现双向数据...
  • 主要介绍了Vue双向数据绑定原理,帮助大家更好的理解和学习vue,感兴趣的朋友可以了解下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,956
精华内容 5,982
关键字:

vue3双向数据绑定原理

vue 订阅