ElTree组件的内部原理
ElTree组件的内部原理
最近一直在做Element3的Tree组件开发,这里就记录一下Tree组件的思想和内部实现原理,也对想要学习源码的童鞋的一个帮助吧。
设计思想
在设计Tree组件的时候是采用两颗树进行互相映射的方案进行设计的,一颗树是客户自己设置节点构成的树RawNode,另一颗是内部进行渲染的树TreeNode。当RawNode某个节点的值变更后Mapper就会得到通知,而后通过通知的内容对TreeNode进行更改。
核心思想
整个组件的难点就是在Mapper这里,他需要完成:
- 节点转换与映射
- 变更监听
- 响应更改
而这里需要注意的两点是:
- 在
RawNode变更后Mapper要对TreeNode进行修改,但是在修改TreeNode后不能在通知变更去修改RawNode - 在监听节点的时候,需要对存储子节点的数组进行监听(children)
这里就引出了一个重要的问题如何监听一个节点的变化?
这里就要说一下ES6的一个新的类Proxy,顾名思义就是代理商,他可以对一个对象进行阻拦如:
- 读取属性阻拦 get
- 修改属性阻拦 set
- 删除属性阻拦 deleteProperty
- 等等 https://es6.ruanyifeng.com/#docs/proxy
这里Proxy还有个特性就是,在修改原始对象的时候不会触发阻拦,通过这个特性就很好处理了注意点1
Proxy还有一个特性就是,每次在修改前肯定会触发get操作,由于他是先获取,在修改
测试先行
TDD 测试先行,我们先想一下需要什么方法,而后先假设有在测试里用一下,而后在去写这个方法
其实很多时候我们内心就是这样的,每次在开发类或者者函数之前一定要先想接口,而后在实现,而TDD只是将内心的活动带到了现实里,这样做有几点好处
1、之后可以自动测试
2、理清楚了接口
3、在你对代码大动刀戈的时候他可以起到肯定的指引作用,这一点在开发Tree的时候是感受颇深
- 首先需要一个TreeNode类作为树的节点
- 一个可以监听对象的的工具类 Watcher
- 一个可以事件通知的工具类 Event
- 一个需要对象映射Mapper类
TreeNode Spec
我们需要传入id、label、children来实现节点的创立,这也是TreeNode必需要传入的
describe('TreeNode.js', ()=>{ it('init a node', ()=>{ // 初始化一个节点 const root = new TreeNode(1, 'Node1', [ new TreeNode(2, 'Node2', []) ]) expect(root.id).toBe(1) expect(root.label).toBe('Node1') expect(root.children[0].id).toBe(2) expect(root.children[0].label).toBe('Node') })})Watcher Spec
这里我们要将对象的操作进行阻拦,这样才能知道这个对象的变化
- 监听节点内哪个属性修改了什么值
- 监听存放孩子节点的数组
- 节点的添加
- 节点的修改(这里需要注意一下,修改就是指针变化)
- 节点的删除
describe('Watcher.js', ()=>{ it('listern a node prop change', ()=>{ const root = { label: 'Node1', } const watcher = new Watcher(root) const _root = watcher.proxy // 拿到代理商后的对象 const changeHandler = jest.fn() watcher.bindHandler('change', changeHandler) const addHandler = jest.fn() watcher.bindHandler('add', addHandler) _root.label = "Test" expect(changeHandler).toHaveBeenCalledTimes(1) _root.disabled = true expect(addHandler).toHaveBeenCalledTimes(1) }) it('listen a node children node pointer and length change', ()=>{ const root = { label: 'Node1', children:[ { label: 'Node2' } ] } const watcher = new Watcher(root) const _root = watcher.proxy // 拿到代理商后的对象 const childrenChangeHandler = jest.fn() watcher.bindHandler('array/change', childrenChangeHandler) const addHandler = jest.fn() watcher.bindHandler('array/', addHandler) _root.label = 'Test' expect(childrenChangeHandler).toHaveBeenCalledTimes(1) expect(childrenChangeHandler).toHaveBeenNthCalledWith(1, { target: root, key: 'label', value: 'Test', currentNode: root }) _root.disabled = true expect(addHandler).toHaveBeenCalledTimes(1) expect(childrenChangeHandler).toHaveBeenNthCalledWith(1, { target: root, key: 'disabled', value: true, currentNode: root }) })})Event Spec
这里要实现简单的事件的监听和发送,你也可以了解为订阅与推送
describe('Event.js', ()=>{ it('listen a event', ()=>{ const event = new Event() const cb = jest.fn() event.on('ev1', cb) event.emit('ev1', 1, 2, 3) expect(cb).toHaveBeenCalledTimes(1) expect(cb).toHaveBeenCalledWith(1, 2, 3) })})Mapper Spec
这里就是最终将上面的功能都集合到一起
- 节点转换与映射
- 变更监听
- 响应更改
describe('Mapper.js', () => { it('mapper a tree', () => { const rawNode = { text: 'Node1', childs: [ { text: 'Node11', childs: [ { text: 'Node111', childs: [] } ] } ] } const mapper = new TreeMapper(rawNode, { label: 'text', children: 'childs' }) const rawNodeProxy = mapper.rawNodeProxy const treeNodeProxy = mapper.treeNodeProxy rawNodeProxy.text = "Test" expect(rawNodeProxy.text).toEqual(treeNodeProxy.label) expect(rawNodeProxy.childs[0].text).toEqual(treeNodeProxy.children[0].label) expect(rawNodeProxy.childs[0].childs[0].text).toEqual( treeNodeProxy.children[0].children[0].label ) }) ...})实现原理
TreeNode
这个利用ES6的Class简单的实现了一下TreeNode
class TreeNode { constructor(id, label, children) { this.id = id this.label = label; this.children = children ?? []; }}Watcher
这里主要是通过Proxy进行代理商阻拦,而后通过Event推送出去
class Watcher { constructor(target) { this.event = new Event(); // 用于变更通知 this.toProxy = new WeakMap(); // WeakMap 有个特别好的特性,可以自动移除未引用的对象 this.toRaw = new WeakMap(); this.proxy = this.reactive(target, target); } reactive(target, lastTarget) { // 嵌套响应式 if (!isObject(target) || this.toRaw.has(target)) { // 假如当前是代理商,或者者不是对象则返回 return target; } if (this.toProxy.has(target)) { // 假如当前对象以及代理商则返回代理商 return this.toProxy.get(target); } const currentNode = isArray(lastTarget) ? target : lastTarget; // 获取当前的节点 const handler = { get: this.createGetter(), set: this.createSetter(currentNode), deleteProperty: this.createDeleteProperty(currentNode), }; const observer = new Proxy(target, handler); this.toProxy.set(target, observer); // 建立原始对象和代理商 this.toRaw.set(observer, target); // 对象的映射关系 return observer; } bindHandler(type, callback) { // 绑定一个通知 this.event.on(type, callback); } createGetter() { return (target, key) => { const res = Reflect.get(target, key); return isObject(res) ? this.reactive(res, target) : res; // 假如是对象,则继续嵌套代理商,假如不是对象则返回这个值 }; } createSetter(currentNode) { return (target, key, value) => { if (this.toRaw.has(value)) { // 假如写入的是已经被代理商的对象,则先转换为普通对象 value = this.toRaw.get(value); } if (isArray(target)) { if (key === "length") { this.event.emit("array/changeLength", { target, key, value, currentNode, }); } else { if (Reflect.has(target, key)) { // 修改 this.event.emit("array/change", { target, key, value, currentNode, }); } else { // 新添加 this.event.emit("array/append", { target, key, value, currentNode, }); } } } else { if (Reflect.has(target, key)) { // 修改 this.event.emit("change", { target, key, value, currentNode }); } else { // 新添加 this.event.emit("add", { target, key, value, currentNode }); } } return Reflect.set(target, key, value); }; } createDeleteProperty(currentNode) { return (target, key) => { if (isArray(target)) { this.event.emit("array/delete", { target, key, currentNode }); } else { this.event.emit("delete", { target, key, currentNode }); } return Reflect.deleteProperty(target, key); }; }}假如看过Vue3的Reactivity这个库,你会发现我这里的Watcher与Reactivity有些相似,其实Watcher的内部就是借鉴了少量Vue3Reactive的实现。
Event
简单的实现一个事件通知
class Event { constructor() { this.events = new Map(); } on(name, callback) { if (!this.events.has(name)) { this.events.set(name, new Set([callback])); return; } this.events.get(name).add(callback); } emit(name, ...args) { if (this.events.has(name)) { this.events.get(name).forEach((cb) => cb(...args)); } }}Mapper
这个组件的实现大概是这几步
1、转换RawNode -> TreeNode
2、对RawNode进行Watcher监听
3、对TreeNode进行Watcher监听
4、当发生变更通知后,对原数据进行修改
class Mapper { constructor(rawNode, keyMap) { this.toTreeNode = new WeakMap(); this.toRawNode = new WeakMap(); this.toRawNodeKey = keyMap; this.toTreeNodeKey = reversalNodeKeyMap(keyMap); // 反向 NodeKey // 初始化 this.rawNode = rawNode; this.treeNode = this.convertToTreeNode(rawNode); // 生成TreeNode this.rawNodeWatcher = new Watcher(this.rawNode); this.treeNodeWatcher = new Watcher(this.treeNode); this.withRawNodeHandler(); this.withTreeNodeHandler(); // 对 rawNode 与 treeNode 分别进行响应式解决 } convertToTreeNode(rawNode) { const treeNode = new TreeNode( rawNode[this.toRawNodeKey.id], rawNode[this.toRawNodeKey.label], this.convertToTreeNodes(rawNode[this.toRawNodeKey.children]), { isChecked: rawNode[this.toRawNodeKey.isChecked] } ); this.toTreeNode.set(rawNode, treeNode); this.toRawNode.set(treeNode, rawNode); return treeNode; } convertToRawNode(treeNode) { const rawNode = { [this.toRawNodeKey.id]: treeNode.id, [this.toRawNodeKey.label]: treeNode.label, [this.toRawNodeKey.children]: this.convertToRawNodes(treeNode.children), }; this.toTreeNode.set(rawNode, treeNode); this.toRawNode.set(treeNode, rawNode); return rawNode; } convertToTreeNodes(rawNodes) { return rawNodes?.map((node) => this.convertToTreeNode(node)); } convertToRawNodes(treeNodes) { return treeNodes?.map((node) => this.convertToRawNode(node)); } withRawNodeHandler() { this.rawNodeWatcher.bindHandler( "array/append", ({ currentNode, value }) => { const currentTreeNode = this.toTreeNode.get(currentNode); this.forTreeNodeAppendChild( currentTreeNode, this.convertToTreeNode(value) ); } ); this.rawNodeWatcher.bindHandler("array/delete", ({ currentNode, key }) => { const currentTreeNode = this.toTreeNode.get(currentNode); this.forTreeNodeRemoveChild(currentTreeNode, key); }); this.rawNodeWatcher.bindHandler( "array/change", ({ currentNode, key, value }) => { const currentTreeNode = this.toTreeNode.get(currentNode); this.forTreeNodeUpdateChild( currentTreeNode, key, this.toTreeNode.get(value) ?? this.convertToTreeNode(value) ); } ); this.rawNodeWatcher.bindHandler("change", ({ currentNode, key, value }) => { const currentTreeNode = this.toTreeNode.get(currentNode); this.forTreeNodeUpdateValue( currentTreeNode, this.toTreeNodeKey[key], value ); }); this.rawNodeWatcher.bindHandler("add", ({ currentNode, key, value }) => { const currentTreeNode = this.toTreeNode.get(currentNode); this.forTreeNodeUpdateValue( currentTreeNode, this.toTreeNodeKey[key], value ); }); } withTreeNodeHandler() { this.treeNodeWatcher.bindHandler( "array/append", ({ currentNode, value }) => { const currentRawNode = this.toRawNode.get(currentNode); this.forRawNodeAppendChild( currentRawNode, this.convertToRawNode(value) ); } ); this.treeNodeWatcher.bindHandler("array/delete", ({ currentNode, key }) => { const currentRawNode = this.toRawNode.get(currentNode); this.forRawNodeRemoveChild(currentRawNode, key); }); this.treeNodeWatcher.bindHandler( "array/change", ({ currentNode, key, value }) => { const currentRawNode = this.toRawNode.get(currentNode); this.forRawNodeUpdateChild(currentRawNode, key, value); } ); this.treeNodeWatcher.bindHandler( "change", ({ currentNode, key, value }) => { const currentRawNode = this.toRawNode.get(currentNode); this.forRawNodeUpdateValue( currentRawNode, this.toRawNodeKey[key], value ); } ); this.treeNodeWatcher.bindHandler("add", ({ currentNode, key, value }) => { const currentRawNode = this.toRawNode.get(currentNode); this.forRawNodeUpdateValue(currentRawNode, this.toRawNodeKey[key], value); }); } forTreeNodeAppendChild(currentTreeNode, newTreeNode) { currentTreeNode.children.push(newTreeNode); } forTreeNodeUpdateValue(currentTreeNode, key, value) { if (key === "children") { currentTreeNode[key] = this.convertToTreeNodes(value); } else { currentTreeNode[key] = value; } } forTreeNodeRemoveChild(currentTreeNode, index) { // TODO: 这里还得对toRawNode 与 toTreeNode 进行解决,不然会内存泄漏 currentTreeNode.children.splice(index, 1); } forTreeNodeUpdateChild(currentTreeNode, index, childNode) { currentTreeNode.children[index] = childNode; } forRawNodeAppendChild(currentRawNode, newRawNode) { currentRawNode[this.toRawNodeKey.children].push(newRawNode); } forRawNodeUpdateValue(currentRawNode, key, value) { if (key === this.toRawNodeKey["children"]) { currentRawNode[key] = this.convertToRawNodes(value); } else if (Reflect.has(currentRawNode, key)) { currentRawNode[key] = value; } } forRawNodeRemoveChild(currentRawNode, index) { currentRawNode[this.toRawNodeKey.children].splice(index, 1); } forRawNodeUpdateChild(currentRawNode, index, childNode) { currentRawNode[this.toRawNodeKey.children][index] = childNode; }}结束
在开发Tree的时候其实,还要比上面写的要复杂,这里是简化了少量操作,实际上在真正的Tree里他还需要将TreeNode进行Vue的reactive响应化,但是在开发的过程中,Vue的响应化和Watcher的响应化有少量冲突,所以会有少量很坑人的事情发生,不过最后也用了少量方法处理了,这里你可以去看Tree的源码学习。这里我说了这么多其实想说的是,当你遇到大坑的时候,将这个大坑处理掉,可以加深对这个坑所对应的问题了解,这就像是摸着坑过河吧。
最后,也是非常希望更多人可以加入我们花果山团队,来和我们一起做开源吧
hug-sun/element3
点赞、评论、收藏
image-20210205193035624.png
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » ElTree组件的内部原理