超大量数据，前端树形结构展示
后端返回了50万数据，让前端一次性展示成树，之前用的ant-design-vue的tree插件，卡的死死的，颠末大量实验，现发现三种树可以支持如此大数量的数据。目次
第一种：vue-easy-tree
使用方式：
1.安装插件
2.引入插件
全局引入
组件引入
3.使用
在使用虚拟滚动时，必须设置 node-key。
4.api（githup经常打不开，哎,复制了一下各人一起看）
基础用法
可选择
懒加载自界说叶子节点
默认展开和默认选中
禁用状态
树节点的选择
自界说节点内容
节点过滤
手风琴模式
可拖拽节点
Attributes
props
方法
Events
Scoped Slot
第二种：zTree(vue-giant-tree)延迟加载
1.安装插件
2.页面使用
第三种：vxe-table-plugin-virtual-tree
总结
第一种：vue-easy-tree
[*]大数据量支持虚拟滚动
[*]基本树形数据的展示
[*]支持checkbox选择
[*]支持懒加载
[*]默认展开和默认选中
[*]禁用节点
[*]通过多种方式选中节点和获取选中的节点信息
[*]支持自界说节点内容
[*]支持节点过滤
[*]非虚拟滚动下，支持手风琴模式
[*]非懒加载时，支持节点拖拽
githup上有具体api介绍
https://github.com/wchbrad/vue-easy-tree/blob/aa225219e4dc9e88f0a633405fe3947991dfd224/element-ui-tree.zh-CN.md
使用方式：
1.安装插件
npm install @wchbrad/vue-easy-tree 2.引入插件
全局引入
在 main.js 文件中引入：
import Vue from "vue";
import VueEasyTree from "@wchbrad/vue-easy-tree";
// 样式文件，可以根据需要自定义样式或主题
import "@wchbrad/vue-easy-tree/src/assets/index.scss"
Vue.use(VueEasyTree) 组件引入
在组件中引入：
import VueEasyTree from "@wchbrad/vue-easy-tree";
// 样式文件，可以根据需要自定义样式或主题
import "@wchbrad/vue-easy-tree/src/assets/index.scss"
export default {
components: {
VueEasyTree
}
} 3.使用
在使用虚拟滚动时，必须设置 node-key。
4.api（githup经常打不开，哎,复制了一下各人一起看）
基础用法
基础的树形结构展示。
<vue-easy-tree :data="data" :props="defaultProps" @node-click="handleNodeClick"></vue-easy-tree>
<script>
export default {
data() {
return {
data: [{
label: '一级 1',
children: [{
label: '二级 1-1',
children: [{
label: '三级 1-1-1'
}]
}]
}, {
label: '一级 2',
children: [{
label: '二级 2-1',
children: [{
label: '三级 2-1-1'
}]
}, {
label: '二级 2-2',
children: [{
label: '三级 2-2-1'
}]
}]
}, {
label: '一级 3',
children: [{
label: '二级 3-1',
children: [{
label: '三级 3-1-1'
}]
}, {
label: '二级 3-2',
children: [{
label: '三级 3-2-1'
}]
}]
}],
defaultProps: {
children: 'children',
label: 'label'
}
};
},
methods: {
handleNodeClick(data) {
console.log(data);
}
}
};
</script> 可选择
实用于需要选择层级时使用。
本例还展示了动态加载节点数据的方法。
<vue-easy-tree
:props="props"
:load="loadNode"
lazy
show-checkbox
@check-change="handleCheckChange">
</vue-easy-tree>
<script>
export default {
data() {
return {
props: {
label: 'name',
children: 'zones'
},
count: 1
};
},
methods: {
handleCheckChange(data, checked, indeterminate) {
console.log(data, checked, indeterminate);
},
handleNodeClick(data) {
console.log(data);
},
loadNode(node, resolve) {
if (node.level === 0) {
return resolve([{ name: 'region1' }, { name: 'region2' }]);
}
if (node.level > 3) return resolve([]);
var hasChild;
if (node.data.name === 'region1') {
hasChild = true;
} else if (node.data.name === 'region2') {
hasChild = false;
} else {
hasChild = Math.random() > 0.5;
}
setTimeout(() => {
var data;
if (hasChild) {
data = [{
name: 'zone' + this.count++
}, {
name: 'zone' + this.count++
}];
} else {
data = [];
}
resolve(data);
}, 500);
}
}
};
</script> 懒加载自界说叶子节点
由于在点击节点时才进行该层数据的获取，默认情况下 Tree 无法预知某个节点是否为叶子节点，所以会为每个节点添加一个下拉按钮，假如节点没有下层数据，则点击后下拉按钮会消失。同时，你也可以提前告知 Tree 某个节点是否为叶子节点，从而避免在叶子节点前渲染下拉按钮。
<vue-easy-tree
:props="props"
:load="loadNode"
lazy
show-checkbox>
</vue-easy-tree>
<script>
export default {
data() {
return {
props: {
label: 'name',
children: 'zones',
isLeaf: 'leaf'
},
};
},
methods: {
loadNode(node, resolve) {
if (node.level === 0) {
return resolve([{ name: 'region' }]);
}
if (node.level > 1) return resolve([]);
setTimeout(() => {
const data = [{
name: 'leaf',
leaf: true
}, {
name: 'zone'
}];
resolve(data);
}, 500);
}
}
};
</script> 默认展开和默认选中
可将 Tree 的某些节点设置为默认展开或默认选中
分别通过default-expanded-keys和default-checked-keys设置默认展开和默认选中的节点。需要注意的是，此时必须设置node-key，其值为节点数据中的一个字段名，该字段在整棵树中是唯一的。
<vue-easy-tree
:data="data"
show-checkbox
node-key="id"
:default-expanded-keys=""
:default-checked-keys=""
:props="defaultProps">
</vue-easy-tree>
<script>
export default {
data() {
return {
data: [{
id: 1,
label: '一级 1',
children: [{
id: 4,
label: '二级 1-1',
children: [{
id: 9,
label: '三级 1-1-1'
}, {
id: 10,
label: '三级 1-1-2'
}]
}]
}, {
id: 2,
label: '一级 2',
children: [{
id: 5,
label: '二级 2-1'
}, {
id: 6,
label: '二级 2-2'
}]
}, {
id: 3,
label: '一级 3',
children: [{
id: 7,
label: '二级 3-1'
}, {
id: 8,
label: '二级 3-2'
}]
}],
defaultProps: {
children: 'children',
label: 'label'
}
};
}
};
</script> 禁用状态
可将 Tree 的某些节点设置为禁用状态
通过disabled设置禁用状态。
<vue-easy-tree
:data="data"
show-checkbox
node-key="id"
:default-expanded-keys=""
:default-checked-keys="">
</vue-easy-tree>
<script>
export default {
data() {
return {
data: [{
id: 1,
label: '一级 2',
children: [{
id: 3,
label: '二级 2-1',
children: [{
id: 4,
label: '三级 3-1-1'
}, {
id: 5,
label: '三级 3-1-2',
disabled: true
}]
}, {
id: 2,
label: '二级 2-2',
disabled: true,
children: [{
id: 6,
label: '三级 3-2-1'
}, {
id: 7,
label: '三级 3-2-2',
disabled: true
}]
}]
}],
defaultProps: {
children: 'children',
label: 'label'
}
};
}
};
</script> 树节点的选择
本例展示如何获取和设置选中节点。获取和设置各有两种方式：通过 node 或通过 key。假如需要通过 key 来获取或设置，则必须设置node-key。
<vue-easy-tree
:data="data"
show-checkbox
default-expand-all
node-key="id"
ref="tree"
highlight-current
:props="defaultProps">
</vue-easy-tree>
<div class="buttons">
<el-button @click="getCheckedNodes">通过 node 获取</el-button>
<el-button @click="getCheckedKeys">通过 key 获取</el-button>
<el-button @click="setCheckedNodes">通过 node 设置</el-button>
<el-button @click="setCheckedKeys">通过 key 设置</el-button>
<el-button @click="resetChecked">清空</el-button>
</div>
<script>
export default {
methods: {
getCheckedNodes() {
console.log(this.$refs.tree.getCheckedNodes());
},
getCheckedKeys() {
console.log(this.$refs.tree.getCheckedKeys());
},
setCheckedNodes() {
this.$refs.tree.setCheckedNodes([{
id: 5,
label: '二级 2-1'
}, {
id: 9,
label: '三级 1-1-1'
}]);
},
setCheckedKeys() {
this.$refs.tree.setCheckedKeys();
},
resetChecked() {
this.$refs.tree.setCheckedKeys([]);
}
},
data() {
return {
data: [{
id: 1,
label: '一级 1',
children: [{
id: 4,
label: '二级 1-1',
children: [{
id: 9,
label: '三级 1-1-1'
}, {
id: 10,
label: '三级 1-1-2'
}]
}]
}, {
id: 2,
label: '一级 2',
children: [{
id: 5,
label: '二级 2-1'
}, {
id: 6,
label: '二级 2-2'
}]
}, {
id: 3,
label: '一级 3',
children: [{
id: 7,
label: '二级 3-1'
}, {
id: 8,
label: '二级 3-2'
}]
}],
defaultProps: {
children: 'children',
label: 'label'
}
};
}
};
</script> 自界说节点内容
节点的内容支持自界说，可以在节点区添加按钮或图标等内容
可以通过两种方法进行树节点内容的自界说：render-content和 scoped slot。使用render-content指定渲染函数，该函数返回需要的节点区内容即可。渲染函数的用法请参考 Vue 文档。使用 scoped slot 会传入两个参数node和data，分别表示当前节点的 Node 对象和当前节点的数据。注意：由于 jsfiddle 不支持 JSX 语法，所以render-content示例在 jsfiddle 中无法运行。但是在实际的项目中，只要精确地设置了相关依赖，就可以正常运行。
<div class="custom-tree-container">
<div class="block">
<p>使用 render-content</p>
<vue-easy-tree
:data="data"
show-checkbox
node-key="id"
default-expand-all
:expand-on-click-node="false"
:render-content="renderContent">
</vue-easy-tree>
</div>
<div class="block">
<p>使用 scoped slot</p>
<vue-easy-tree
:data="data"
show-checkbox
node-key="id"
default-expand-all
:expand-on-click-node="false">
<span class="custom-tree-node" slot-scope="{ node, data }">
<span>{{ node.label }}</span>
<span>
<el-button
type="text"
size="mini"
@click="() => append(data)">
Append
</el-button>
<el-button
type="text"
size="mini"
@click="() => remove(node, data)">
Delete
</el-button>
</span>
</span>
</vue-easy-tree>
</div>
</div>
<script>
let id = 1000;
export default {
data() {
const data = [{
id: 1,
label: '一级 1',
children: [{
id: 4,
label: '二级 1-1',
children: [{
id: 9,
label: '三级 1-1-1'
}, {
id: 10,
label: '三级 1-1-2'
}]
}]
}, {
id: 2,
label: '一级 2',
children: [{
id: 5,
label: '二级 2-1'
}, {
id: 6,
label: '二级 2-2'
}]
}, {
id: 3,
label: '一级 3',
children: [{
id: 7,
label: '二级 3-1'
}, {
id: 8,
label: '二级 3-2'
}]
}];
return {
data: JSON.parse(JSON.stringify(data)),
data: JSON.parse(JSON.stringify(data))
}
},
methods: {
append(data) {
const newChild = { id: id++, label: 'testtest', children: [] };
if (!data.children) {
this.$set(data, 'children', []);
}
data.children.push(newChild);
},
remove(node, data) {
const parent = node.parent;
const children = parent.data.children || parent.data;
const index = children.findIndex(d => d.id === data.id);
children.splice(index, 1);
},
renderContent(h, { node, data, store }) {
return (
<span class="custom-tree-node">
<span>{node.label}</span>
<span>
<el-button size="mini" type="text" on-click={ () => this.append(data) }>Append</el-button>
<el-button size="mini" type="text" on-click={ () => this.remove(node, data) }>Delete</el-button>
</span>
</span>);
}
}
};
</script>
<style>
.custom-tree-node {
flex: 1;
display: flex;
align-items: center;
justify-content: space-between;
font-size: 14px;
padding-right: 8px;
}
</style> 节点过滤
通过关键字过滤树节点
在需要对节点进行过滤时，调用 Tree 实例的filter方法，参数为关键字。需要注意的是，此时需要设置filter-node-method，值为过滤函数。
<el-input
placeholder="输入关键字进行过滤"
v-model="filterText">
</el-input>
<vue-easy-tree
class="filter-tree"
:data="data"
:props="defaultProps"
default-expand-all
:filter-node-method="filterNode"
ref="tree">
</vue-easy-tree>
<script>
export default {
watch: {
filterText(val) {
this.$refs.tree.filter(val);
}
},
methods: {
filterNode(value, data) {
if (!value) return true;
return data.label.indexOf(value) !== -1;
}
},
data() {
return {
filterText: '',
data: [{
id: 1,
label: '一级 1',
children: [{
id: 4,
label: '二级 1-1',
children: [{
id: 9,
label: '三级 1-1-1'
}, {
id: 10,
label: '三级 1-1-2'
}]
}]
}, {
id: 2,
label: '一级 2',
children: [{
id: 5,
label: '二级 2-1'
}, {
id: 6,
label: '二级 2-2'
}]
}, {
id: 3,
label: '一级 3',
children: [{
id: 7,
label: '二级 3-1'
}, {
id: 8,
label: '二级 3-2'
}]
}],
defaultProps: {
children: 'children',
label: 'label'
}
};
}
};
</script> 手风琴模式
对于同一级的节点，每次只能展开一个
<vue-easy-tree
:data="data"
:props="defaultProps"
accordion
@node-click="handleNodeClick">
</vue-easy-tree>
<script>
export default {
data() {
return {
data: [{
label: '一级 1',
children: [{
label: '二级 1-1',
children: [{
label: '三级 1-1-1'
}]
}]
}, {
label: '一级 2',
children: [{
label: '二级 2-1',
children: [{
label: '三级 2-1-1'
}]
}, {
label: '二级 2-2',
children: [{
label: '三级 2-2-1'
}]
}]
}, {
label: '一级 3',
children: [{
label: '二级 3-1',
children: [{
label: '三级 3-1-1'
}]
}, {
label: '二级 3-2',
children: [{
label: '三级 3-2-1'
}]
}]
}],
defaultProps: {
children: 'children',
label: 'label'
}
};
},
methods: {
handleNodeClick(data) {
console.log(data);
}
}
};
</script> 可拖拽节点
通过 draggable 属性可让节点变为可拖拽。
<vue-easy-tree
:data="data"
node-key="id"
default-expand-all
@node-drag-start="handleDragStart"
@node-drag-enter="handleDragEnter"
@node-drag-leave="handleDragLeave"
@node-drag-over="handleDragOver"
@node-drag-end="handleDragEnd"
@node-drop="handleDrop"
draggable
:allow-drop="allowDrop"
:allow-drag="allowDrag">
</vue-easy-tree>
<script>
export default {
data() {
return {
data: [{
id: 1,
label: '一级 1',
children: [{
id: 4,
label: '二级 1-1',
children: [{
id: 9,
label: '三级 1-1-1'
}, {
id: 10,
label: '三级 1-1-2'
}]
}]
}, {
id: 2,
label: '一级 2',
children: [{
id: 5,
label: '二级 2-1'
}, {
id: 6,
label: '二级 2-2'
}]
}, {
id: 3,
label: '一级 3',
children: [{
id: 7,
label: '二级 3-1'
}, {
id: 8,
label: '二级 3-2',
children: [{
id: 11,
label: '三级 3-2-1'
}, {
id: 12,
label: '三级 3-2-2'
}, {
id: 13,
label: '三级 3-2-3'
}]
}]
}],
defaultProps: {
children: 'children',
label: 'label'
}
};
},
methods: {
handleDragStart(node, ev) {
console.log('drag start', node);
},
handleDragEnter(draggingNode, dropNode, ev) {
console.log('tree drag enter: ', dropNode.label);
},
handleDragLeave(draggingNode, dropNode, ev) {
console.log('tree drag leave: ', dropNode.label);
},
handleDragOver(draggingNode, dropNode, ev) {
console.log('tree drag over: ', dropNode.label);
},
handleDragEnd(draggingNode, dropNode, dropType, ev) {
console.log('tree drag end: ', dropNode && dropNode.label, dropType);
},
handleDrop(draggingNode, dropNode, dropType, ev) {
console.log('tree drop: ', dropNode.label, dropType);
},
allowDrop(draggingNode, dropNode, type) {
if (dropNode.data.label === '二级 3-1') {
return type !== 'inner';
} else {
return true;
}
},
allowDrag(draggingNode) {
return draggingNode.data.label.indexOf('三级 3-2-2') === -1;
}
}
};
</script> Attributes
参数阐明类型可选值默认值data展示数据array——empty-text内容为空的时候展示的文本String——node-key每个树节点用来作为唯一标识的属性，整棵树应该是唯一的String——props设置选项，具体看下表object——render-after-expand是否在第一次展开某个树节点后才渲染其子节点boolean—trueload加载子树数据的方法，仅当 lazy 属性为true 时生效function(node, resolve)——render-content树节点的内容区的渲染 FunctionFunction(h, { node, data, store }——highlight-current是否高亮当前选中节点，默认值是 false。boolean—falsedefault-expand-all是否默认展开全部节点boolean—falseexpand-on-click-node是否在点击节点的时候展开大概收缩节点， 默认值为 true，假如为 false，则只有点箭头图标的时候才会展开大概收缩节点。boolean—truecheck-on-click-node是否在点击节点的时候选中节点，默认值为 false，即只有在点击复选框时才会选中节点。boolean—falseauto-expand-parent展开子节点的时候是否自动展开父节点boolean—truedefault-expanded-keys默认展开的节点的 key 的数组array——show-checkbox节点是否可被选择boolean—falsecheck-strictly在显示复选框的情况下，是否严格的遵循父子不相互关联的做法，默认为 falseboolean—falsedefault-checked-keys默认勾选的节点的 key 的数组array——current-node-key当前选中的节点string, number——filter-node-method对树节点进行筛选时执行的方法，返回 true 表示这个节点可以显示，返回 false 则表示这个节点会被隐蔽Function(value, data, node)——accordion是否每次只打开一个同级树节点展开boolean—falseindent相邻级节点间的程度缩进，单位为像素number—16item-size每个节点的高度,单位为像素number—26icon-class自界说树节点的图标string--lazy是否懒加载子节点，需与 load 方法联合使用boolean—falsedraggable是否开启拖拽节点功能boolean—falseallow-drag判断节点能否被拖拽Function(node)——allow-drop拖拽时判定目标节点能否被放置。type 参数有三种情况：'prev'、'inner' 和 'next'，分别表示放置在目标节点前、插入至目标节点和放置在目标节点后Function(draggingNode, dropNode, type)—— props
参数阐明类型可选值默认值label指定节点标签为节点对象的某个属性值string, function(data, node)——children指定子树为节点对象的某个属性值string——disabled指定节点选择框是否禁用为节点对象的某个属性值boolean, function(data, node)——isLeaf指定节点是否为叶子节点，仅在指定了 lazy 属性的情况下生效boolean, function(data, node)—— 方法
Tree 内部使用了 Node 类型的对象来包装用户传入的数据，用来保存目前节点的状态。 Tree 拥有如下方法：
方法名阐明参数filter对树节点进行筛选操作吸取一个恣意类型的参数，该参数会在 filter-node-method 中作为第一个参数updateKeyChildren通过 keys 设置节点子元素，使用此方法必须设置 node-key 属性(key, data) 吸取两个参数，1. 节点 key 2. 节点数据的数组getCheckedNodes若节点可被选择（即 show-checkbox 为 true），则返回目前被选中的节点所构成的数组(leafOnly, includeHalfChecked) 吸取两个 boolean 类型的参数，1. 是否只是叶子节点，默认值为 false 2. 是否包含半选节点，默认值为 falsesetCheckedNodes设置目前勾选的节点，使用此方法必须设置 node-key 属性(nodes) 吸取勾选节点数据的数组getCheckedKeys若节点可被选择（即 show-checkbox 为 true），则返回目前被选中的节点的 key 所构成的数组(leafOnly) 吸取一个 boolean 类型的参数，若为 true 则仅返回被选中的叶子节点的 keys，默认值为 falsesetCheckedKeys通过 keys 设置目前勾选的节点，使用此方法必须设置 node-key 属性(keys, leafOnly) 吸取两个参数，1. 勾选节点的 key 的数组 2. boolean 类型的参数，若为 true 则仅设置叶子节点的选中状态，默认值为 falsesetCheckedAll虚拟滚动时，快速全选大概扫除全选的方法，使用setCheckedKeys可能会卡顿(checked) 吸取一个 boolean 类型的参数，若为 true 则全选全部节点，若为 false 则取消全部节点的选中/半选状态，默认值为 falsesetChecked通过 key / data 设置某个节点的勾选状态，使用此方法必须设置 node-key 属性(key/data, checked, deep) 吸取三个参数，1. 勾选节点的 key 大概 data 2. boolean 类型，节点是否选中 3. boolean 类型，是否设置子节点 ，默认为 falsegetHalfCheckedNodes若节点可被选择（即 show-checkbox 为 true），则返回目前半选中的节点所构成的数组-getHalfCheckedKeys若节点可被选择（即 show-checkbox 为 true），则返回目前半选中的节点的 key 所构成的数组-getCurrentKey获取当前被选中节点的 key，使用此方法必须设置 node-key 属性，若没有节点被选中则返回 null—getCurrentNode获取当前被选中节点的 data，若没有节点被选中则返回 null—setCurrentKey通过 key 设置某个节点的当前选中状态，使用此方法必须设置 node-key 属性(key) 待被选节点的 key，若为 null 则取消当前高亮的节点setCurrentNode通过 node 设置某个节点的当前选中状态，使用此方法必须设置 node-key 属性(node) 待被选节点的 nodegetNode根据 data 大概 key 拿到 Tree 组件中的 node(data) 要获得 node 的 key 大概 dataremove删除 Tree 中的一个节点，使用此方法必须设置 node-key 属性(data) 要删除的节点的 data 大概 nodeappend为 Tree 中的一个节点追加一个子节点(data, parentNode) 吸取两个参数，1. 要追加的子节点的 data 2. 子节点的 parent 的 data、key 大概 nodeinsertBefore为 Tree 的一个节点的前面增加一个节点(data, refNode) 吸取两个参数，1. 要增加的节点的 data 2. 要增加的节点的后一个节点的 data、key 大概 nodeinsertAfter为 Tree 的一个节点的后面增加一个节点(data, refNode) 吸取两个参数，1. 要增加的节点的 data 2. 要增加的节点的前一个节点的 data、key 大概 node Events
事件名称阐明回调参数node-click节点被点击时的回调共三个参数，依次为：通报给 data 属性的数组中该节点所对应的对象、节点对应的 Node、节点组件本身。node-contextmenu当某一节点被鼠标右键点击时会触发该事件共四个参数，依次为：event、通报给 data 属性的数组中该节点所对应的对象、节点对应的 Node、节点组件本身。check-change节点选中状态发生厘革时的回调共三个参数，依次为：通报给 data 属性的数组中该节点所对应的对象、节点本身是否被选中、节点的子树中是否有被选中的节点check当复选框被点击的时候触发共两个参数，依次为：通报给 data 属性的数组中该节点所对应的对象、树目前的选中状态对象，包含 checkedNodes、checkedKeys、halfCheckedNodes、halfCheckedKeys 四个属性current-change当前选中节点厘革时触发的事件共两个参数，依次为：当前节点的数据，当前节点的 Node 对象node-expand节点被展开时触发的事件共三个参数，依次为：通报给 data 属性的数组中该节点所对应的对象、节点对应的 Node、节点组件本身node-collapse节点被关闭时触发的事件共三个参数，依次为：通报给 data 属性的数组中该节点所对应的对象、节点对应的 Node、节点组件本身node-drag-start节点开始拖拽时触发的事件共两个参数，依次为：被拖拽节点对应的 Node、eventnode-drag-enter拖拽进入其他节点时触发的事件共三个参数，依次为：被拖拽节点对应的 Node、所进入节点对应的 Node、eventnode-drag-leave拖拽离开某个节点时触发的事件共三个参数，依次为：被拖拽节点对应的 Node、所离开节点对应的 Node、eventnode-drag-over在拖拽节点时触发的事件（雷同欣赏器的 mouseover 事件）共三个参数，依次为：被拖拽节点对应的 Node、当前进入节点对应的 Node、eventnode-drag-end拖拽结束时（可能未成功）触发的事件共四个参数，依次为：被拖拽节点对应的 Node、结束拖拽时最后进入的节点（可能为空）、被拖拽节点的放置位置（before、after、inner）、eventnode-drop拖拽成功完成时触发的事件共四个参数，依次为：被拖拽节点对应的 Node、结束拖拽时最后进入的节点、被拖拽节点的放置位置（before、after、inner）、event Scoped Slot
name阐明—自界说树节点的内容，参数为 { node, data }
第二种：zTree(vue-giant-tree)延迟加载
巨树：基于ztree封装的 Vue 树形组件，轻松实现海量数据的高性能渲染。
Vue 的数据监听机制决定了在大数据量场景下的渲染性能非常低下，基于 Vue 实现的通例树组件险些无法胜任上万条数据的高性能渲染，在 IE 欣赏器（即便是 IE11）中很容易导致页面卡死甚至欣赏器崩溃。
为了摆脱数据监听，只能放弃通过 Vue 渲染，采用通例 DOM 操作的方式。在这个范畴ztree是当之无愧最成熟的方案，因此 vue-giant-tree 直接基于 ztree 做上层封装，以组件的情势将 ztree 的设置和事件袒露出来，使其可以方便的在 Vue 项目中安装使用。
vue-giant-tree 仅仅是给 ztree 套了一层 Vue 组件的壳，趁便提供了一套更现代化的皮肤，因为主打大数据量场景，所以取名巨树。
针对树节点很多，但是每级节点数据不多的情况造成的总数据量大，速率很快。但针对每个节点数据很多，但总节点不多的大量数据情况无效。（比如如今数据是1x 20 x 10 x 25 x 100 五个层级，每个层级最大只有100符合，假如是1x 25x 20000 ,一个节点有2万数据，优化不明显），前端书写的时候都是dom操作，还是有些麻烦的
githup链接：https://github.com/tower1229/Vue-Giant-Tree
zTree的api文档链接：Demo
1.安装插件
npm i vue-giant-tree --save 注意：组件依赖 jQuery，务必在页面中提前加载 jQuery，
2.页面使用
zTree组件页面代码
<template>
<div class="ztree vue-giant-tree" :id="ztreeId"></div>
</template>
<script>
require("@ztree/ztree_v3/js/jquery.ztree.all");
export default {
props: {
setting: {
type: Object,
require: false,
default: function () {
return {};
},
},
nodes: {
type: Array,
require: true,
default: function () {
return [];
},
},
},
data() {
return {
ztreeId: "ztree_" + parseInt(Math.random() * 1e10),
ztreeObj: null,
list: [],
ztreeSetting: {
view: {
showIcon: false, // default to hide icon
},
callback: {
onAsyncError: (...arg) => {
this.$emit("onAsyncError", ...arg);
},
onAsyncSuccess: (...arg) => {
this.$emit("onAsyncSuccess", ...arg);
},
onCheck: (...arg) => {
this.$emit("onCheck", ...arg);
},
onClick: (...arg) => {
this.$emit("onClick", ...arg);
},
onCollapse: (...arg) => {
this.$emit("onCollapse", ...arg);
},
onDblClick: (...arg) => {
this.$emit("onDblClick", ...arg);
},
onDrag: (...arg) => {
this.$emit("onDrag", ...arg);
},
onDragMove: (...arg) => {
this.$emit("onDragMove", ...arg);
},
onDrop: (...arg) => {
this.$emit("onDrop", ...arg);
},
onExpand: (...arg) => {
this.$emit("onExpand", ...arg);
},
onMouseDown: (...arg) => {
this.$emit("onMouseDown", ...arg);
},
onMouseUp: (...arg) => {
this.$emit("onMouseUp", ...arg);
},
onRemove: (...arg) => {
this.$emit("onRemove", ...arg);
},
onRename: (...arg) => {
this.$emit("onRename", ...arg);
},
onRightClick: (...arg) => {
this.$emit("onRightClick", ...arg);
},
},
},
};
},
watch: {
nodes: {
handler: function (nodes) {
this.list = nodes;
// update tree
if (this.ztreeObj) {
this.ztreeObj.destroy();
}
this.$nextTick(() => {
this.ztreeObj = $.fn.zTree.init(
$("#" + this.ztreeId),
Object.assign({}, this.ztreeSetting, this.setting),
this.list
);
this.$emit("onCreated", this.ztreeObj);
});
},
deep: true,
immediate: true,
},
},
};
</script>
<style>
/* beauty ztree! */
.ztree {
text-align: left;
font-size: 14px;
}
.vue-giant-tree li {
list-style-type: none;
white-space: nowrap;
outline: none;
}
.vue-giant-tree li ul {
position: relative;
padding: 0 0 0 20px;
margin: 0;
}
.vue-giant-tree .line:before {
position: absolute;
top: 0;
left: 10px;
height: 100%;
content: "";
border-right: 1px dotted #dbdbdb;
}
.vue-giant-tree .roots_docu:before,
.vue-giant-tree .roots_docu:after,
.vue-giant-tree .center_docu:before,
.vue-giant-tree .bottom_docu:before,
.vue-giant-tree .center_docu:after,
.vue-giant-tree .bottom_docu:after {
position: absolute;
content: "";
border: 0 dotted #dbdbdb;
}
.vue-giant-tree .roots_docu:before {
left: 10px;
height: 50%;
top: 50%;
border-left-width: 1px;
}
.vue-giant-tree .roots_docu:after {
top: 50%;
left: 11px;
width: 50%;
border-top-width: 1px;
}
.vue-giant-tree .center_docu:before {
left: 10px;
height: 100%;
border-left-width: 1px;
}
.vue-giant-tree .center_docu:after {
top: 50%;
left: 11px;
width: 50%;
border-top-width: 1px;
}
.vue-giant-tree .bottom_docu:before {
left: 10px;
height: 50%;
border-left-width: 1px;
}
.vue-giant-tree .bottom_docu:after {
top: 50%;
left: 11px;
width: 50%;
border-top-width: 1px;
}
.vue-giant-tree li a {
display: inline-block;
line-height: 22px;
height: 22px;
margin: 0;
cursor: pointer;
transition: none;
vertical-align: middle;
color: #555555;
}
.vue-giant-tree .node_name {
display: inline-block;
padding: 0 3px;
border-radius: 4px;
}
.vue-giant-tree .curSelectedNode .node_name {
color: #000;
background-color: #c9e9f7;
}
.vue-giant-tree .curSelectedNode_Edit {
height: 20px;
opacity: 0.8;
color: #000;
border: 1px #6cc2e8 solid;
background-color: #9dd6f0;
}
.vue-giant-tree .tmpTargetNode_inner {
opacity: 0.8;
color: #fff;
background-color: #4fcbf0;
filter: alpha(opacity=80);
}
.vue-giant-tree .rename {
font-size: 12px;
line-height: 22px;
width: 80px;
height: 22px;
margin: 0;
padding: 0;
vertical-align: top;
border: 0;
background: none;
}
.vue-giant-tree .button {
position: relative;
display: inline-block;
line-height: 22px;
height: 22px;
width: 22px;
cursor: pointer;
text-align: center;
vertical-align: middle;
}
.vue-giant-tree .button.edit {
color: #25ae88;
}
.vue-giant-tree .button.remove {
color: #cb4042;
}
.vue-giant-tree .button.chk {
position: relative;
width: 14px;
height: 14px;
margin: 0 4px 0 0;
border: 1px solid #d7dde4;
border-radius: 2px;
background: #fff;
}
.vue-giant-tree .chk.radio_true_full,
.vue-giant-tree .chk.radio_false_full,
.vue-giant-tree .chk.radio_true_full_focus,
.vue-giant-tree .chk.radio_false_full_focus,
.vue-giant-tree .chk.radio_false_disable,
.vue-giant-tree .chk.radio_true_disable,
.vue-giant-tree .chk.radio_true_part,
.vue-giant-tree .chk.radio_false_part,
.vue-giant-tree .chk.radio_true_part_focus,
.vue-giant-tree .chk.radio_false_part_focus {
border-radius: 8px;
}
.vue-giant-tree .button.chk:after {
position: absolute;
top: 1px;
left: 4px;
width: 4px;
height: 8px;
content: "";
transition: -webkit-transform 0.2s ease-in-out;
transition: transform 0.2s ease-in-out;
transition: transform 0.2s ease-in-out, -webkit-transform 0.2s ease-in-out;
-webkit-transform: rotate(0deg) scale(0);
transform: rotate(0deg) scale(0);
border-right: 2px solid #fff;
border-bottom: 2px solid #fff;
}
.vue-giant-tree .button.checkbox_false_full_focus {
border-color: #ccc;
}
.vue-giant-tree .button.checkbox_true_full,
.vue-giant-tree .button.checkbox_true_full_focus,
.vue-giant-tree .button.checkbox_true_part,
.vue-giant-tree .button.checkbox_true_part_focus,
.vue-giant-tree .button.checkbox_true_disable {
border-color: #39f;
background-color: #39f;
}
.vue-giant-tree .button.checkbox_true_full:after,
.vue-giant-tree .button.checkbox_true_full_focus:after,
.vue-giant-tree .button.checkbox_true_disable:after {
-webkit-transform: rotate(45deg) scale(1);
transform: rotate(45deg) scale(1);
}
.vue-giant-tree .button.checkbox_true_part:after,
.vue-giant-tree .button.checkbox_true_part_focus:after {
top: 5px;
left: 2px;
width: 10px;
height: 1px;
-webkit-transform: rotate(0deg) scale(1);
transform: rotate(0deg) scale(1);
border-right: 0;
}
.vue-giant-tree .button.radio_true_full,
.vue-giant-tree .chk.radio_true_full_focus,
.vue-giant-tree .chk.radio_true_part,
.vue-giant-tree .chk.radio_true_part_focus {
border-color: #39f;
}
.vue-giant-tree .button.radio_true_full:after,
.vue-giant-tree .chk.radio_true_full_focus:after,
.vue-giant-tree .chk.radio_true_part:after,
.vue-giant-tree .chk.radio_true_part_focus:after {
top: 3px;
left: 3px;
width: 8px;
-webkit-transform: rotate(0deg) scale(1);
transform: rotate(0deg) scale(1);
border: 0;
border-radius: 4px;
background: #39f;
}
.vue-giant-tree .button.checkbox_true_disable,
.vue-giant-tree .button.checkbox_false_disable,
.vue-giant-tree .chk.radio_false_disable,
.vue-giant-tree .chk.radio_true_disable {
cursor: not-allowed;
}
.vue-giant-tree .button.checkbox_false_disable {
background-color: #f3f3f3;
}
.vue-giant-tree .button.noline_close:before,
.vue-giant-tree .button.noline_open:before,
.vue-giant-tree .button.root_open:before,
.vue-giant-tree .button.root_close:before,
.vue-giant-tree .button.roots_open:before,
.vue-giant-tree .button.roots_close:before,
.vue-giant-tree .button.bottom_open:before,
.vue-giant-tree .button.bottom_close:before,
.vue-giant-tree .button.center_open:before,
.vue-giant-tree .button.center_close:before {
position: absolute;
top: 5px;
left: 5px;
content: "";
transition: -webkit-transform ease 0.3s;
transition: transform ease 0.3s;
transition: transform ease 0.3s, -webkit-transform ease 0.3s;
-webkit-transform: rotateZ(0deg);
transform: rotateZ(0deg);
-webkit-transform-origin: 25% 50%;
transform-origin: 25% 50%;
border: 6px solid;
border-color: transparent transparent transparent #666;
}
.vue-giant-tree .button.noline_open:before,
.vue-giant-tree .button.root_open:before,
.vue-giant-tree .button.roots_open:before,
.vue-giant-tree .button.bottom_open:before,
.vue-giant-tree .button.center_open:before {
-webkit-transform: rotateZ(90deg);
transform: rotateZ(90deg);
}
.vue-giant-tree .button.ico_loading {
margin-right: 2px;
background: url("data:image/gif;base64,R0lGODlhEAAQAKIGAMLY8YSx5HOm4Mjc88/g9Ofw+v///wAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQFCgAGACwAAAAAEAAQAAADMGi6RbUwGjKIXCAA016PgRBElAVlG/RdLOO0X9nK61W39qvqiwz5Ls/rRqrggsdkAgAh+QQFCgAGACwCAAAABwAFAAADD2hqELAmiFBIYY4MAutdCQAh+QQFCgAGACwGAAAABwAFAAADD1hU1kaDOKMYCGAGEeYFCQAh+QQFCgAGACwKAAIABQAHAAADEFhUZjSkKdZqBQG0IELDQAIAIfkEBQoABgAsCgAGAAUABwAAAxBoVlRKgyjmlAIBqCDCzUoCACH5BAUKAAYALAYACgAHAAUAAAMPaGpFtYYMAgJgLogA610JACH5BAUKAAYALAIACgAHAAUAAAMPCAHWFiI4o1ghZZJB5i0JACH5BAUKAAYALAAABgAFAAcAAAMQCAFmIaEp1motpDQySMNFAgA7")
0 center no-repeat;
}
.vue-giant-tree .tmpTargetzTree {
opacity: 0.8;
background-color: #2ea9df;
filter: alpha(opacity=80);
}
.vue-giant-tree .tmpzTreeMove_arrow {
position: absolute;
width: 18px;
height: 18px;
color: #4fcbf0;
}
</style>
<style>
ul.ztree.zTreeDragUL {
margin: 0;
padding: 0;
position: absolute;
overflow: hidden;
background-color: #dedede;
border: 1px #4fcbf0 dotted;
border-radius: 4px;
opacity: 0.7;
}
.zTreeMask {
position: absolute;
z-index: 10000;
opacity: 0;
background-color: #cfcfcf;
}
</style>
在需要使用的页面引入ztree组件
<template>
<div style="width:30%;">
<h1 class="T">
zTree(vue-giant-tree)延迟加载
</h1>
<div class="wrap flex-1">
<div class="c" style="height:600px;overflow:auto">
<tree :setting="setting" :nodes="nodes" @onClick="onClick @onCheck="onCheck" @onCreated="handleCreated" />
</div>
</div>
</div>
</template>
<script>
export default {
name: "app",
components: {
VueEasyTree,
tree: resolve => require(["./ztree.vue"], resolve)
},
data() {
return {
nodes: [],
showIndex: 0,
ztreeObj: null,
setting: {
check: {
enable: true
},
data: {
simpleData: {
enable: false,
pIdKey: "pid",
},
key:{
name:'departName'
}
},
view: {
showIcon: false,
addHoverDom: this.addHoverDom,
removeHoverDom: this.removeHoverDom,
}
}
};
},
methods: {
addHoverDom(treeid, treeNode) {
const item = document.getElementById(`${treeNode.tId}_a`);
if (item && !item.querySelector('.tree_extra_btn')) {
const btn = document.createElement('sapn');
btn.id = `${treeid}_${treeNode.id}_btn`;
btn.classList.add('tree_extra_btn');
btn.innerText = '删除';
btn.addEventListener('click', (e) => {
e.stopPropagation()
this.clickRemove(treeNode)
})
item.appendChild(btn);
}
},
removeHoverDom(treeid, treeNode) {
const item = document.getElementById(`${treeNode.tId}_a`);
if (item) {
const btn = item.querySelector('.tree_extra_btn');
if (btn) {
item.removeChild(btn)
}
}
},
clickRemove(treeNode) {
console.log('remove', treeNode)
this.ztreeObj && this.ztreeObj.removeNode(treeNode)
},
onClick: function (evt, treeId, treeNode) {
// 点击事件
console.log(evt.type, treeNode);
},
onCheck: function (evt, treeId, treeNode) {
// 选中事件
console.log(evt.type, treeNode);
},
handleCreated: function (ztreeObj) {
this.ztreeObj = ztreeObj;
// onCreated 中操作ztreeObj对象展开第一个节点
ztreeObj.expandNode(ztreeObj.getNodes(), true);
//ztreeObj.expandAll(true);
},
update: function () {
// 更新示例数据
this.showIndex = this.showIndex === 0 ? 1 : 0;
}
}
};
</script>
<style scoped>
.T {
font-size: 34px;
margin: 0 0 30px;
overflow: hidden;
}
</style> 第三种：vxe-table-plugin-virtual-tree
这个插件是为相识决vxe-table的v2.0版本不支持虚拟树，vxe-table的3.0版本如今支持虚拟树了，也可以使用vxe-table v3.0。
githup链接：https://github.com/x-extends/vxe-table-plugin-virtual-tree
api链接:
xe-table v2
这个插件只用了展示树形结构，大概表格树还是比较方便的，但是数据量太大时候，勾选操作还是略卡。但是十万数据以内速率还不错，关键是它可以做成表格树。
总结：
具体用哪一种，看你的具体情况了。
假如仅仅是树形展示，那就第一种vue-easy-tree，方便简朴。假如数据量超级大，节点多，但是每个节点的数量不多，还要兼容ie，那就第二种zTree，假如要展示表格树，那就第三种vue-virtual-tree
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]