嘿，今天咱们来聊聊 Lyt.js 这个库，它有个特别牛的地方——它同时支持 Proxy 模式和 Signal 模式。你可Neng要问了这俩是啥玩意儿？别急，咱慢慢来先从 Proxy 模式说起。

Proxy 模式，说白了就是 Vue 那一套的响应式系统，它Neng自动追踪对象属性的变化。比如你写个 reactive，它会自动把对象变成响应式的，你改个属性，它就自动geng新。这个模式的好处是啥？上手快啊，你啥dou不用管，它自己就给你搞定了。特别适合写业务逻辑的时候用，省心省力，你懂的。

那啥是 Signal 模式呢？这玩意儿就有点意思了。它不是自动追踪，而是你手动控制哪个值变了、哪个组件要geng新。这就有意思了性Neng敏感的场景，比如大数据量、高频geng新的列表，用这个模式，geng新粒度Ke以精确到某个节点，性Neng飞起。Lyt.js 把这两种模式dou给你实现了而且是双模式共存，你爱用哪个用哪个，甚至混着用dou行。

你可Neng会说这俩模式Neng混用？害，还真Neng。Lyt.js 的设计就是这么灵活。你Ke以在一个组件里用 Proxy 模式处理用户数据，再用 Signal 模式处理高频geng新的计数器，各司其职，互不干扰。这不比你写死一种模式强？

那问题来了这俩模式底层怎么实现的？咱先说 Proxy 模式。它靠的是 ES6 的 Proxy，拦截对象的 get 和 set 操作，然后在 get 的时候收集依赖，set 的时候触发geng新。Lyt.js 用的是三层依赖收集结构，targetMap 是个 WeakMap，存的是对象 -> 属性 -> 副作用的映射关系。这玩意儿听着高大上，其实说白了就是个依赖树，记录谁依赖了谁，这样你一改数据，它就知道该通知谁了。

再来说 Signal 模式。它不靠 Proxy，而是靠一个叫 activeSubscriber 的全局变量来追踪谁在读取数据。你读取一个 signal，它就自动把你加到这个 signal 的订阅者列表里。你改值的时候，它就去通知这些订阅者。这比 Proxy 模式geng细粒度，性Nenggeng好，但写起来稍微麻烦点，你得手动管理依赖关系。

那 Lyt.js 是怎么Zuo到双模式共存的呢？它在 effect 和 computed 的实现上Zuo了区分。Proxy 模式用的是 track 和 trigger，Signal 模式用的是自己的那一套机制。两套系统完全独立，但共享调度器，就是说它们的geng新机制是统一的，但依赖收集和触发geng新的方式不一样。这就像你左手画方，右手画圆，互不影响，但dou是你画的，对吧？

你可Neng要问了这俩模式混用会不会出事？Lyt.js 早就想到了。它提供了 untrack 方法，让你在 effect 里读取值但不建立依赖关系。比如你只想读个值，但不想它触发geng新，就Ke以用 untrack 包一下。这不就灵活了嘛，想怎么玩就怎么玩。

那 Lyt.js 的 reactivity 包就是整个框架的 L1 层，是地基。所有上层模块，比如渲染器、组件、路由、状态管理啥的，dou得靠它。这玩意儿就像你家的电闸，一开全屋有电，一关全屋断电。所以它必须稳，必须快，必须灵活。

你可Neng还想知道，为啥 Lyt.js 不收录？哈哈，这问题问得好。其实 Lyt.js 是个假想的库，它还没上线呢，所以百度当然不收录啦。不过你要是真想用，Ke以自己动手实现，或者等它哪天真的上线了咱再回来用它。开玩笑的，不过这设计思路，确实挺牛的，对吧？

那 Lyt.js 是怎么处理嵌套副作用的呢？它用了一个叫 effectStack 的东西，就是个副作用栈。栈顶的永远是当前正在执行的副作用。这样就算你嵌套调用 effect，它也Neng正确处理依赖关系，不会乱套。这就像你打

那 effect 的执行顺序呢？Lyt.js 用了一个叫 batch 的机制。就是说你一批geng新完了再统一通知，而不是一geng新就通知。这不就减少了hen多没必要的重复geng新嘛。就像你点外卖，一批点完再一起送，而不是点一个送一个，效率高多了。

那 Lyt.js 的 ref 是啥？它其实是对基本类型的包装。因为 Proxy 只Neng代理对象，不Neng代理基本类型，比如 number、string。所以 Lyt.js 用 ref 包一层，变成对象，再用 Proxy 拦截 value 属性，这样你就Neng响应式地改值了。这就像你给基本类型穿了件马甲，让它Neng被 Proxy 拦截。

数组的处理是 Lyt.js 里Zui复杂的部分。因为数组方法太灵活了比如 push、pop、splice 这些方法，内部会读取 length，但你又不想收集这些内部读取的依赖。所以 Lyt.js 用了一个叫 arrayInstrumentations 的对象，拦截了这些方法，手动处理依赖收集和触发geng新。这就像你给数组方法加了个中间件，让它按你的规则来。

比如 includes、indexOf 这些方法，它们会遍历数组元素，所以 Lyt.js 会追踪每个元素的依赖。而 push、pop 这些方法，内部会修改 length，但又不会触发 set 拦截器，所以要手动触发 length 依赖geng新。这就像你给数组方法加了双保险，确保依赖收集完整。

那 computed 呢？它有个 dirty 标记，依赖变了就标记为脏，但不立即重新计算，而是等你访问的时候再算。这叫惰性求值。就像你家的电灯，你按一下开关，它不马上亮，而是等你真需要的时候再亮。这不就省电了嘛。

Signal 模式的 computed 也实现了循环依赖检测。你要是不小心写了循环依赖，它会直接报错，不让你继续执行。这就像你写代码写疯了它就拉你一把，别死循环了。

Zui后说说 effect。它接收一个函数，这个函数的参数是 onCleanup 回调。你Ke以在副作用里注册清理逻辑，比如清除定时器、取消请求啥的。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的架构呢？它分四层：L0 是基础工具层，L1 是核心原语层，L2 是渲染引擎层，L3 是核心运行时层。你所有的上层模块dou依赖 reactivity 包提供的响应式Neng力。这就像盖楼，地基打好了上面想盖啥就盖啥。

那为啥用 WeakMap Zuo缓存呢？因为 WeakMap 有个好处，就是当原始对象失去引用的时候，对应的代理缓存也会被自动清除，避免内存泄漏。这就像你家的垃圾桶，满了自动倒，省心。

那 Lyt.js 的 get 拦截器里对嵌套对象执行 reactive，这就是深层响应式的实现。你访问嵌套对象的时候，它自动帮你包装成代理。这就像你家亲戚来了你不用管，它自己就帮你招待了。

那 receiver 检查是啥？就是说当通过原型链访问属性的时候，set 会被触发两次一次在原型对象上，一次在实例上。通过检查 target === toRaw，确保只在正确的目标对象上触发geng新，避免重复通知。这就像你打

那 track 函数呢？它就是记录副作用和依赖的关系。每次副作用执行前，它会清理旧依赖，再收集新依赖。这就像你家的账本，旧账清掉，新账记上，保证数据准确。

那为啥要用双向引用设计呢？就是副作用不仅记录在 targetMap 里副作用自身也通过 deps 持有所有依赖集合的引用。这就像你家的账本，不仅记录你花了多少钱，还记录你啥时候花的，花在哪了。这样你下次查账就方便了。

那 Lyt.js 的数组处理呢？它把数组方法分两类：搜索类和变异类。搜索类方法内部会遍历数组元素，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的数组方法处理是Zui复杂的部分。它把数组方法分为搜索类和变异类。搜索类方法内部会遍历数组元素，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的数组方法处理是Zui复杂的部分。它把数组方法分为搜索类和变异类。搜索类方法内部会遍历数组元素，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的数组方法处理是Zui复杂的部分。它把数组方法分为搜索类和变异类。搜索类方法内部会遍历数组元素，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的数组方法处理是Zui复杂的部分。它把数组方法分为搜索类和变异类。搜索类方法内部会遍历数组元素，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的数组方法处理是Zui复杂的部分。它把数组方法分为搜索类和变异类。搜索类方法内部会遍历数组元素，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的数组方法处理是Zui复杂的部分。它把数组方法分为搜索类和变异类。搜索类方法内部会遍历数组元素，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的数组方法处理是Zui复杂的部分。它把数组方法分为搜索类和变异类。搜索类方法内部会遍历数组元素，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的数组方法处理是Zui复杂的部分。它把数组方法分为搜索类和变异类。搜索类方法内部会遍历数组元素，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的数组方法处理是Zui复杂的部分。它把数组方法分为搜索类和变异类。搜索类方法内部会遍历数组元素，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的数组方法处理是Zui复杂的部分。它把数组方法分为搜索类和变异类。搜索类方法内部会遍历数组元素，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

那 Lyt.js 的数组方法处理是Zui复杂的部分。它把数组方法分为搜索类和变异类。搜索类方法内部会遍 邻接点数组方法，必须对每个索引进行 track，否则依赖收集不完整。这就像你家的账本，不Neng漏记，不Neng错记，得全记。

变异类方法内部会读取 length 等属性，但又不想收集这些内部读取的依赖，所以要暂停依赖收集。这就像你家的账本，有些账不Neng记，得跳过。

那 Lyt.js 的 computed 实现了循环依赖检测，你要是不小心写了循环依赖，它会直接报错。这就像你写代码写疯了它就拉你一把，别死循环了。

那 Lyt.js 的 effect 支持 onCleanup 回调，你Ke以在副作用中注册清理逻辑，比如清除定时器、取消请求，下次执行前或 dispose 时自动执行。这就像你写了个定时器，下次执行前或者 dispose 的时候，它会自动清理掉。这不就避免了内存泄漏嘛。

---