ElTree组件的内部原理

作者 : 开心源码 本文共10205个字,预计阅读时间需要26分钟 发布时间: 2022-05-14 共304人阅读

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组件的内部原理

发表回复