An article explaining the principle of reactivity in Vue in detail

This article will help you learn Vue and gain an in-depth understanding of the responsiveness principles in Vue. I hope it will be helpful to you!

This article commemorates the passing of responsive syntax sugar

Without further ado, let’s get straight to the point. Responsiveness is Applications in daily development are very common. Here is a simple example:

let a=3
let b=a*10
console.log(b)//30
a=4
console.log(b)//40

At this time we want b=4*10, which is obviously not possible, even if we add a ## in front #var will only variable promotion, the value we give will not be promoted.

At this time, the role of responsiveness is reflected:

import { reactive } from 'vue'

let state = reactive({ a: 3 })
let b = computed(() => state.a * 10)
console.log(b.value) // 30
state.a = 4
console.log(b.value) // 40

Only a simple

responsive API can achieve the effect of tracking changes. [Related recommendations: vuejs video tutorial, web front-end development]

Analyze reactive

In fact, Vue3

reactive is essentially a publish-subscribe model

by creating a dependency graph to track data dependencies. A dependency graph is a graph that describes which data depends on which data. When the data changes, Vue 3's

reactive system will automatically trigger an update of the view. This is because it tracks data changes in the dependency graph and achieves this by associating it with updates to the view

Here I list the code demonstrated by Youda in Vue Master as a simple example :

class Dep{
    constructor(value){
        this.subscribers=new Set()
        this._value=value
    }
    get value(){
        this.depend()
        return this._value
    }
    set value(newValue){
        this._value=newValue
        this.notify()
    }
    depend(){
        if(activeEffect){
            this.subscribers.add(activeEffect)
        }
    }
    notify(){
        this.subscribers.forEach(effect=>{
            effect()
        })
    }
}

Let’s analyze this code:

Define a
• subscribe attribute as a subscriber list to store all Subscriber information
• depend function is used to manage dependency relationships, that is, the variable
• notify function on which the subscriber depends is used as a notification The value of this variable has changed for all subscribers

When the value of the variable changes, it can automatically notify all subscribers to update

Vue2’s Object.defineProperty

In fact, in the Vue2 period, responsiveness was implemented by

Object.defineProperty, but in Vue3 it was switched to Proxy, let’s wait and see the reason combined with the actual code; let’s first take a look at how Vue2 is implemented:

function reactive(raw){
    Object.keys(raw).forEach(ket=>{
        const dep=new Dep()
        let value=raw[key]
        
        Object.definProperty(raw,key,{
            get(){
                dep.depend()
                return value
            },
            //当属性发生
            set(newValue){
                value=newValue
                dep.notify()
            }
        })
    })
    //这时候返回的原始对象已经具有响应性
    return raw
}

Such a simple reactive API is implemented

But the shortcomings here are obvious:

In Vue 2.x, the object passed in will be directly changed by Vue.observable But in Vue3, it is Will return a responsive proxy, but directly changing the source object is still unresponsive

This leads to:

When When we
• add or delete the properties of the object, Vue2's responsiveness cannot be detected. Since Vue will perform getter/setter conversion on the property when initializing the instance, the property must be in data Only when it exists on the object can Vue convert it into a responsive
Unable to detect the
• subscript and length changes of the array

Of course, this is a historical limitation. At that time, ES5 could only choose

Object.definProperty, but in the ES6 version, there are more Proxy. At this time, Vue’s response The formula has been upgraded

Vue3’s Proxy

Vue3 uses

Proxy to monitor data changes. Compared with Vue2, it not only solves In addition to the above problems, there are also these advantages:

No need to use
• vue.$set to trigger reactivity, which makes the code look more Introduction
Comprehensive array change detection, eliminating invalid boundary conditions in Vue2
Reduces the amount of responsive code written in Vue3, which makes our development more convenient

Let's take a look at what the actual code looks like:

const reactiveHandles={
    get(target,key,receiver){
        const dep=getDep(target,key)
        dep.depend()
        return Reflect.get(target,key,receiver)
    },
    set(target,key,value,receiver){
        const dep=getDep(target,key)
        const result=Reflect.set(target,key,value,receiver)
        dep.notify()
        return result
    }
}

The responsive way is to

collect dependencies on objects. The essence of Vue3 responsiveness

ref

There is a sentence in the official documentation: The various limitations of

reactive() are ultimately because JavaScript cannot function The "reference" mechanism for all value types, and the limitation of reactive is:

can only handle observable data structures, such as arrays and objects; and unobservable data structures , such as primitive data types, they cannot be monitored
• Can only process data defined in the component where it is located, and cannot process global variables

And this time it is needed

ref is here, ref was born for basic data type, which makes up for the shortcomings of reactive. To put it simply, ref is more suitable for simple single variable values ​​(but in actual development Most of the time it’s just refs. Hahahaha

By the way, it’s a pity that the responsive syntax sugar proposal was cancelled

(Learning video sharing: vuejs introductory tutorial, Basic programming video)

The above is the detailed content of An article explaining the principle of reactivity in Vue in detail. For more information, please follow other related articles on the PHP Chinese website!