Vue

import { useState } from "react";
import "./styles.css";

function One({ count, setCount }) {
  return (
    <div style={{ border: "1px solid red" }}>
      <h2>Conponent One</h2>
      <button onClick={() => setCount(count + 1)}>Click</button>
      <div>{count}</div>
    </div>
  );
}

function Two({ count, setCount }) {
  return (
    <div style={{ border: "1px solid red" }}>
      <h2>Conponent Two</h2>
      <button onClick={() => setCount(count + 1)}>Click</button>
      <div>{count}</div>
    </div>
  );
}

export default function App() {
  const [count, setCount] = useState(0);
  return (
    <div className="App">
      <One count={count} setCount={(c) => setCount(c)} />
      <Two count={count} setCount={(c) => setCount(c)} />
    </div>
  );
}

// 触发更新视图
function updateView() {
    console.log('视图更新')
}

// 重新定义数组原型
const oldArrayProperty = Array.prototype
// Object.create 方法  
// --->创建新对象，原型指向 oldArrayProperty ，再扩展新的方法不会影响原型
const arrProto = Object.create(oldArrayProperty);
['push', 'pop', 'shift', 'unshift', 'splice'].forEach(methodName => {
    arrProto[methodName] = function () {
        updateView() // 触发视图更新
        oldArrayProperty[methodName].call(this, ...arguments)
        // Array.prototype.push.call(this, ...arguments)
    }
})

// 重新定义属性，监听起来
function defineReactive(target, key, value) {
    // 深度监听
    observer(value)

    // 核心 API
    Object.defineProperty(target, key, {
        get() {
            return value
        },
        set(newValue) {
            if (newValue !== value) {
                // 深度监听
                observer(newValue)

                // 设置新值
                // 注意，value 一直在闭包中，此处设置完之后，再 get 时也是会获取最新的值
                value = newValue

                // 触发更新视图
                updateView()
            }
        }
    })
}

// 监听对象属性
function observer(target) {
    if (typeof target !== 'object' || target === null) {
        // 不是对象或数组
        return target
    }

    // 1.0 不可以这样处理 array 的方法  --->污染全局的 Array 原型
    // Array.prototype.push = function () {
    //     updateView()
    //     ...
    // }
		// 2.0 只能通过copy代理一份
    if (Array.isArray(target)) {
        target.__proto__ = arrProto
    }

    // 重新定义各个属性（for in 也可以遍历数组）
    for (let key in target) {
        defineReactive(target, key, target[key])
    }
}

// 准备数据
const data = {
    name: 'zhangsan',
    age: 20,
    info: {
        address: '北京' // 需要深度监听
    },
    nums: [10, 20, 30]
}

// 监听数据
observer(data)

// 测试
// data.name = 'lisi'
// data.age = 21
// // console.log('age', data.age)
// data.x = '100' // 新增属性，监听不到 —— 所以有 Vue.set
// delete data.name // 删除属性，监听不到 —— 所有已 Vue.delete
// data.info.address = '上海' // 深度监听
data.nums.push(4) // 监听数组

// 创建一个响应式对象的函数
function reactive(target) {
    // 定义处理程序对象，用于拦截对目标对象的操作
    const handlers = {
        // 当访问对象属性时触发此方法
        get: (obj, prop) => {
            console.log(`获取 ${prop} 的值`); // 打印获取的属性名
            // 使用 Reflect.get 来执行默认的属性获取操作，并返回结果
            return Reflect.get(obj, prop);
        },
        // 当设置对象属性时触发此方法
        set: (obj, prop, value) => {
            console.log(`设置 ${prop} 的新值为 ${value}`); // 打印设置的属性名和新值
            // 使用 Reflect.set 来执行默认的属性设置操作，并返回操作是否成功的结果
            const result = Reflect.set(obj, prop, value);
            trigger(); // 触发副作用函数重新运行
            return result;
        }
    };
    // 返回一个带有自定义处理程序的新代理对象
    return new Proxy(target, handlers);
}

// 触发副作用函数
let activeEffect; // 存储当前活跃的副作用函数

// 注册并立即执行副作用函数
function effect(fn) {
    activeEffect = fn; // 设置当前活跃的副作用函数
    fn(); // 立即执行副作用函数
    activeEffect = null; // 清除当前活跃的副作用函数
}

// 当数据改变时调用此函数以触发副作用
function trigger() {
    if (activeEffect) {
        // 如果存在当前活跃的副作用函数，则重新执行它
        activeEffect();
    }
}

// 使用示例
const state = reactive({ count: 0 }); // 创建一个响应式对象

effect(() => {
    // 注册一个副作用函数，该函数依赖于 state.count
    console.log(`count 的值是：${state.count}`); // 每当 state.count 变化时，这个函数会被重新执行
});

// 修改状态，这将触发副作用函数重新运行
state.count++; // 这里会打印 "设置 count 的新值为 1" 和 "count 的值是：1"

<input v-bind:value="searchText"
v-on:input="searchText=$event.target.value"/>

父beforeCreate-> 父create -> 子beforeCreate-> 子created -> 子mounted -> 父mounted