Tree树形控件

何时使用

文件夹、组织架构、生物分类、国家地区等等，世间万物的大多数结构都是树形结构。使用树控件可以完整展现其中的层级关系，并具有展开收起选择等交互功能。

代码演示

Tree树形控件 - 图1

基本

最简单的用法，展示可勾选，可选中，禁用，默认展开等功能。

  1. import { Tree } from 'antd';
  3. const { TreeNode } = Tree;
  5. class Demo extends React.Component {
  6.   onSelect = (selectedKeys, info) => {
  7.     console.log('selected', selectedKeys, info);
  8.   };
  10.   onCheck = (checkedKeys, info) => {
  11.     console.log('onCheck', checkedKeys, info);
  12.   };
  14.   render() {
  15.     return (
  16.       <Tree
  17.         checkable
  18.         defaultExpandedKeys={['0-0-0', '0-0-1']}
  19.         defaultSelectedKeys={['0-0-0', '0-0-1']}
  20.         defaultCheckedKeys={['0-0-0', '0-0-1']}
  21.         onSelect={this.onSelect}
  22.         onCheck={this.onCheck}
  23.       >
  24.         <TreeNode title="parent 1" key="0-0">
  25.           <TreeNode title="parent 1-0" key="0-0-0" disabled>
  26.             <TreeNode title="leaf" key="0-0-0-0" disableCheckbox />
  27.             <TreeNode title="leaf" key="0-0-0-1" />
  28.           </TreeNode>
  29.           <TreeNode title="parent 1-1" key="0-0-1">
  30.             <TreeNode title={<span style={{ color: '#1890ff' }}>sss</span>} key="0-0-1-0" />
  31.           </TreeNode>
  32.         </TreeNode>
  33.       </Tree>
  34.     );
  35.   }
  36. }
  38. ReactDOM.render(<Demo />, mountNode);

Tree树形控件 - 图2

拖动示例

将节点拖拽到其他节点内部或前后。

  1. import { Tree } from 'antd';
  3. const { TreeNode } = Tree;
  5. const x = 3;
  6. const y = 2;
  7. const z = 1;
  8. const gData = [];
  10. const generateData = (_level, _preKey, _tns) => {
  11.   const preKey = _preKey || '0';
  12.   const tns = _tns || gData;
  14.   const children = [];
  15.   for (let i = 0; i < x; i++) {
  16.     const key = `${preKey}-${i}`;
  17.     tns.push({ title: key, key });
  18.     if (i < y) {
  19.       children.push(key);
  20.     }
  21.   }
  22.   if (_level < 0) {
  23.     return tns;
  24.   }
  25.   const level = _level - 1;
  26.   children.forEach((key, index) => {
  27.     tns[index].children = [];
  28.     return generateData(level, key, tns[index].children);
  29.   });
  30. };
  31. generateData(z);
  33. class Demo extends React.Component {
  34.   state = {
  35.     gData,
  36.     expandedKeys: ['0-0', '0-0-0', '0-0-0-0'],
  37.   };
  39.   onDragEnter = info => {
  40.     console.log(info);
  41.     // expandedKeys 需要受控时设置
  42.     // this.setState({
  43.     //   expandedKeys: info.expandedKeys,
  44.     // });
  45.   };
  47.   onDrop = info => {
  48.     console.log(info);
  49.     const dropKey = info.node.props.eventKey;
  50.     const dragKey = info.dragNode.props.eventKey;
  51.     const dropPos = info.node.props.pos.split('-');
  52.     const dropPosition = info.dropPosition - Number(dropPos[dropPos.length - 1]);
  54.     const loop = (data, key, callback) => {
  55.       data.forEach((item, index, arr) => {
  56.         if (item.key === key) {
  57.           return callback(item, index, arr);
  58.         }
  59.         if (item.children) {
  60.           return loop(item.children, key, callback);
  61.         }
  62.       });
  63.     };
  64.     const data = [...this.state.gData];
  66.     // Find dragObject
  67.     let dragObj;
  68.     loop(data, dragKey, (item, index, arr) => {
  69.       arr.splice(index, 1);
  70.       dragObj = item;
  71.     });
  73.     if (!info.dropToGap) {
  74.       // Drop on the content
  75.       loop(data, dropKey, item => {
  76.         item.children = item.children || [];
  77.         // where to insert 示例添加到尾部，可以是随意位置
  78.         item.children.push(dragObj);
  79.       });
  80.     } else if (
  81.       (info.node.props.children || []).length > 0 && // Has children
  82.       info.node.props.expanded && // Is expanded
  83.       dropPosition === 1 // On the bottom gap
  84.     ) {
  85.       loop(data, dropKey, item => {
  86.         item.children = item.children || [];
  87.         // where to insert 示例添加到尾部，可以是随意位置
  88.         item.children.unshift(dragObj);
  89.       });
  90.     } else {
  91.       let ar;
  92.       let i;
  93.       loop(data, dropKey, (item, index, arr) => {
  94.         ar = arr;
  95.         i = index;
  96.       });
  97.       if (dropPosition === -1) {
  98.         ar.splice(i, 0, dragObj);
  99.       } else {
  100.         ar.splice(i + 1, 0, dragObj);
  101.       }
  102.     }
  104.     this.setState({
  105.       gData: data,
  106.     });
  107.   };
  109.   render() {
  110.     const loop = data =>
  111.       data.map(item => {
  112.         if (item.children && item.children.length) {
  113.           return (
  114.             <TreeNode key={item.key} title={item.title}>
  115.               {loop(item.children)}
  116.             </TreeNode>
  117.           );
  118.         }
  119.         return <TreeNode key={item.key} title={item.title} />;
  120.       });
  121.     return (
  122.       <Tree
  123.         className="draggable-tree"
  124.         defaultExpandedKeys={this.state.expandedKeys}
  125.         draggable
  126.         blockNode
  127.         onDragEnter={this.onDragEnter}
  128.         onDrop={this.onDrop}
  129.       >
  130.         {loop(this.state.gData)}
  131.       </Tree>
  132.     );
  133.   }
  134. }
  136. ReactDOM.render(<Demo />, mountNode);

Tree树形控件 - 图3

可搜索

可搜索的树。

  1. import { Tree, Input } from 'antd';
  3. const { TreeNode } = Tree;
  4. const { Search } = Input;
  6. const x = 3;
  7. const y = 2;
  8. const z = 1;
  9. const gData = [];
  11. const generateData = (_level, _preKey, _tns) => {
  12.   const preKey = _preKey || '0';
  13.   const tns = _tns || gData;
  15.   const children = [];
  16.   for (let i = 0; i < x; i++) {
  17.     const key = `${preKey}-${i}`;
  18.     tns.push({ title: key, key });
  19.     if (i < y) {
  20.       children.push(key);
  21.     }
  22.   }
  23.   if (_level < 0) {
  24.     return tns;
  25.   }
  26.   const level = _level - 1;
  27.   children.forEach((key, index) => {
  28.     tns[index].children = [];
  29.     return generateData(level, key, tns[index].children);
  30.   });
  31. };
  32. generateData(z);
  34. const dataList = [];
  35. const generateList = data => {
  36.   for (let i = 0; i < data.length; i++) {
  37.     const node = data[i];
  38.     const { key } = node;
  39.     dataList.push({ key, title: key });
  40.     if (node.children) {
  41.       generateList(node.children);
  42.     }
  43.   }
  44. };
  45. generateList(gData);
  47. const getParentKey = (key, tree) => {
  48.   let parentKey;
  49.   for (let i = 0; i < tree.length; i++) {
  50.     const node = tree[i];
  51.     if (node.children) {
  52.       if (node.children.some(item => item.key === key)) {
  53.         parentKey = node.key;
  54.       } else if (getParentKey(key, node.children)) {
  55.         parentKey = getParentKey(key, node.children);
  56.       }
  57.     }
  58.   }
  59.   return parentKey;
  60. };
  62. class SearchTree extends React.Component {
  63.   state = {
  64.     expandedKeys: [],
  65.     searchValue: '',
  66.     autoExpandParent: true,
  67.   };
  69.   onExpand = expandedKeys => {
  70.     this.setState({
  71.       expandedKeys,
  72.       autoExpandParent: false,
  73.     });
  74.   };
  76.   onChange = e => {
  77.     const { value } = e.target;
  78.     const expandedKeys = dataList
  79.       .map(item => {
  80.         if (item.title.indexOf(value) > -1) {
  81.           return getParentKey(item.key, gData);
  82.         }
  83.         return null;
  84.       })
  85.       .filter((item, i, self) => item && self.indexOf(item) === i);
  86.     this.setState({
  87.       expandedKeys,
  88.       searchValue: value,
  89.       autoExpandParent: true,
  90.     });
  91.   };
  93.   render() {
  94.     const { searchValue, expandedKeys, autoExpandParent } = this.state;
  95.     const loop = data =>
  96.       data.map(item => {
  97.         const index = item.title.indexOf(searchValue);
  98.         const beforeStr = item.title.substr(0, index);
  99.         const afterStr = item.title.substr(index + searchValue.length);
  100.         const title =
  101.           index > -1 ? (
  102.             <span>
  103.               {beforeStr}
  104.               <span style={{ color: '#f50' }}>{searchValue}</span>
  105.               {afterStr}
  106.             </span>
  107.           ) : (
  108.             <span>{item.title}</span>
  109.           );
  110.         if (item.children) {
  111.           return (
  112.             <TreeNode key={item.key} title={title}>
  113.               {loop(item.children)}
  114.             </TreeNode>
  115.           );
  116.         }
  117.         return <TreeNode key={item.key} title={title} />;
  118.       });
  119.     return (
  120.       <div>
  121.         <Search style={{ marginBottom: 8 }} placeholder="Search" onChange={this.onChange} />
  122.         <Tree
  123.           onExpand={this.onExpand}
  124.           expandedKeys={expandedKeys}
  125.           autoExpandParent={autoExpandParent}
  126.         >
  127.           {loop(gData)}
  128.         </Tree>
  129.       </div>
  130.     );
  131.   }
  132. }
  134. ReactDOM.render(<SearchTree />, mountNode);

Tree树形控件 - 图4

自定义图标

可以针对不同的节点定制图标。

  1. import { Tree, Icon } from 'antd';
  3. const { TreeNode } = Tree;
  5. ReactDOM.render(
  6.   <Tree
  7.     showIcon
  8.     defaultExpandAll
  9.     defaultSelectedKeys={['0-0-0']}
  10.     switcherIcon={<Icon type="down" />}
  11.   >
  12.     <TreeNode icon={<Icon type="smile-o" />} title="parent 1" key="0-0">
  13.       <TreeNode icon={<Icon type="meh-o" />} title="leaf" key="0-0-0" />
  14.       <TreeNode
  15.         icon={({ selected }) => <Icon type={selected ? 'frown' : 'frown-o'} />}
  16.         title="leaf"
  17.         key="0-0-1"
  18.       />
  19.     </TreeNode>
  20.   </Tree>,
  21.   mountNode,
  22. );

Tree树形控件 - 图5

受控操作示例

受控操作示例

  1. import { Tree } from 'antd';
  3. const { TreeNode } = Tree;
  5. const treeData = [
  6.   {
  7.     title: '0-0',
  8.     key: '0-0',
  9.     children: [
  10.       {
  11.         title: '0-0-0',
  12.         key: '0-0-0',
  13.         children: [
  14.           { title: '0-0-0-0', key: '0-0-0-0' },
  15.           { title: '0-0-0-1', key: '0-0-0-1' },
  16.           { title: '0-0-0-2', key: '0-0-0-2' },
  17.         ],
  18.       },
  19.       {
  20.         title: '0-0-1',
  21.         key: '0-0-1',
  22.         children: [
  23.           { title: '0-0-1-0', key: '0-0-1-0' },
  24.           { title: '0-0-1-1', key: '0-0-1-1' },
  25.           { title: '0-0-1-2', key: '0-0-1-2' },
  26.         ],
  27.       },
  28.       {
  29.         title: '0-0-2',
  30.         key: '0-0-2',
  31.       },
  32.     ],
  33.   },
  34.   {
  35.     title: '0-1',
  36.     key: '0-1',
  37.     children: [
  38.       { title: '0-1-0-0', key: '0-1-0-0' },
  39.       { title: '0-1-0-1', key: '0-1-0-1' },
  40.       { title: '0-1-0-2', key: '0-1-0-2' },
  41.     ],
  42.   },
  43.   {
  44.     title: '0-2',
  45.     key: '0-2',
  46.   },
  47. ];
  49. class Demo extends React.Component {
  50.   state = {
  51.     expandedKeys: ['0-0-0', '0-0-1'],
  52.     autoExpandParent: true,
  53.     checkedKeys: ['0-0-0'],
  54.     selectedKeys: [],
  55.   };
  57.   onExpand = expandedKeys => {
  58.     console.log('onExpand', expandedKeys);
  59.     // if not set autoExpandParent to false, if children expanded, parent can not collapse.
  60.     // or, you can remove all expanded children keys.
  61.     this.setState({
  62.       expandedKeys,
  63.       autoExpandParent: false,
  64.     });
  65.   };
  67.   onCheck = checkedKeys => {
  68.     console.log('onCheck', checkedKeys);
  69.     this.setState({ checkedKeys });
  70.   };
  72.   onSelect = (selectedKeys, info) => {
  73.     console.log('onSelect', info);
  74.     this.setState({ selectedKeys });
  75.   };
  77.   renderTreeNodes = data =>
  78.     data.map(item => {
  79.       if (item.children) {
  80.         return (
  81.           <TreeNode title={item.title} key={item.key} dataRef={item}>
  82.             {this.renderTreeNodes(item.children)}
  83.           </TreeNode>
  84.         );
  85.       }
  86.       return <TreeNode {...item} />;
  87.     });
  89.   render() {
  90.     return (
  91.       <Tree
  92.         checkable
  93.         onExpand={this.onExpand}
  94.         expandedKeys={this.state.expandedKeys}
  95.         autoExpandParent={this.state.autoExpandParent}
  96.         onCheck={this.onCheck}
  97.         checkedKeys={this.state.checkedKeys}
  98.         onSelect={this.onSelect}
  99.         selectedKeys={this.state.selectedKeys}
  100.       >
  101.         {this.renderTreeNodes(treeData)}
  102.       </Tree>
  103.     );
  104.   }
  105. }
  107. ReactDOM.render(<Demo />, mountNode);

Tree树形控件 - 图6

异步数据加载

点击展开节点，动态加载数据。

  1. import { Tree } from 'antd';
  3. const { TreeNode } = Tree;
  5. class Demo extends React.Component {
  6.   state = {
  7.     treeData: [
  8.       { title: 'Expand to load', key: '0' },
  9.       { title: 'Expand to load', key: '1' },
  10.       { title: 'Tree Node', key: '2', isLeaf: true },
  11.     ],
  12.   };
  14.   onLoadData = treeNode =>
  15.     new Promise(resolve => {
  16.       if (treeNode.props.children) {
  17.         resolve();
  18.         return;
  19.       }
  20.       setTimeout(() => {
  21.         treeNode.props.dataRef.children = [
  22.           { title: 'Child Node', key: `${treeNode.props.eventKey}-0` },
  23.           { title: 'Child Node', key: `${treeNode.props.eventKey}-1` },
  24.         ];
  25.         this.setState({
  26.           treeData: [...this.state.treeData],
  27.         });
  28.         resolve();
  29.       }, 1000);
  30.     });
  32.   renderTreeNodes = data =>
  33.     data.map(item => {
  34.       if (item.children) {
  35.         return (
  36.           <TreeNode title={item.title} key={item.key} dataRef={item}>
  37.             {this.renderTreeNodes(item.children)}
  38.           </TreeNode>
  39.         );
  40.       }
  41.       return <TreeNode {...item} dataRef={item} />;
  42.     });
  44.   render() {
  45.     return <Tree loadData={this.onLoadData}>{this.renderTreeNodes(this.state.treeData)}</Tree>;
  46.   }
  47. }
  49. ReactDOM.render(<Demo />, mountNode);

Tree树形控件 - 图7

连接线

带连接线的树。

  1. import { Tree } from 'antd';
  3. const { TreeNode } = Tree;
  5. class Demo extends React.Component {
  6.   onSelect = (selectedKeys, info) => {
  7.     console.log('selected', selectedKeys, info);
  8.   };
  10.   render() {
  11.     return (
  12.       <Tree showLine defaultExpandedKeys={['0-0-0']} onSelect={this.onSelect}>
  13.         <TreeNode title="parent 1" key="0-0">
  14.           <TreeNode title="parent 1-0" key="0-0-0">
  15.             <TreeNode title="leaf" key="0-0-0-0" />
  16.             <TreeNode title="leaf" key="0-0-0-1" />
  17.             <TreeNode title="leaf" key="0-0-0-2" />
  18.           </TreeNode>
  19.           <TreeNode title="parent 1-1" key="0-0-1">
  20.             <TreeNode title="leaf" key="0-0-1-0" />
  21.           </TreeNode>
  22.           <TreeNode title="parent 1-2" key="0-0-2">
  23.             <TreeNode title="leaf" key="0-0-2-0" />
  24.             <TreeNode title="leaf" key="0-0-2-1" />
  25.           </TreeNode>
  26.         </TreeNode>
  27.       </Tree>
  28.     );
  29.   }
  30. }
  32. ReactDOM.render(<Demo />, mountNode);

Tree树形控件 - 图8

目录

内置的目录树，multiple 模式支持 ctrl(Windows) / command(Mac) 复选。

  1. import { Tree } from 'antd';
  3. const { TreeNode, DirectoryTree } = Tree;
  5. class Demo extends React.Component {
  6.   onSelect = (keys, event) => {
  7.     console.log('Trigger Select', keys, event);
  8.   };
  10.   onExpand = () => {
  11.     console.log('Trigger Expand');
  12.   };
  14.   render() {
  15.     return (
  16.       <DirectoryTree multiple defaultExpandAll onSelect={this.onSelect} onExpand={this.onExpand}>
  17.         <TreeNode title="parent 0" key="0-0">
  18.           <TreeNode title="leaf 0-0" key="0-0-0" isLeaf />
  19.           <TreeNode title="leaf 0-1" key="0-0-1" isLeaf />
  20.         </TreeNode>
  21.         <TreeNode title="parent 1" key="0-1">
  22.           <TreeNode title="leaf 1-0" key="0-1-0" isLeaf />
  23.           <TreeNode title="leaf 1-1" key="0-1-1" isLeaf />
  24.         </TreeNode>
  25.       </DirectoryTree>
  26.     );
  27.   }
  28. }
  30. ReactDOM.render(<Demo />, mountNode);

API

Tree props

参数说明类型默认值
autoExpandParent是否自动展开父节点booleantrue
blockNode是否节点占据一行booleanfalse
checkable节点前添加 Checkbox 复选框booleanfalse
checkedKeys（受控）选中复选框的树节点（注意：父子节点有关联，如果传入父节点 key，则子节点自动选中；相应当子节点 key 都传入，父节点也自动选中。当设置checkable和checkStrictly，它是一个有checked和halfChecked属性的对象，并且父子节点的选中与否不再关联string[] | {checked: string[], halfChecked: string[]}[]
checkStrictlycheckable 状态下节点选择完全受控（父子节点选中状态不再关联）booleanfalse
defaultCheckedKeys默认选中复选框的树节点string[][]
defaultExpandAll默认展开所有树节点booleanfalse
defaultExpandedKeys默认展开指定的树节点string[][]
defaultExpandParent默认展开父节点booltrue
defaultSelectedKeys默认选中的树节点string[][]
disabled将树禁用boolfalse
draggable设置节点可拖拽（IE>8）booleanfalse
expandedKeys（受控）展开指定的树节点string[][]
filterTreeNode按需筛选树节点（高亮），返回 truefunction(node)-
loadData异步加载数据function(node)-
loadedKeys（受控）已经加载的节点，需要配合 loadData 使用string[][]
multiple支持点选多个节点（节点本身）booleanfalse
selectedKeys（受控）设置选中的树节点string[]-
showIcon是否展示 TreeNode title 前的图标，没有默认样式，如设置为 true，需要自行定义图标相关样式booleanfalse
switcherIcon自定义树节点的展开/折叠图标React.ReactElement-
showLine是否展示连接线booleanfalse
onCheck点击复选框触发function(checkedKeys, e:{checked: bool, checkedNodes, node, event})-
onDragEnddragend 触发时调用function({event, node})-
onDragEnterdragenter 触发时调用function({event, node, expandedKeys})-
onDragLeavedragleave 触发时调用function({event, node})-
onDragOverdragover 触发时调用function({event, node})-
onDragStart开始拖拽时调用function({event, node})-
onDropdrop 触发时调用function({event, node, dragNode, dragNodesKeys})-
onExpand展开/收起节点时触发function(expandedKeys, {expanded: bool, node})-
onLoad节点加载完毕时触发function(loadedKeys, {event, node})-
onRightClick响应右键点击function({event, node})-
onSelect点击树节点触发function(selectedKeys, e:{selected: bool, selectedNodes, node, event})-
treeDatatreeNodes 数据，如果设置则不需要手动构造 TreeNode 节点（key 在整个树范围内唯一）array\<{key, title, children, [disabled, selectable]}>-

TreeNode props

参数说明类型默认值版本
checkable当树为 checkable 时，设置独立节点是否展示 Checkboxboolean-3.17.0
disableCheckbox禁掉 checkboxbooleanfalse
disabled禁掉响应booleanfalse
icon自定义图标。可接收组件，props 为当前节点 propsReactNode/Function(props):ReactNode-
isLeaf设置为叶子节点(设置了loadData时有效)booleanfalse
key被树的 (default)ExpandedKeys / (default)CheckedKeys / (default)SelectedKeys 属性所用。注意：整个树范围内的所有节点的 key 值不能重复！string内部计算出的节点位置
selectable设置节点是否可被选中booleantrue
title标题string|ReactNode'—-'

DirectoryTree props

参数说明类型默认值
expandAction目录展开逻辑，可选 false 'click' 'doubleClick'stringclick

注意

在 3.4.0 之前：树节点可以有很多，但在设置checkable时，将会花费更多的计算时间，因此我们缓存了一些计算结果（this.treeNodesStates）来复用，避免多次重复计算，以此提高性能。但这也带来了一些限制，当你异步加载树节点时，你需要这样渲染树：

  1. {
  2.   this.state.treeData.length ? (
  3.     <Tree>
  4.       {this.state.treeData.map(data => (
  5.         <TreeNode />
  6.       ))}
  7.     </Tree>
  8.   ) : (
  9.     'loading tree'
  10.   );
  11. }

FAQ

在 showLine 时，如何隐藏子节点图标？

文件图标通过 switcherIcon 来实现，如果不需要你可以覆盖对应的样式：https://codesandbox.io/s/883vo47xp8