我们经常会遇到有大量的数据需要使用表格的形式展示在界面上的场景，通常一些表格组件会提供虚拟滚动的能力来解决这个场景中出现的性能问题。那么你是否有想过，虚拟滚动是如何实现的吗？今天笔者就带一起尝试写一个这样的组件。

交互效果图：
1.gif

整个需求很简单，也比较容易理解，就不废话了。

定义属性

Table 组件可以定义的属性很多，但在本示例中我们只看虚拟滚动的实现，故暂且把其他的属性都放到一边不理。但有两个是表格组件的基础，是不能不理会的，那就是 dataSource 和 columns。同样的，columns 在本文中也是最简配置。简单说明如下：

  • dataSource：用于显示的表格内数据，数据结构为对象数组；
  • columns: 用于定义表格列信息，数据结构也为对象数组；对象必须包含 code, name, width 三个字段
    • code: 用于显示数据的字段Key，对应 dataSource 对象中的Key
    • name: 列标题名称，展示在表头中
    • width: 列的宽度，每个列可以设置自己的宽度；

根据以上定义，构建以下测试数据：

  1. // 因为要模拟大数据量，真的一条一条 mock 数据是不现实的，写两个小函数吧
  3. // 构建 dataSource 数据
  4. const createDataSource = (rows, cols) => {
  5.   const result = [];
  6.   for (let i = 0; i < rows; i++) {
  7.     const item = {};
  8.     for (let j = 0; j < cols; j++) {
  9.       item[`col_${j}`] = `ROW--${i}, COLUMN--${j}`;
  10.     }
  11.     result.push(item);
  12.   }
  13.   return result;
  14. };
  16. // 构建 columns 列信息
  17. const createColumns = (data) => {
  18.   const item = data[0];
  19.   const columns = [];
  20.   Object.keys(item).forEach((key) => {
  21.     columns.push({
  22.       code: key,
  23.       name: key,
  24.       width: 180,
  25.     });
  26.   });
  27.   return columns;
  28. };

构建基本表格

先构建一个表格头部固定，内容区域可以进行横向、纵向滚动的基本组件来。直接使用一个 table 标签是无法达到这个效果的。所以我们需要把 Header 和 Body 放在两个容器中，并配上相应的样式。代码如下：

UseVirtualTable.jsx

  1. import React, { PureComponent } from 'react';
  2. import './UseVirtualTable.less';
  4. class UseVirtualTable extends PureComponent {
  5.   tableHeaderRender = () => {
  6.       const { columns } = this.props;
  7.     const cols = [];
  8.     const ths = [];
  9.     columns.forEach((col, i) => {
  10.       const { code, name, width = 160 } = col;
  11.       const key = `${key}-${i}`;
  12.       cols.push(<col key={key} width={`${width}px`} />);
  13.       ths.push(<th key={key} className="table-header-cell">{name}</th>);
  14.     });
  16.     return (
  17.       <div className="table-header" ref={this.getTableHeaderDom}>
  18.         <table>
  19.           <colgroup>{cols}</colgroup>
  20.           <thead>
  21.             <tr className='table-header-row'>{ths}</tr>
  22.           </thead>
  23.         </table>
  24.       </div>
  25.     );
  26.   };
  28.   tableBodyRender = () => {
  29.     const { columns, dataSource = [] } = this.props;
  30.     const cols = [];
  31.     columns.forEach((col, i) => {
  32.       const { code, width = 160 } = col;
  33.       cols.push(<col key={`${code}-${i}`} width={`${width}px`} />);
  34.     });
  36.     return (
  37.       <div className="table-body">
  38.           <table>
  39.             <colgroup>{cols}</colgroup>
  40.             <tbody>
  41.               {dataSource.map((row, i) => {
  42.                 return (
  43.                   <tr className="table-row" key={i} data-rowindex={i}>
  44.                     {columns.map(({ code }, j) => {
  45.                       return <td className="table-cell" key={`${code}-${j}`} data-colindex={j}>{row[code]}</td>;
  46.                     })}
  47.                   </tr>
  48.                 );
  49.               })}
  50.             </tbody>
  51.           </table>
  52.       </div>
  53.     );
  54.   };
  56.   render() {
  57.       return (
  58.         <div className="use-virtual-table">
  59.         <div className="use-virtual-table-body">
  60.           {this.tableHeaderRender()}
  61.           {this.tableBodyRender()}
  62.         </div>
  63.       </div>
  64.     );
  65.   }
  66. }
  68. export default UseVirtualTable;

UseVirtualTable.less

  1. .use-virtual-table {
  2.   --border-color: #eee;
  3.   --th-background-color: #f5f5f5;
  4.   --table-header-height: 34px;
  6.   position: relative;
  7.   height: 100%; // 与容器高度保持一致
  8.   width: 100%;
  10.   .use-virtual-table-body {
  11.     display: flex;
  12.     flex-direction: column;
  13.     width: 100%;
  14.     height: 100%;
  15.     background-color: var(--th-background-color);
  16.     overflow-y: hidden; // 这个表格区域实现横向滚动
  17.     overflow-x: auto;
  18.   }
  20.   table {
  21.     table-layout: fixed;
  22.     width: 100%;
  23.     border-collapse: separate;
  24.     border-spacing: 0;
  25.   }
  27.   .table-header {
  28.     flex-shrink: 0;
  29.     height: var(--table-header-height);
  31.     th.table-header-cell {
  32.       border-top: 1px solid var(--border-color);
  33.       border-left: 1px solid var(--border-color);
  34.       border-bottom: 1px solid var(--border-color);
  35.       background-color: var(--th-background-color);
  36.       padding: 8px 12px;
  37.       text-align: left;
  38.     }
  39.   }
  41.   .table-body {
  42.     flex: 1;
  43.     width: fit-content;
  44.     background-color: #fff;
  45.     overflow-y: auto; // 内容区域实现纵向滚动
  47.     td.table-cell {
  48.       border-left: 1px solid var(--border-color);
  49.       border-top: 1px solid var(--border-color);
  50.       padding: 8px 12px;
  51.     }
  53.     tr:last-child td.table-cell {
  54.       border-bottom: 1px solid var(--border-color);
  55.     }
  56.   }
  57. }

此处使用 Flex 实现了整个表格的内容高度可以随容器自由伸缩，且内容区域纵向滚动，表格头部和内容同时进行横向滚动。效果如图：
1.gif

虚拟滚动

虚拟滚动的本质是仅渲染可视区域的内容，所以需要实现的逻辑是：

  1. 计算可视区域的 width 和 height
  2. 再依据 scrollTop 或 scrollLeft 推算出可视区域显示那几行及那几列
  3. 在滚动时，实时计算第2步
  4. 计算出表格内容的总高度，scrollTop 隐藏的部分使用 paddingTop 表示
  5. 计算出表格内容的总宽度，分别用两个 td 标签表示前、后未被渲染的部分

第4步在 HTML 中的呈现：
image.png
第5步在 HTML 中的呈现：
image.png

还有一个问题是纵向滚动条藏在最右侧，只有横向滚动条滚动到底之后才能看的到 —— 这显然是不符合预期的。所以我们要放一个“假的滚动条”始终显示在可视区域的右侧。如此一来“假滚动条”需要与内容滚动条保持一致。“假滚动条”在 HTML 中的呈现：
image.png

UseVirtualTable.jsx (完整代码)

  1. // 计算出滚动条的宽度；用于“假滚动条”
  2. function getScrollbarWidth() {
  3.   const scrollDiv = document.createElement('div');
  4.   scrollDiv.style.cssText = 'width: 99px; height: 99px; overflow: scroll; position: absolute; top: -9999px;';
  5.   document.body.appendChild(scrollDiv);
  6.   const scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
  7.   document.body.removeChild(scrollDiv);
  9.   return scrollbarWidth;
  10. }
  12. const DEFAULT_ROW_HEIGHT = 32; // 默认表格单行高度
  13. const OFFSET_HORIZONTAL = 300; // 横向滚动前、后偏移量
  14. const OFFSET_VERTICAL = 120; // 纵向滚动上、下偏移量
  16. const POSITION_TABLE_BODY = 'tableBody'; // 表示纵向滚动响应位置在表格内容上
  17. const POSITION_VERTICAL_BAR = 'verticalBar'; // 表示纵向滚动响应位置在假滚动条上
  19. class UseVirtualTable extends PureComponent {
  20.   virtualTable = null;
  21.   virtualTableHeight = 0; // 虚拟表格高度
  22.   virtualTableWidth = 0; // 虚拟表格宽度
  23.   scrollBarWidth = getScrollbarWidth(); // 滚动条宽度
  24.   scrollDom = null; // 纵向假滚动条节点
  25.   horizontalDom = null; // 横向滚动节点
  26.   verticalDom = null; // 纵向滚动节点
  27.   mousePosition = ''; // 鼠标所在位置，用于区别纵向滚动由哪个节点相应的
  28.   state = {
  29.     totalHeight: 0, // 表格内容区域总高度
  30.     totalWidth: 0, // 表格内容区域总宽度
  31.     hiddenTopStyle: { // 顶部隐藏样式
  32.       height: `0px`,
  33.     },
  34.     hiddenLeftStyle: { // 左侧隐藏样式
  35.       width: `0px`,
  36.     },
  37.     hiddenRightStyle: { // 右侧隐藏样式
  38.       width: `0px`,
  39.     },
  40.     rowSize: [0, 0], // 可视区域显示的行号
  41.     colSize: [0, 0], // 可视区域显示的列号
  42.   };
  44.   componentDidMount() {
  45.     this.setVirtualSize();
  46.     this.setVerticalData();
  47.     this.setHorizontalData();
  48.   }
  50.   // 设置虚拟表格高度、宽度
  51.   setVirtualSize = (dom) => {
  52.     const virtualTable = dom || this.virtualTable;
  53.     const height = virtualTable?.clientHeight;
  54.     const width = virtualTable?.clientWidth;
  55.     if (height && width) {
  56.       this.virtualTableHeight = height;
  57.       this.virtualTableWidth = width;
  58.     }
  59.   };
  61.   getVirtualTableRef = (dom) => {
  62.     this.virtualTable = dom || this.virtualTable;
  63.     this.setVirtualSize(dom);
  64.   };
  66.   getTableHeaderDom = (dom) => {
  67.     this.tableHeader = dom || this.tableHeader;
  68.   };
  70.   getScrollDom = (dom) => {
  71.     this.scrollDom = dom || this.scrollDom;
  72.   };
  74.   getHorizontalDom = (dom) => {
  75.     this.horizontalDom = dom || this.horizontalDom;
  76.   };
  78.   getVerticalDom = (dom) => {
  79.     this.verticalDom = dom || this.verticalDom;
  80.   };
  82.   // 设置虚拟表格纵向数据；在纵向滚动时使用
  83.   setVerticalData = () => {
  84.     const scrollTop = this.verticalDom && this.verticalDom.scrollTop;
  85.     const { dataSource = [], columns = [] } = this.props;
  86.     const { rowSize: oRowSize, colSize: oColSize } = this.state;
  87.     // 计算表格头部所占用的高度
  88.     const headerHeight = this.tableHeader?.clientHeight;
  89.     // 计算表格内容可视区域高度
  90.     const height = this.virtualTableHeight - headerHeight;
  91.     const rowSize = [];
  92.     let totalHeight = 0;
  93.     let hiddenTopHeight = 0; // 计算顶部隐藏区域的高度
  94.     let hiddenButtomHeight = 0;
  95.     let currentStep = 0; // 0: 顶部被隐藏阶段；1: 可视区域阶段
  96.     if (!height) {
  97.       return;
  98.     }
  100.     dataSource.forEach((item, i) => {
  101.       // 获取行高，目前这里是最简化的，可以根据需要进行扩展
  102.       const rowHeight = DEFAULT_ROW_HEIGHT;
  103.       totalHeight += rowHeight;
  104.       if (currentStep === 0) {
  105.         if (totalHeight >= scrollTop - OFFSET_VERTICAL) {
  106.           // 根据 scrollTop 算出可视区域起始行号
  107.           rowSize[0] = i;
  108.           currentStep += 1;
  109.         } else {
  110.           hiddenTopHeight += rowHeight;
  111.         }
  112.       } else if (currentStep === 1) {
  113.         if (totalHeight > scrollTop + height + OFFSET_VERTICAL) {
  114.           // 计算出可视区域结束行号
  115.           rowSize[1] = i;
  116.           currentStep += 1;
  117.         }
  118.       }
  119.     });
  121.     if (oRowSize.join() !== rowSize.join()) {
  122.       // 可视区域的行号有了变化才重新进行渲染
  123.       this.setState({
  124.         hiddenTopStyle: { height: `${hiddenTopHeight}px` },
  125.         rowSize,
  126.         totalHeight,
  127.       });
  128.     }
  129.   };
  131.   // 设置虚拟表格横向数据；在横向滚动时使用
  132.   setHorizontalData = () => {
  133.     const scrollLeft = this.horizontalDom && this.horizontalDom.scrollLeft;
  134.     const { columns = [] } = this.props;
  135.     const { colSize: oColSize } = this.state;
  136.     // 表格内容可视区域的宽度
  137.     const width = this.virtualTableWidth;
  138.     const colSize = [];
  139.     let totalWidth = 0;
  140.     let hiddenLeftWidth = 0; // 左侧隐藏未被渲染的宽度
  141.     let hiddenRigthWidth = 0; // 右侧隐藏未被渲染的宽度
  142.     let currentStep = 0; // 0: 前面被隐藏阶段；1: 可视区域阶段；2: 后面不可见区域
  143.     if (!width) {
  144.       return;
  145.     }
  147.     columns.forEach((item, i) => {
  148.       const { width: colWidth = 160 } = item;
  149.       totalWidth += colWidth;
  150.       if (currentStep === 0) {
  151.         if (totalWidth >= scrollLeft - OFFSET_HORIZONTAL) {
  152.           // 根据 scrollLeft 算出可视区域起始行号
  153.           colSize[0] = i;
  154.           currentStep += 1;
  155.         } else {
  156.           hiddenLeftWidth += colWidth;
  157.         }
  158.       }
  159.       if (currentStep === 1 && totalWidth > scrollLeft + width + OFFSET_HORIZONTAL) {
  160.         // 计算出可视区域结束列号
  161.         colSize[1] = i;
  162.         currentStep += 1;
  163.       }
  164.       if (currentStep === 2) {
  165.         hiddenRigthWidth += colWidth;
  166.       }
  167.     });
  169.     if (oColSize.join() !== colSize.join()) {
  170.       // 可视区域的列号有了变化才重新进行渲染
  171.       this.setState({
  172.         hiddenLeftStyle: { width: `${hiddenLeftWidth}px` },
  173.         hiddenRightStyle: { width: `${hiddenRigthWidth}px` },
  174.         colSize,
  175.         totalWidth,
  176.       });
  177.     }
  178.   };
  180.   handleVerticalScroll = (e) => {
  181.     const scrollTop = e.target.scrollTop;
  182.     // 内容区域纵向滚动逻辑，仅在“内容区域”滚动时执行
  183.     if (this.mousePosition === POSITION_TABLE_BODY) {
  184.       // 同步假滚动条 scrollTop 值
  185.       this.scrollDom && (this.scrollDom.scrollTop = scrollTop);
  186.       this.verticalTop = scrollTop;
  187.       this.setVerticalData(scrollTop);
  188.     }
  189.   };
  191.   handleScroll = (e) => {
  192.     const scrollTop = e.target.scrollTop;
  193.     // 假滚动条纵向滚动逻辑，仅在“假滚动条”滚动时执行
  194.     if (this.mousePosition === POSITION_VERTICAL_BAR) {
  195.       // 同步内容区域 scrollTop 值
  196.       this.verticalDom && (this.verticalDom.scrollTop = scrollTop);
  197.       this.verticalTop = scrollTop;
  198.       this.setVerticalData();
  199.     }
  200.   };
  202.   handleHorizontalScroll = (e) => {
  203.     e.stopPropagation();
  204.     const scrollLeft = e.target.scrollLeft;
  205.     this.scrollDom && (this.scrollDom.scrollLeft = scrollLeft);
  206.     this.setHorizontalData();
  207.   };
  209.   handleBodyMouseEnter = () => {
  210.     this.mousePosition = POSITION_TABLE_BODY;
  211.   };
  213.   handleVerScrollMouseEnter = () => {
  214.     this.mousePosition = POSITION_VERTICAL_BAR;
  215.   };
  217.   tableHeaderRender = () => {
  218.     const { columns } = this.props;
  219.     const cols = [];
  220.     const ths = [];
  221.     columns.forEach((col, i) => {
  222.       const { code, name, width = 160 } = col;
  223.       const key = `${key}-${i}`;
  224.       cols.push(<col key={key} width={`${width}px`} />);
  225.       ths.push(<th key={key} className="table-header-cell">{name}</th>);
  226.     });
  228.     return (
  229.       <div className="table-header" ref={this.getTableHeaderDom}>
  230.         <table>
  231.           <colgroup>{cols}</colgroup>
  232.           <thead>
  233.             <tr className='table-header-row'>{ths}</tr>
  234.           </thead>
  235.         </table>
  236.       </div>
  237.     );
  238.   };
  240.   tableBodyRender = () => {
  241.     const { hiddenTopStyle, hiddenBottomStyle, hiddenLeftStyle, hiddenRightStyle, rowSize, colSize, totalHeight } = this.state;
  242.     const { columns, dataSource = [] } = this.props;
  243.     const showData = dataSource.slice(...rowSize);
  244.     const showCols = columns.slice(...colSize);
  245.     const cols = [];
  246.     if (colSize[0]) {
  247.       cols.push(<col key="first" width={hiddenLeftStyle.width} />);
  248.     }
  249.     showCols.forEach((col, i) => {
  250.       const { code, width = 160 } = col;
  251.       cols.push(<col key={`${code}-${colSize[0] + i}`} width={`${width}px`} />);
  252.     });
  253.     if (colSize[1]) {
  254.       cols.push(<col key="last" width={hiddenRightStyle.width} />);
  255.     }
  257.     return (
  258.       <div className="table-body" ref={this.getVerticalDom} onScroll={this.handleVerticalScroll} onMouseEnter={this.handleBodyMouseEnter}>
  259.         <div className="table-body-total" style={{ height: `${totalHeight}px`, paddingTop: `${hiddenTopStyle?.height}` }}>
  260.           <table>
  261.             <colgroup>{cols}</colgroup>
  262.             <tbody>
  263.               {showData.map((row, i) => {
  264.                 const index = rowSize[0] + i;
  265.                 return (
  266.                   <tr className="table-row" key={index} data-rowindex={index} ref={this.getTrRef.bind(null, index)}>
  267.                     {colSize[0] ? <td /> : null}
  268.                     {showCols.map(({ code }, j) => {
  269.                       const colIndex = colSize[0] + j;
  270.                       return <td className="table-cell" key={`${code}-${colIndex}`} data-colindex={colIndex}>{row[code]}</td>;
  271.                     })}
  272.                     {colSize[1] ? <td /> : null}
  273.                   </tr>
  274.                 );
  275.               })}
  276.             </tbody>
  277.           </table>
  278.         </div>
  279.       </div>
  280.     );
  281.   };
  283.   render() {
  284.     const { totalHeight } = this.state;
  285.     return <div className="use-virtual-table" ref={this.getVirtualTableRef} onScroll={this.handleHorizontalScroll}>
  286.       <div className="use-virtual-table-body" ref={this.getHorizontalDom}>
  287.         {this.tableHeaderRender()}
  288.         {this.tableBodyRender()}
  289.       </div>
  290.       <div
  291.         className="bar-virtual-vertical-scroll"
  292.         style={{ height: `${this.virtualTableHeight - (this.tableHeader?.clientHeight || 34)}px`, width: `${this.scrollBarWidth}px` }}
  293.         onScroll={this.handleScroll}
  294.         ref={this.getScrollDom}
  295.         onMouseEnter={this.handleVerScrollMouseEnter}
  296.       >
  297.         <div className='bar-body' style={{ height: `${totalHeight}px` }} />
  298.       </div>
  299.     </div>
  300.   }
  301. }
  303. export default UseVirtualTable;

补充“假滚动条”的样式（只要整合前面基本表格的样式就完整了）：

  1. .use-virtual-table {
  2.   // ...... 省略已有样式代码
  4.   // 表格内容容器
  5.   .table-body-total {
  6.     width: 100%;
  7.     overflow: hidden;
  8.   }
  10.   .bar-virtual-vertical-scroll {
  11.     position: absolute;
  12.     top: 0;
  13.     right: 0;
  14.     height: 100%;
  15.     margin-top: var(--table-header-height);
  16.     overflow: auto;
  18.     .bar-body {
  19.       width: 1px;
  20.     }
  21.   }
  22. }

调用组件

前面组件的逻辑已经比较完整了，这里在完整的补充一下调用逻辑，这份代码就完整了：

  1. import ReactDOM from 'react-dom';
  2. import UseVirtualTable from './UseVirtualTable';
  4. const createDataSource = (rows, cols) => {
  5.   const result = [];
  6.   for (let i = 0; i < rows; i++) {
  7.     const item = {};
  8.     for (let j = 0; j < cols; j++) {
  9.       item[`col_${j}`] = `ROW--${i}, COLUMN--${j}`;
  10.     }
  11.     result.push(item);
  12.   }
  13.   return result;
  14. };
  15. const dataSource = createDataSource(30, 15);
  17. const createColumns = (data) => {
  18.   const item = data[0];
  19.   const columns = [];
  20.   Object.keys(item).forEach((key) => {
  21.     columns.push({
  22.       code: key,
  23.       name: key,
  24.       width: 180,
  25.     });
  26.   });
  27.   return columns;
  28. };
  29. const columns = createColumns(dataSource);
  31. ReactDOM.render(
  32.   [
  33.     <UseVirtualTable dataSource={dataSource} columns={columns} useVirtual />
  34.   ],
  35.   document.getElementById('root')
  36. );

整个组件只要捋清楚虚拟滚动、假滚动条的 HTML 结构及 CSS，然后配上滚动逻辑之后还是比较简单的。