---
localeCode: en-US
order: 60
category: Show
title: Table
subTitle: Table
icon: doc-table
dir: column
brief: Tables are used to present structured data content, usually accompanied by the ability to manipulate the data (sort, search, paginate...).
---
## How to Use
Into the header. `columns` And data. `DataSource` To render.
> Please provide a "key" for each data item in the dataSource that is different from the value of the other data items, or use the row Key parameter to specify an attribute name as the primary key, alternative row operation functions such as row selection and expansion of the table.
```jsx noInline=true import
import React from 'react';
import { Table } from '@douyinfe/semi-ui';
function App() {
const columns = [
{
title: 'Title',
dataIndex: 'name',
},
{
title: 'Size',
dataIndex: 'size',
},
{
title: 'Owner',
dataIndex: 'owner',
},
{
title: 'Update',
dataIndex: 'updateTime',
}
];
const data = [
{
key: '1',
name: 'Semi Design design draft.fig',
nameIconSrc: 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/figma-icon.png',
size: '2M',
owner: 'Jiang Pengzhi',
updateTime: '2020-02-02 05:13',
avatarBg: 'grey'
},
{
key: '2',
name: 'Semi Design share docs',
nameIconSrc: 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/docs-icon.png',
size: '2M',
owner: 'Hao Xuan',
updateTime: '2020-01-17 05:31',
avatarBg: 'red'
},
{
key: '3',
name: 'Design docs',
nameIconSrc: 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/docs-icon.png',
size: '34KB',
owner: 'Zoey Edwards',
updateTime: '2020-01-26 11:01',
avatarBg: 'light-blue'
},
];
return
;
}
```
## Demos
### Basic Table
For tables, the two most basic parameters are `dataSource` and `columns`, the former is the data item, the latter is the configuration of each column, both are array types.
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table, Avatar } from '@douyinfe/semi-ui';
import { IconMore } from '@douyinfe/semi-icons';
function App() {
const columns = [
{
title: 'Title',
dataIndex: 'name',
render: (text, record, index) => {
return (
;
}
render(App);
```
### JSX Writing
You can also use JSX syntax definitions `columns`, note that Table only supports `columns` JSX syntax definition. You cannot use any component package `Table.Column`.
> Note: JSX-written tables are not supported the parameter `Resizable`.
When columns are written in JSX, please do not use it at the same time as the configuration method; if used at the same time, only the configuration method will take effect, and no aggregation operation will be performed.
{typeof text === 'string' && text.slice(0, 1)}
{text}
);
};
return (
} />
);
}
render(App);
```
### Row Selection Operation
This feature can be turned on by passing in `rowSelection`.
- Click the selection box in the header, and all rows in the `dataSource` that are not in the state of `disabled` will be selected. The callback function for selecting all rows is `onSelectAll`;
- Clicking on the row selection box will select the current row. Its callback function is `onSelect`;
> Note: Be sure to provide a "key" for each row of data that is different from other row values, or use the rowKey parameter to specify a property name as the primary key.
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table, Avatar } from '@douyinfe/semi-ui';
import { IconMore } from '@douyinfe/semi-icons';
function App() {
const columns = [
{
title: 'Title',
dataIndex: 'name',
width: 400,
render: (text, record, index) => {
return (
);
}
render(App);
```
### Table With Pagination
Table paging currently supports two modes: controlled and uncontrolled.
- In controlled mode, the paging state is passed entirely externally, depending on whether the pagination .currentPage field is passed. In general, the controlled mode is suitable for remotely pulling data and rendering.
- In uncontrolled mode, Table passes the incoming dataSource length as total to the Pagination component by default, and of course you can also pass a total field to overwrite the value of the Table component, but we do not recommend users to pass this field in uncontrolled paging mode.
> Note: The custom `pagination.total` field passed in uncontrolled conditions is supported only after version 0.25.0.
```jsx live=true noInline=true dir="column"
import React, { useState, useMemo } from 'react';
import { Table, Avatar } from '@douyinfe/semi-ui';
import * as dateFns from 'date-fns';
const figmaIconUrl = 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/figma-icon.png';
const columns = [
{
title: 'Title',
dataIndex: 'name',
width: 400,
render: (text, record, index) => {
return (
;
}
render(App);
```
### Pull Remote Data
Under normal circumstances, the data is often not obtained at one time. We will retrieve the data from the interface when clicking on the page number, filter or sort button. In this case, please use **Controlled mode** To handle pagination. The user needs to pass in the `pagination.currentPage` field, where the rendering of the pagination component depends entirely on the incoming pagination object.
1. When pagination is an object type, literal is not recommended because it causes the table to render to its original state (it looks like the pager is not working). Please try to define reference type parameters outside the render method. If hooks are used, please use useMemo or useState for storage.
2. In the controlled mode, Table will not paginate dataSource, please pass in current page data to dataSource
);
}
render(App);
```
### Fixed Column or Head
You can fix the column by setting the Fixed attribute of the column and scroll.x, and fix the header by setting scroll.y.
> - Make sure that all elements inside the table do not affect the height of the cells after rendering (e.g. containing unloaded pictures, etc.). In this case, give the stator element a definite height to ensure that the left and right Fixed columns of cells are not deranged.
> - If the column header is not aligned with the content or there is a column duplication, specify the width width of the fixed column. If the specified width is not effective, try to recommend leaving a column with no width to accommodate the elastic layout, or check for ultra-long continuous fields to destroy the layout.
> - It is recommended to specify scroll.x as a **fixed value** or percentage greater than the width of the table. It is recommended to set a fixed value of `>= the sum of all fixed column widths + the sum of all table column widths`.
```jsx live=true noInline=true dir="column"
import React, { useState, useMemo } from 'react';
import { Table, Avatar } from '@douyinfe/semi-ui';
import { IconMore } from '@douyinfe/semi-icons';
import * as dateFns from 'date-fns';
const DAY = 24 * 60 * 60 * 1000;
const figmaIconUrl = 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/figma-icon.png';
const columns = [
{
title: 'Title',
dataIndex: 'name',
fixed: true,
width: 250,
render: (text, record, index) => {
return (
;
}
render(App);
```
### Table Header With Sorting and Filtering Function
Filters and sorting controls are integrated inside the table, and users can pass in the sorter display of the sorter open header by passing filters in Column and the filter control display of the onFilter open header.
> Note: Be sure to provide a "key" for each row of data that is different from other row values, or use the rowKey parameter to specify a property name as the primary key.
```jsx live=true noInline=true dir="column"
import React, { useState, useMemo } from 'react';
import { Table, Avatar } from '@douyinfe/semi-ui';
import * as dateFns from 'date-fns';
const DAY = 24 * 60 * 60 * 1000;
const figmaIconUrl = 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/figma-icon.png';
const columns = [
{
title: 'Title',
dataIndex: 'name',
width: 400,
render: (text, record, index) => {
return (
;
}
render(App);
```
### Custom Filter Item Rendering
Since the **1.1.0** version, it is supported to pass in `renderFilterDropdownItem` to customize the rendering method of each filter item.
This method accepts an `Object` input parameter, and the meaning of each attribute is as follows:
- `onChange: e => void` current filter item selection/reverse selection event;
- `text: ReactNode` copy of the current screening item;
- `value: any` the value of the current filter item;
- `checked: boolean` whether the current filter item has been selected;
- `filteredValue: any[]` all currently filtered values;
- `level: number` is the level of the current filter item, if it is a nested filter item, the value will be >= 1;
- `filterMultiple: boolean` whether the current filter item is multi-select.
```jsx live=true noInline=true dir="column"
import React, { useState, useMemo } from 'react';
import { Table, Avatar, Dropdown } from '@douyinfe/semi-ui';
import * as dateFns from 'date-fns';
const DAY = 24 * 60 * 60 * 1000;
const figmaIconUrl = 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/figma-icon.png';
const columns = [
{
title: 'Title',
dataIndex: 'name',
width: 400,
render: (text, record, index) => {
return (
;
}
render(App);
```
### A Table That Can Be Expanded
1. Since version `0.27.0`, the unfold button will be rendered in the same cell as the first column, and you can open a separate column of rendering by passing in `hideExpandedColumn = {false}`.
2. Be sure to provide a "key" for each row of data that is different from the other row values, or use the rowKey parameter to specify an attribute name as the primary key.
#### A Common Table That Can Be Expanded
If you need to render a table that can be expanded, in addition to the need to pass `expandedRowRender` In addition to this method, you must specify `rowKey`(by default `key`), Table will be based on `rowKey` Gets a row unique identifier.
- If `rowKey` is a Function, the result of `rowKey(record)` is taken as the row unique ID
- If `rowKey` is a string type, you take `record[rowKey]` as the row unique ID
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table, Avatar, Descriptions, Tag } from '@douyinfe/semi-ui';
import { IconMore } from '@douyinfe/semi-icons';
const columns = [
{
title: 'Title',
width: 500,
dataIndex: 'name',
render: (text, record, index) => {
return (
{text}
);
}
},
{
title: 'Size',
dataIndex: 'size',
},
{
title: 'Owner',
dataIndex: 'owner',
render: (text, record, index) => {
return (
{typeof text === 'string' && text.slice(0, 1)}
{text}
;
}
render(App);
```
#### The Unfold Button Is Rendered In a Separated Column
**Version: >= 0.27.0**
By default, the expansion button will be rendered in the same cell as the first copy, and you can enter `hideExpandedColumn={false}` to render as a separate column:
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table, Avatar, Descriptions, Tag } from '@douyinfe/semi-ui';
import { IconMore } from '@douyinfe/semi-icons';
const columns = [
{
title: 'Title',
width: 500,
dataIndex: 'name',
render: (text, record, index) => {
return (
{text}
);
}
},
{
title: 'Size',
dataIndex: 'size',
},
{
title: 'Owner',
dataIndex: 'owner',
render: (text, record, index) => {
return (
{typeof text === 'string' && text.slice(0, 1)}
{text}
);
}
render(App);
```
#### Turn Off Rendering of Expandable Button of a Row
**Version: > = 0.27.0**
You can pass the row Expandable method, enter the reference as record, and determine whether the return value is false to close the rendering of the expandable button on a row.
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table, Avatar, Descriptions, Tag } from '@douyinfe/semi-ui';
import { IconMore } from '@douyinfe/semi-icons';
const columns = [
{
title: 'Title',
width: 500,
dataIndex: 'name',
render: (text, record, index) => {
return (
{text}
);
}
},
{
title: 'Size',
dataIndex: 'size',
},
{
title: 'Owner',
dataIndex: 'owner',
render: (text, record, index) => {
return (
{typeof text === 'string' && text.slice(0, 1)}
{text}
record.name !== 'Design docs' }
hideExpandedColumn={false}
rowSelection={rowSelection}
pagination={false}
/>
);
}
render(App);
```
### Tree Data Display
**Version: > = 0.27.0**
The table supports the display of tree data and is automatically displayed as a tree table when there are children fields in the data. If you do not need or use other fields, you can configure it with the childrenRecordName. In addition, you can control the indent width of each layer by setting indent Size.
> Note: Be sure to provide a "key" for each row of data that is different from the other row values, or use the `rowKey` parameter to specify a property name as the primary key.
#### Simple example of tree data
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table } from '@douyinfe/semi-ui';
function App() {
const columns = [
{
title: 'Key',
dataIndex: 'dataKey',
key: 'dataKey',
},
{
title: 'Name',
dataIndex: 'name',
key: 'name',
width: 200,
},
{
title: 'Data Type',
dataIndex: 'type',
key: 'type',
width: 400,
},
{
title: 'Description',
dataIndex: 'description',
key: 'description',
},
{
title: 'Default',
dataIndex: 'default',
key: 'default',
width: 100,
},
];
const data = [
{
key: 1,
dataKey: 'videos_info',
name: 'Video Info',
type: 'Object',
description: 'Meta info of video',
default: 'None',
children: [
{
key: 11,
dataKey: 'status',
name: 'Video Status',
type: 'Enum ',
description: 'Viewable and recommended status of the video',
default: '1',
},
{
key: 12,
dataKey: 'vid',
name: 'Video ID',
type: 'String',
description: 'Unique ID that identifies the video',
default: 'None',
children: [
{
dataKey: 'video_url',
name: 'Video url',
type: 'String',
description: 'Unique link to the video',
default: 'None',
},
],
}
],
},
{
key: 2,
dataKey: 'text_info',
name: 'Text Info',
type: 'Object',
description: 'Meta info of video',
default: 'None',
children: [
{
key: 21,
dataKey: 'title',
name: 'Video Title',
type: 'String',
description: 'Title of video',
default: 'None',
},
{
key: 22,
dataKey: 'video_description',
name: 'Video Description',
type: 'String',
description: 'Description of video',
default: 'None',
}
],
},
];
return (
);
};
render(App);
```
#### Rows of Interchangeable Tree Data
**Version: > = 0.27.0**
You can do row switching by changing the order of the dataSource elements.
```jsx live=true noInline=true dir="column"
import React, { useState } from 'react';
import { Table, Button } from '@douyinfe/semi-ui';
import { IconArrowUp, IconArrowDown } from '@douyinfe/semi-icons';
const raw = [
{
key: 1,
dataKey: 'videos_info',
name: 'Video Info',
type: 'Object',
description: 'Meta info of video',
default: 'None',
children: [
{
key: 11,
dataKey: 'status',
name: 'Video Status',
type: 'Enum ',
description: 'Viewable and recommended status of the video',
default: '1',
},
{
key: 12,
dataKey: 'vid',
name: 'Video ID',
type: 'String',
description: 'Unique ID that identifies the video',
default: 'None',
children: [
{
dataKey: 'video_url',
name: 'Video url',
type: 'String',
description: 'Unique link to the video',
default: 'None',
},
],
}
],
},
{
key: 2,
dataKey: 'text_info',
name: 'Text Info',
type: 'Object',
description: 'Meta info of video',
default: 'None',
children: [
{
key: 21,
dataKey: 'title',
name: 'Video Title',
type: 'String',
description: 'Title of video',
default: 'None',
},
{
key: 22,
dataKey: 'video_description',
name: 'Video Description',
type: 'String',
description: 'Description of video',
default: 'None',
}
],
},
];
const rowKey= 'key';
const childrenRecordName= 'children';
function App() {
const [expandedRowKeys, setExpandedRowKeys] = useState([1, 2]);
const [data, setData] = useState(raw);
const switchRecord = (key1, key2) => {
const newData = [...data];
if (key1 != null && key2 != null) {
const item1 = findRecordByKey(key1, newData);
const item2 = findRecordByKey(key2, newData);
// you have to copy item1 and item2 first
const copiedItem1 = { ...item1 };
const copiedItem2 = { ...item2 };
coverRecord(item1, copiedItem2);
coverRecord(item2, copiedItem1);
setData(newData);
}
};
const findRecordByKey = (key, data) => {
if (Array.isArray(data) && data.length && key != null) {
for (let item of data) {
if (item[rowKey] === key) {
return item;
}
const children = item[childrenRecordName];
if (Array.isArray(children) && children.length) {
const item = findRecordByKey(key, children);
if (item != null) {
return item;
}
}
}
}
};
const coverRecord = (obj, srcObj) => {
if (obj && typeof obj === 'object' && srcObj && typeof srcObj === 'object') {
const srcKeys = Object.keys(srcObj);
const copied = { ...srcObj };
Object.assign(obj, copied);
Object.keys(obj).forEach(key => {
if (!srcKeys.includes(key)) {
delete obj[key];
}
});
}
return obj;
};
const getSameLevelRecords = (key, data = []) => {
if (key != null && Array.isArray(data) && data.length) {
if (data.find(item => item[rowKey] === key)) {
return data;
}
for (let item of data) {
const records = getSameLevelRecords(key, item[childrenRecordName]);
if (records.length) {
return records;
}
}
}
return [];
};
const columns = [
{
title: 'Key',
dataIndex: 'dataKey',
key: 'dataKey',
},
{
title: 'Name',
dataIndex: 'name',
key: 'name',
width: 200,
},
{
title: 'Data Type',
dataIndex: 'type',
key: 'type',
},
{
title: 'Description',
dataIndex: 'description',
key: 'description',
},
{
title: 'Default',
dataIndex: 'default',
key: 'default',
width: 100,
},
{
key: 'operation',
render: record => {
const records = getSameLevelRecords(record[rowKey], data);
const index = records.findIndex(item => item[rowKey] === record[rowKey]);
const upProps = {};
const downProps = {};
if (index > 0) {
const upRow = records[index - 1];
upProps.onClick = () => switchRecord(record[rowKey], upRow[rowKey]);
} else {
upProps.disabled = true;
}
if (index < records.length - 1) {
const downRow = records[index + 1];
downProps.onClick = () => switchRecord(record[rowKey], downRow[rowKey]);
} else {
downProps.disabled = true;
}
return (
<>
} {...upProps} />
} {...downProps} />
);
},
},
];
return (
);
};
render(ChildrenDataSelectedDemo);
```
### Custom Row or Cell Events and Properties
- The incoming `onRow` / `onHeaderRow` can define the native event or property of a table or table header line.
- The incoming `Column.onCell` / `Column.onHeaderCell` can define a table or header cell native event or property.
In principle, the properties or events supported on tr / td / th can be defined. For example:
- The tr at the head of the watch defines onMouseEnter / onMouseLeave
- The tr of the table defines className
- The third line of the table defines onClick.
```jsx live=true noInline=true dir="column"
import React, { useMemo } from 'react';
import { Table, Avatar } from '@douyinfe/semi-ui/';
import * as dateFns from 'date-fns';
const DAY = 24 * 60 * 60 * 1000;
const figmaIconUrl = 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/figma-icon.png';
function EventTable(props = {}) {
const columns = useMemo(
() => [
{
title: 'Title',
dataIndex: 'name',
width: 400,
render: (text, record, index) => {
return (
;
}
render(App);
```
### Resizable Column
Version > = 0.15.0
#### Basic Resizable Column
For some columns with more content, you can choose to turn on the telescopic column function and pull and pull at the head to realize the real-time change of column width.
But you need to pay attention to some parameters:
- `resizable` is set to `true` or an `object`
- Any column in `columns` that requires a telescopic function should specify the `width`field (if not passed, the column does not have a telescopic function and its column width will be automatically adjusted by the browser)
> It is not recommended to use with fixed columns at the same time. Fixed columns need to specify `scroll.x`, which stipulates that the table has a width range, and the flexible column will expand the column width, which may cause the table to be misaligned
```jsx live=true noInline=true dir="column"
import React, { useMemo } from 'react';
import { Table, Avatar } from '@douyinfe/semi-ui';
import * as dateFns from 'date-fns';
const DAY = 24 * 60 * 60 * 1000;
const figmaIconUrl = 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/figma-icon.png';
function ResizableDemo() {
const columns = [
{
title: 'Title',
dataIndex: 'name',
width: 400,
render: (text, record, index) => {
return (
;
}
render(ResizableDemo);
```
#### Advanced Telescopic Columns
`resizable` can also be an `object`, including three event methods:
- onResize
- onResizeStart
- onResizeStop
These three callback will be triggered on `changing column width`, `start changing column width` and `stop changing column width` respectively. Developers can choose to modify the column at this time, such as adding a vertical line effect when dragging, as shown below.
```jsx live=true noInline=true dir="column"
import React, { useMemo } from 'react';
import { Table, Avatar } from '@douyinfe/semi-ui';
import * as dateFns from 'date-fns';
const DAY = 24 * 60 * 60 * 1000;
const figmaIconUrl = 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/figma-icon.png';
const pagination = { pageSize: 5 };
function ResizableDemo() {
const columns = [
{
title: 'Title',
dataIndex: 'name',
width: 400,
render: (text, record, index) => {
return (
({
index,
moveRow,
})}
/>
);
}
render(DragSortingTableDemo);
```
The CSS styles used in this example are:
```css
#components-table-demo-drag-sorting tr.drop-over-downward td {
border-bottom: 2px dashed #1890ff;
}
#components-table-demo-drag-sorting tr.drop-over-upward td {
border-top: 2px dashed #1890ff;
}
```
### Table Grouping
For some tables whose data needs to be displayed in groups, you can pass in `groupBy` to define the grouping rules, and use `renderGroupSection` to define the rendering of the grouping table header.
> Note: Be sure to provide a "key" for each row of data that is different from other row values, or use the rowKey parameter to specify a property name as the primary key.
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table, Avatar } from '@douyinfe/semi-ui';
import * as dateFns from 'date-fns';
const DAY = 24 * 60 * 60 * 1000;
const figmaIconUrl = 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/figma-icon.png';
const columns = [
{
title: 'Title',
dataIndex: 'name',
width: 400,
render: (text, record, index) => {
return (
Group by file size {groupKey} KB}
onGroupedRow={(group, index) => {
return {
// onMouseEnter: () => {
// console.log(`Grouped row mouse enter: `, group, index);
// },
// onMouseLeave: () => {
// console.log(`Grouped row mouse leave: `, group, index);
// },
onClick: e => { console.log(`Grouped row clicked: `, group, index); }
};
}}
clickGroupedRowToExpand // if you want to click the entire row to expand
scroll={{ y: 480 }}
/>
);
}
render(Demo);
```
### Virtualized Table
Virtualization can be used for scenes that need to render large-scale data. You can enable this feature by configuring the `virtualized` parameter. have to be aware of is:
- Must pass `scroll.y` (number) and`style.width` (number);
- Need to pass the height of each line `virtualized.itemSize` (when not transmitting, the normal line height defaults to `56`, and the group head line height defaults to `56`), can be of the following types:
- `number`
- `(index, { sectionRow?: boolean, expandedRow?: boolean }) => number`
- Table grouping virtualization requires version >= `0.37.0`.
The following is an example of rendering 1000 pieces of data.
```jsx live=true noInline=true dir="column"
import React, { useRef } from 'react';
import { Table, Avatar, Button } from '@douyinfe/semi-ui';
import * as dateFns from 'date-fns';
const DAY = 24 * 60 * 60 * 1000;
const columns = [
{
title: 'Title',
dataIndex: 'name',
width: 200,
fixed: true,
render: (text, record, index) => {
return (
);
}
}
render(App);
```
### Fully custom rendering
**Version:** >=0.34.0
Generally, you can use `Column.render`, but you can also pass`Column.useFullRender = true` to enable full custom rendering mode. At this time, the components such as checkbox button, expand button, indent will be Pass through to the `Column.title` and`Column.render` methods, you can further define the rendering method of the header and cell content.
The input parameters accepted by `Column.title` are:
```tsx
{
filter: ReactNode, // Filter button
sorter: ReactNode, // Sort button
selection: ReactNode, // Select button
}
```
`Column.render` The fourth input parameter is:
```tsx
{
expandIcon: ReactNode, // Expand button
selection: ReactNode, // Select button
indentTex: ReactNode, // Indentation
}
```
> The example below renders the checkbox and content into the same cell and header.
```jsx live=true noInline=true dir="column"
import React, { useState, useEffect, useMemo } from 'react';
import { Table, Avatar } from '@douyinfe/semi-ui';
import * as dateFns from 'date-fns';
const DAY = 24 * 60 * 60 * 1000;
const figmaIconUrl = 'https://lf3-static.bytednsdoc.com/obj/eden-cn/ptlz_zlp/ljhwZthlaukjlkulzlp/figma-icon.png';
const columns = [
{
title: ({ sorter, filter, selection }) => (
{selection}
Name
{sorter}
{filter}
),
dataIndex: 'name',
width: 400,
render: (text, record, index) => {
return (
;
}
render(App);
```
## API Reference
## Table
| Properties | Instructions | Type | Default | Version |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ---------- | ----------------------------------------------------------------- |
| bordered | Whether to display outer and column borders | boolean | false |
| className | Outermost style name | string | |
| clickGroupedRowToExpand | Group content expands or collapses when the group header row is clicked | boolean | | **0.29.0** |
| columns | For a configuration description of the table column, see [Column](#Column) | Column [] | [] |
| dataSource | Data | RecordType[] | [] |
| defaultExpandAllRows | All rows are expanded by default | boolean | false |
| defaultExpandAllGroupRows | All grouped rows are expanded by default | boolean | false | **1.30.0**
| defaultExpandedRowKeys | Default expansion of row key array | Array <\*> | [] |
| empty | Content displayed when there is no data | ReactNode | ReactNode | 'No data yet. ' |
| expandCellFixed | Whether the column of the expansion icon is fixed or not, the same value as the fixed value in Column | boolean\|string | false |
| expandIcon | Custom expansion icon, hidden when it is `false` | boolean \|ReactNode \| (expanded: boolean) => ReactNode | |
| expandedRowKeys | Expanded rows, the row expansion function will be controlled when this parameter is introduced. | (string \| number)[] | |
| expandedRowRender | Extra unfolding lines | (record: object, index: number, expanded: boolean) => ReactNode | |
| expandAllRows | All rows are expanded | boolean | false | **1.30.0**
| expandAllGroupRows | All grouped rows are expanded | boolean | false | **1.30.0**
| expandRowByClick | Expand row when click row | boolean | false | **1.31.0**
| footer | End of form | string \|ReactNode \|(pageData: object) => string\|ReactNode | |
| groupBy | Grouping basis, generally a method of a key name or a return value of a string or number in the dataSource element | string\|number \|(record: any) => string\|number | | **0.29.0** |
| hideExpandedColumn | Whether to hide the expansion button column and turn off the rendering of the expansion button when it is turned on | boolean | true |
| indentSize | indent size of TableCell | number | 20 |
| loading | Table is loading or not | boolean | false |
| pagination | Paging component configuration | boolean\|TablePaginationProps | true |
| prefixCls | Style name prefix | string | |
| renderGroupSection | Header rendering method | (groupKey?: string \| number, group?: string[] \| number[]) => ReactNode | | **0.29.0** |
| renderPagination | Customize the rendering method of pagination. | (paginationProps?: TablePaginationProps) => ReactNode | | **1.13.0** |
| resizable | Whether to turn on the telescopic column function, the column that needs to be telescopic must provide the value of width | boolean\|[Resizable](#Resizable) | false |
| rowExpandable | Whether the row can be expanded, turning off the rendering of the expandable button when the value is false | (record: RecordType): => boolean | () => true | **0.27.0** |
| rowKey | The value of the table row key, which can be a string or a function. | string \| (record: RecordType) => string | 'key' |
| rowSelection | See [rowSelection](#rowSelection) | object | null |
| scroll | Whether the table is scrollable, configure the width or height of the scroll area, see [scroll](#scroll) | object | - |
| showHeader | Does it show the header? | boolean | true |
| size | Table size, will effect the `padding` of the rows | "default"\|"middle"\|"small" | "default" | **1.0.0** |
| title | Table Title | string \|ReactNode \|(pageData: RecordType[]) => string\|ReactNode | |
| virtualized | Virtualization settings | Virtualized | false | **0.33.0** |
| virtualized.itemSize | Row height | number\|(index: number) => number | 56 | **0.33.0** |
| virtualized.onScroll | Virtualization scroll callback method | ( scrollDirection?: 'forward' \| 'backward', scrollOffset?: number, scrollUpdateWasRequested?: boolean ) => void | | **0.33.0** |
| onChange | Trigger when paging, sorting, filtering changes | ({ pagination: TablePaginationProps, filters: Array<\*>, sorter: object, extra: any }) => void | |
| onExpand | Trigger when clicking on the row expansion icon | (expanded: boolean, record: RecordType, DOMEvent: MouseEvent) => void | | The third parameter DOMEvent requires version **>=0.28.0** |
| onExpandedRowsChange | Triggers when unfolding row changes | (rows: RecordType[]) => void | |
| onGroupedRow | Similar to onRow, but this parameter is used to define the row attribute of the grouping header alone | (record: RecordType, index: number) => object | | **0.29.0** |
| onHeaderRow | Set the header row property, and the returned object is merged to the header line | (columns: Column[], index: number) => object | |
| onRow | Set the row property, and the returned object is merged to the table row | (record: RecordType, index: number) => object | |
Some of the type definitions used above:
```typescript
// PaginationProps is the props supported by the Pagination component
interface TablePaginationProps extends PaginationProps {
position?: PaginationPosition;
formatPageText?: FormatPageText;
}
type VirtualizedMode = 'list' | 'grid';
type VirtualizedItemSizeFn = (index?: number) => number;
type VirtualizedOnScrollArgs = {
scrollDirection?: 'forward' | 'backward';
scrollOffset?: number;
scrollUpdateWasRequested?: boolean;
};
type VirtualizedOnScroll = (object: VirtualizedOnScrollArgs) => void;
type Virtualized = boolean | {
mode?: VirtualizedMode;
itemSize?: number | VirtualizedItemSizeFn;
onScroll?: VirtualizedOnScroll;
};
```
RecordType is a generic parameter of Table and Column, and the default is object type. You can use RecordType like this:
```typescript
import { ColumnProps } from 'table/interface';
interface Record {
title?: string;
dataIndex?: string;
width?: number;
render?: Function;
key?: string;
name?: string;
age?: number;
address?: string;
}
const columns: ColumnProps[] = [
{
title: 'Name',
dataIndex: 'name',
width: 200,
},
// ...
];
const data: Record[] = [
{
key: '1',
name: 'John Brown',
age: 32,
address: 'New York No. 1 Lake Park, New York No. 1 Lake Park',
},
// ...
];
function App() {
return (
columns={columns} dataSource={data} />
);
}
```
## onRow/onHeaderRow Usage
> Also in `column.onCell` `column.onHeaderCell` Properties or events supported by td / th can also be returned.
```jsx noInline=true
import React from 'react';
import { Table } from '@douyinfe/semi-ui';
() => (
{
return {
onClick: event => {},
onMouseEnter: event => {},
onMouseLeave: event => {},
className: '',
// ...
// Other attributes or events that can be applied to tr
};
}}
onHeaderRow={(columns, index) => {
return {
onClick: event => {},
onMouseEnter: event => {},
onMouseLeave: event => {},
className: '',
// ...
// Other attributes or events that can be applied to th
};
}}
/>
);
```
## Column
| Parameters | Instructions | Type | Default | Version |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | ------- | ----------------------------------------- |
| align | Setting the alignment of columns | 'left '\| 'right '\| 'center' | 'left' |
| children | Settings for sub-columns when the header is merged | Column[] | |
| className | Column style name | string | |
| colSpan | When header columns merge, set to 0, do not render | number | |
| dataIndex | The key corresponding to the column data in the data item. It is required when using sorter or filter. | string | |
| defaultFilteredValue | Default value of the filter, the filter state of the external control column with a value of the screened value array | any[] | | **2.5.0** |
| defaultSortOrder | The default value of sortOrder, one of 'ascend'\|'descend'\|false | boolean\| string | false | **1.31.0**
| filterChildrenRecord | Whether the child data needs to be filtered locally. If this function is enabled, if the child meets the filtering criteria, the parent will retain it even if it does not meet the criteria. | boolean | | **0.29.0** |
| filterDropdown | You can customize the filter menu. This function is only responsible for rendering the layer and needs to write a variety of interactions. | ReactNode | |
| filterDropdownProps | Props passing to Dropdown, see more in [Dropdown API](/en-US/show/dropdown#Dropdown) | object | |
| filterDropdownVisible | Visible of Dropdown, see more in [Dropdown API](/en-US/show/dropdown#Dropdown) | boolean | |
| filterIcon | Custom filter icon | boolean\|ReactNode\|(filtered: boolean) => ReactNode | |
| filterMultiple | Whether to choose more | boolean | true |
| filteredValue | Controlled property of the filter, the filter state of the external control column with a value of the screened value array | any[] | |
| filters | Filter menu items for the header | Filter[] | |
| fixed | Whether the column is fixed, optional true (equivalent to left) 'left' 'right' | boolean\|string | false |
| key | The key required by React, if a unique dataIndex has been set, can ignore this property | string | |
| render | A rendering function that generates complex data, the parameters are the value of the current row, the current row data, the row index, and the table row / column merge can be set in return object | (text: any, record: RecordType, index: number, { expandIcon?: ReactNode }) => React\|object | |
| renderFilterDropdownItem | Customize the rendering method of each filter item. For usage details, see [Custom Filter Item Rendering](#Custom-Filter-Item-Rendering) | ({ value: any, text: any, onChange: Function, level: number, ...otherProps }) => ReactNode | - | **1.1.0** |
| sortChildrenRecord | Whether to sort child data locally | boolean | | **0.29.0** |
| sortOrder | The controlled property of the sorting, the sorting of this control column can be set to 'ascend'\|'descended '\|false | boolean | false |
| sorter | Sorting function, local sorting uses a function (refer to the compreFunction of Array.sort), requiring a server-side sorting can be set to true | boolean\|(r1: RecordType, r2: RecordType) => number | true |
| title | Column header displays text. When a function is passed in, title will use the return value of the function; when other types are passed in, they will be aggregated with sorter and filter | string \| ReactNode\|({ filter: ReactNode, sorter: ReactNode, selection: ReactNode }) => ReactNode | | Function type requires **0.34.0** |
| useFullRender | Whether to completely customize the rendering, see [Full Custom Rendering](#Fully-custom-rendering) for usage details | boolean | false | **0.34.0** |
| width | Column width | string \| number | |
| onCell | Set cell properties | (record: RecordType, rowIndex: number) => object | |
| onFilter | Determine the running function of the filter in local mode | (filteredValue: any[], record: RecordType) => boolean | |
| onFilterDropdownVisibleChange | A callback when a custom filter menu is visible | (visible: boolean) => void | |
| onHeaderCell | Set the head cell property | (column: RecordType, columnIndex: number) => object | |
Some of the type definitions used above:
```typescript
// RecordType is a generic parameter of Table and Column, the default is object type
type Filter = {
value: any;
text: React.ReactNode;
children?: Filter[];
};
```
## rowSelection
| Parameters | Instructions | Type | Default | Version |
| ---------------- | ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | --------- | ------------------ |
| className | Style name listed | string | |
| disabled | Disabled `Checkbox` in `Table` header or not. | boolean | false | **0.32.0** |
| fixed | Secure the selection box column to the left. | boolean | false |
| getCheckboxProps | Default property configuration for the selection box | (record: RecordType) => object | | |
| hidden | Hide selection column or not | boolean | false | **0.34.0** |
| selectedRowKeys | Specifies the key array of the selected item, which needs to work with onChange | string [] | | |
| title | Custom List Selection Box Title | string | ReactNode | |
| width | Custom list selection box width | string | number | |
| onChange | A callback in the event of a change in the selected item. The first parameter will save the row keys selected last time, even if you do paging control or update the dataSource [FAQ](#faq) | (selectedRowKeys: number[]\|string[], selectedRows: RecordType[]) => void | | |
| onSelect | Callback when the user manually clicks the selection box of a row | (record: RecordType, selected: boolean, selectedRows: RecordType[], nativeEvent: MouseEvent) => void | | |
| onSelectAll | The user manually clicks the callback of the header selection box, and all optional rows in the dataSource will be selected/unselected | (selected: boolean, selectedRows: RecordType[], changedRows: RecordType[]) => void | | |
## scroll
| Parameters | Instructions | Type | Default | Version |
| ------------------------ | ---------------------------------------------------------------------------------------------------- | -------------- | ------- | ------------- |
| scrollToFirstRowOnChange | Whether to automatically scroll to the top of the table after paging, sorting, and filtering changes | boolean | false | 1.1.0 |
| x | Set the width of the horizontal scroll area, which can be pixel value, percentage, or 'max-content' | string\|number | | |
| y | Set the height of the vertical scroll area, which can be a pixel value | number | | |
## pagination
Page-turning component configuration. Pagination suggests not to use literal value.
| Parameters | Instructions | Type | Default | Version |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | -------- | ------------------- |
| currentPage | Current page number | number | - | |
| defaultCurrentPage | Default current page number | number | 1 | **>=1.1.0** |
| formatPageText | Page-turning area copywriting custom formatting, pass false to close copywriting display; This item affects the copy display on the left of the page turning area of the form. It is different from the `showTotal` parameter of the`Pagination` component. | boolean\| ({ currentStart: number, currentEnd: number, total: number }) => string\|ReactNode | true | **0.27.0** |
| pageSize | Number of entries per page | number | 10 | |
| position | Location | 'bottom '\|'top '\|'both' | 'bottom' |
| total | Total number of entries | number | 0 | **>=0.25.0** |
For other configurations, see [Pagination](/en-US/navigation/pagination#API-Reference)
## Resizable
The parameters of the resizable object type, which mainly include event methods when the table column is scaled. These event methods can return an object that merges with the final column.
| Parameters | Instructions | Type | Default |
| ------------- | ---------------------------------------------------------- | ------------------------------------------------ | ------- |
| onResize | Triggers when the table column changes its width | (column: [Column](#Column)) => [Column](#Column) | |
| onResizeStart | Triggers when the table column starts to change the width. | (column: [Column](#Column)) => [Column](#Column) | |
| onResizeStop | Triggers when the table column stops changing the width | (column: [Column](#Column)) => [Column](#Column) | |
## Methods
Some internal methods provided by Table can be accessed through ref:
```jsx noInline=true
import React, { useRef, useEffect } from 'react';
import { Table } from '@douyinfe/semi-ui';
function Demo() {
const ref = useRef();
useEffect(() => {
ref.getCurrentPageData(); // => { dataSource: [/*...*/], groups: /*...*/ }
}, []);
return (
);
}
```
| Parameters | Instructions | Version |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------- | -------------- |
| getCurrentPageData() | Returns the data object of the current page: { dataSource: RecordType[], groups: Map<{groupKey: string, recordKeys: Set}> } | 0.37.0 |
## Accessibility
### ARIA
- The role of the table is grid, and the role of the tree table is treegrid
- the row's role is row, and the cell's role is gridcell
- Added aria-rowcount and aria-colcount attributes to the table to indicate the number of rows and columns
- The row has added aria-rowindex to indicate which row it currently belongs to, and the first row is 1
- The row of the tree table has aria-level representing the tree level of the current row, the first level is 1
- Expandable table rows have the aria-expanded attribute, indicating whether the current row is expanded
- The new aria-colindex of the cell indicates which column the current grid belongs to, and the first column is 1
- Added aria-label to column filter and sort buttons, and added aria-label attribute to row select buttons
## Content Guidelines
- Table title
- The title of the table should clearly make the user perceive the purpose of the table;
- Add descriptions to complex tables to provide users with more contextual information about the table;
- use sentence case;
- Column headers
- Keep column headings concise, it is recommended to use 1-2 words as column headings;
- When the column header is long, it is recommended to display it in 2 lines, and the remaining text is abbreviated and displayed completely in the Tooltip;
- Adopt the capitalization rules of Sentence case;
- Use sentence case for column headings;
- Table operation area
- You can follow [Button's content Guidelines](/en-US/input/button)
## Design Tokens
## FAQ
- **Why is the table data not updated?**
At present, all parameters of the table component are shallow comparison. That is to say, if the parameter value type is an array or object, you need to manually change its reference to trigger the update. Similarly, if you don't want to trigger additional updates, try not to use literal values when passing parameters directly or define reference parameter values in the render process:
```text
// ...render() {
// }
```
The above writing method will trigger the update of data in the table every time render (the current selected row will be cleared and the row key array will be expanded, etc.). In order to improve performance and avoid some exceptions, please define some reference type parameters outside the render method as far as possible (if hooks are used, please use useMemo or useState for storage).**
- **Why can't my form line be selected and expanded?**
Please specify a rowKey or set a different "key" attribute for each item of the dataSource. **All rows related operations in the table need to be used.**
- **How to implement custom sorting or pass parameters to the server for sorting when clicking the sort button?**
The input parameters of the onChange method include pagination, filters, and sorter. Users can customize the sorting of the dataSource according to the sorter.
- **How to add className to a row?**
Use onRow or onHeaderRow.
- **How to style the table cell?**
It can be controlled by column.onHeaderCell and column.onCell.
- **Why cache the previously selected keys for the first parameter of `rowSelection` `onChange`?**
This is for the scenario where the selected row keys are lost when data is selected on the first page during paging, and then the data is selected on the second page. If you don't want to use the cached keys, you can filter it from the current dataSource or use the second parameter of `rowSelection` `onChange`.
- **Does it support single row selection?**
Table currently does not support single-row selection function, and users can implement single selection in a custom way. Please check the FAQ.
- **How is Table implemented, I want to know more details?**
Please click Semi Table component design
See more Table FAQ and demos, please click Table FAQ