---
localeCode: en-US
order: 56
category: Show
title: Table
subTitle: Table
icon: doc-table
dir: column
brief: Show row data.
---
## When to Use
- When there is a large amount of structured data to be presented;
- When complex behaviors such as sorting, searching, paging and customizing data need to be performed.
## 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';
class App extends React.Component {
constructor() {
this.columns = [
{
title: 'Name',
Data Index: 'name',
render: text => {text},
},
{
title: 'Age',
dataIndex: 'age',
},
{
title: 'Address',
dataIndex: 'address',
},
];
this.data = [
{
key: '1',
name: 'John Brown',
age: 32,
address: 'New York No. 1 Lake Park, New York No. 1 Lake Park',
},
{
key: '2',
name: 'Jim Green',
age: 42,
address: 'London No. 1 Lake Park',
},
{
key: '3',
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
},
{
key: '4',
name: 'Michael James',
age: 99,
address: 'Sidney No. 1 Lake Park',
},
];
}
render() {
;
}
}
```
## 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 } from '@douyinfe/semi-ui';
class App extends React.Component {
constructor() {
this.columns = [
{
title: 'Name',
dataIndex: 'name',
render: (text, record, index) => {
console.log(text, record, index);
return {text};
},
},
{
title: 'Age',
dataIndex: 'age',
},
{
title: 'Address',
dataIndex: 'address',
},
];
this.data = [
{
key: '1',
name: 'John Brown',
age: 32,
address: 'New York No. 1 Lake Park, New York No. 1 Lake Park',
},
{
key: '2',
name: 'Jim Green',
age: 42,
address: 'London No. 1 Lake Park',
},
{
key: '3',
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
},
{
key: '4',
name: 'Michael James',
age: 99,
address: 'Sidney No. 1 Lake Park',
},
];
}
render() {
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.
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table } from '@douyinfe/semi-ui';
const { Column } = Table;
class App extends React.Component {
constructor() {
this.data = [
{
key: '1',
name: 'John Brown',
age: 32,
address: 'New York No. 1 Lake Park, New York No. 1 Lake Park',
},
{
key: '2',
name: 'Jim Green',
age: 42,
address: 'London No. 1 Lake Park',
},
{
key: '3',
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
},
{
key: '4',
name: 'Michael James',
age: 99,
address: 'Sidney No. 1 Lake Park',
},
];
}
render() {
return (
);
}
}
render(App);
```
### Line Selection Operation
This feature can be turned on by passing in `rowSelection`.
> 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 } from '@douyinfe/semi-ui';
class App extends React.Component {
constructor() {
this.columns = [
{
title: 'Name',
dataIndex: 'name',
render: text => {text},
},
{
title: 'Age',
dataIndex: 'age',
},
{
title: 'Address',
dataIndex: 'address',
},
];
this.data = [
{
key: '1',
name: 'John Brown',
age: 32,
address: 'New York No. 1 Lake Park, New York No. 1 Lake Park',
},
{
key: '2',
name: 'Jim Green',
age: 42,
address: 'London No. 1 Lake Park',
},
{
key: '3',
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
},
{
key: '4',
name: 'Michael James',
age: 99,
address: 'Sidney No. 1 Lake Park',
},
];
this.rowSelection = {
onChange: (selectedRowKeys, selectedRows) => {
console.log(`selectedRowKeys: ${selectedRowKeys}`, 'selectedRows: ', selectedRows);
},
getCheckboxProps: record => ({
disabled: record.name === 'Michael James', // Column configuration not to be checked
name: record.name,
}),
};
}
render() {
return (
);
}
}
render(App);
```
### Custom Rendering
Users can use Column.render to customize the rendering of a column of cells, which is suitable for rendering more complex cell content.
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table, Button } from '@douyinfe/semi-ui';
import { IconDelete } from '@douyinfe/semi-icons';
class TableApp extends React.Component {
constructor(props) {
super(props);
this.raw = [
{
key: '1',
name: 'John Brown',
age: 32,
address: 'New York No. 1 Lake Park, New York No. 1 Lake Park',
},
{
key: '2',
name: 'Jim Green',
age: 42,
address: 'London No. 1 Lake Park',
},
{
key: '3',
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
},
{
key: '4',
name: 'Michael James',
age: 99,
address: 'Sidney No. 1 Lake Park',
},
];
this.state = {
dataSource: [...this.raw],
columns: [
{
title: 'Name',
dataIndex: 'name',
width: 200,
render: text => {text},
},
{
width: 90,
title: 'Age',
dataIndex: 'age',
},
{
title: 'Address',
dataIndex: 'address',
},
{
title: 'Operation',
width: 150,
render: (text, record) => (
}theme="borderless" onClick={() => this.removeRecord(record.key)} />
),
},
],
};
}
removeRecord(key) {
let dataSource = [...this.state.dataSource];
if (key != null) {
let idx = dataSource.findIndex(data => data.key === key);
// console.log(key, dataSource, idx);
if (idx > -1) {
dataSource.splice(idx, 1);
this.setState({ dataSource });
}
}
}
resetData() {
let dataSource = [...this.raw];
this.setState({ dataSource });
}
render() {
let { columns, dataSource } = this.state;
return (
<>
);
}
}
render(TableApp);
```
### 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 from 'react';
import { Table } from '@douyinfe/semi-ui';
class TableApp extends React.Component {
constructor() {
this.columns = [
{
title: 'Name',
dataIndex: 'name',
width: 150,
filters: [
{
text: 'King 3',
value: 'King 3',
},
{
text: 'King 4',
value: 'King 4',
},
],
onFilter: (value, record) => record.name.includes(value),
},
{
title: 'Age',
dataIndex: 'age',
width: 150,
sorter: (a, b) => (a.age - b.age > 0 ? 1 : -1),
},
{
title: 'Address',
dataIndex: 'address',
},
];
this.data = [];
this.rowSelection = {
onChange: (selectedRowKeys, selectedRows) => {
// console.log(`selectedRowKeys: ${selectedRowKeys}`, 'selectedRows: ', selectedRows);
},
getCheckboxProps: record => ({
disabled: record.name === 'Michael James', // Column configuration not to be checked
name: record.name,
}),
};
for (let i = 0; i < 46; i++) {
this.data.push({
key: '' + i,
name: `Edward King ${i}`,
age: 40 + (Math.random() > 0.5 ? 1 : -1) * Math.ceil(i / 3),
address: `London, Park Lane no. ${i}`,
});
}
this.scroll = { y: 300 };
}
render() {
return (
);
}
}
render(TableApp);
```
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.
### 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.
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table } from '@douyinfe/semi-ui';
class App extends React.Component {
constructor() {
const columns = [
{
title: 'Name',
dataIndex: 'name',
},
{
title: 'Age',
dataIndex: 'age',
},
{
title: 'Address',
dataIndex: 'address',
},
];
const data = [];
for (let i = 0; i < 46; i++) {
data.push({
key: '' + i,
name: `Edward King ${i}`,
age: 32,
address: `London, Park Lane no. ${i}`,
});
}
this.data = data;
this.fetchData = (currentPage = 1) => {
// console.log(`FetchData currentPage: `, currentPage);
this.setState({ loading: true });
let pagination = { ...this.state.pagination, currentPage };
return new Promise((res, rej) => {
setTimeout(() => {
let dataSource = this.data.slice(
(currentPage - 1) * pagination.pageSize,
currentPage * pagination.pageSize
);
res(dataSource);
}, 1500);
}).then(dataSource => {
// console.log('Request data: ', dataSource);
this.setState({
loading: false,
pagination,
dataSource,
});
});
};
this.state = {
loading: false,
columns,
pagination: {
currentPage: 1,
pageSize: 5,
total: data.length,
onPageChange: page => this.fetchData(page),
},
dataSource: [],
};
}
componentDidMount() {
this.fetchData();
}
render() {
let { columns, dataSource, pagination, loading } = this.state;
return
;
}
}
render(App);
```
### Fixed Column or Head
You can fix the column by setting the Fixed attribute of the column and scoll.x, and fix the header by setting scoll.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 from 'react';
import { Table, Tooltip, Tag } from '@douyinfe/semi-ui';
class TableApp extends React.Component {
constructor() {
this.columns = [
{
title: 'Name',
dataIndex: 'name',
width: 150,
fixed: true,
filters: [
{
text: 'King 3',
value: 'King 3',
},
{
text: 'King 4',
value: 'King 4',
},
],
onFilter: (value, record) => record.name.includes(value),
},
{
title: 'Age',
dataIndex: 'age',
width: 150,
sorter: (a, b) => (a.age - b.age > 0 ? 1 : -1),
},
{
title: 'Address',
width: 200,
dataIndex: 'address',
},
{
title: 'Description',
// width: 400,
dataIndex: 'description',
},
{
fixed: 'right',
width: 250,
render: (text, record) => (
Show Info
),
},
];
this.data = [];
this.rowSelection = {
onChange: (selectedRowKeys, selectedRows) => {
// console.log(`selectedRowKeys: ${selectedRowKeys}`, 'selectedRows: ', selectedRows);
},
getCheckboxProps: record => ({
disabled: record.name === 'Michael James', // Column configuration not to be checked
name: record.name,
}),
};
for (let i = 0; i < 46; i++) {
let age = 40 + (Math.random() > 0.5 ? 1 : -1) * Math.ceil(i / 3);
let name = `Edward King ${i}`;
this.data.push({
key: '' + i,
name,
age,
address: `London, Park Lane no. ${i}`,
description: `My name is ${name}, I am ${age} years old, living in New York No. ${i + 1} Lake Park.`,
});
}
this.scroll = { y: 300, x: 1500 };
}
render() {
return
;
}
}
render(TableApp);
```
### 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 from 'react';
import { Table } from '@douyinfe/semi-ui';
class App extends React.Component {
constructor() {
this.state = {
sortColumns: [
{
title: 'Name',
dataIndex: 'name',
filters: [
{
text: 'Joe',
value: 'Joe',
},
{
text: 'Jim',
value: 'Jim',
},
],
onFilter: (value, record) => record.name.indexOf(value) === 0,
sorter: (a, b) => a.name.length - b.name.length,
},
{
title: 'Age',
dataIndex: 'age',
sorter: (a, b) => (a.age - b.age > 0 ? 1 : -1),
},
{
title: 'Address',
dataIndex: 'address',
filters: [
{
text: 'London',
value: 'London',
},
{
text: 'New York',
value: 'New York',
},
],
filterMultiple: false,
onFilter: (value, record) => record.address.indexOf(value) === 0,
sorter: (a, b) => a.address.length - b.address.length,
},
],
sortData: [
{
key: '1',
name: 'John Brown',
age: 32,
address: 'New York No. 1 Lake Park',
},
{
key: '2',
name: 'Jim Green',
age: 42,
address: 'London No. 1 Lake Park',
},
{
key: '3',
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
},
{
key: '4',
name: 'Jim Red',
age: 32,
address: 'London No. 2 Lake Park',
},
],
};
this.onChange = (...args) => {
console.log('Table changed to:', ...args);
};
}
render() {
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 from 'react';
import { Table, Tag, Tooltip, Dropdown } from '@douyinfe/semi-ui';
class CustomDropdownItem extends React.Component {
constructor(props = {}) {
super(props);
this.columns = [
{
title: 'Name',
dataIndex: 'name',
width: 150,
fixed: true,
filterMultiple: false,
filters: [
{
text: 'Code 45',
value: '45',
},
{
text: 'King 4',
value: 'King 4',
},
],
onFilter: (value, record) => record.name.includes(value),
renderFilterDropdownItem: ({ text, checked, onChange }) => (
{text}
),
filterDropdownProps: {
showTick: true,
},
},
{
title: 'Age',
dataIndex: 'age',
width: 150,
sorter: (a, b) => (a.age - b.age > 0 ? 1 : -1),
},
{
title: 'Address',
width: 200,
dataIndex: 'address',
},
{
title: 'Description',
dataIndex: 'description',
},
{
fixed: 'right',
width: 250,
render: (text, record) => (
Show Info
),
},
];
this.data = [];
for (let i = 0; i < 46; i++) {
let age = 40 + (Math.random() > 0.5 ? 1 : -1) * Math.ceil(i / 3);
let name = `Edward King ${i}`;
this.data.push({
key: '' + i,
name,
age,
address: `London, Park Lane no. ${i}`,
description: `My name is ${name}, I am ${age} years old, living in New York No. ${i + 1} Lake Park.`,
});
}
this.scroll = { y: 400, x: '150%' };
}
render() {
return
;
}
}
render(CustomDropdownItem);
```
### A Table That Can Be Expanded
> Notice:
>
> - 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}`.
> - 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 } from '@douyinfe/semi-ui';
class App extends React.Component {
constructor() {
this.expandColumns = [
{ title: 'Name', dataIndex: 'name', key: 'name' },
{ title: 'Age', dataIndex: 'age', key: 'age' },
{ title: 'Address', dataIndex: 'address', key: 'address' },
{
title: 'Action',
dataIndex: '',
key: 'x',
render: () => Delete,
},
];
this.rowSelection = {
onChange: (selectedRowKeys, selectedRows) => {
// console.log(`selectedRowKeys: ${selectedRowKeys}`, 'selectedRows: ', selectedRows);
},
getCheckboxProps: record => ({
disabled: record.name === 'Michael James', // Column configuration not to be checked
name: record.name,
}),
};
this.expandData = [
{
name: 'John Brown',
age: 32,
address: 'New York No. 1 Lake Park',
description: 'My name is John Brown, I am 32 years old, living in New York No. 1 Lake Park.',
},
{
name: 'Jim Green',
age: 42,
address: 'London No. 1 Lake Park',
description: 'My name is Jim Green, I am 42 years old, living in London No. 1 Lake Park.',
},
{
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
description: 'My name is Joe Black, I am 32 years old, living in Sidney No. 1 Lake Park.',
},
];
this.expandRowRender = (record, index) =>
index < 2 ? (
) : (
{record.description}
);
}
render() {
return (
);
}
}
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 } from '@douyinfe/semi-ui';
class App extends React.Component {
constructor() {
this.expandColumns = [
{ title: 'Name', dataIndex: 'name', key: 'name' },
{ title: 'Age', dataIndex: 'age', key: 'age' },
{ title: 'Address', dataIndex: 'address', key: 'address' },
{
expandIcon: true,
title: 'Action',
dataIndex: '',
key: 'x',
render: () => Delete,
},
];
this.rowSelection = {
onChange: (selectedRowKeys, selectedRows) => {
// console.log(`selectedRowKeys: ${selectedRowKeys}`, 'selectedRows: ', selectedRows);
},
getCheckboxProps: record => ({
disabled: record.name === 'Michael James', // Column configuration not to be checked
name: record.name,
}),
};
this.expandData = [
{
name: 'John Brown',
age: 32,
address: 'New York No. 1 Lake Park',
description: 'My name is John Brown, I am 32 years old, living in New York No. 1 Lake Park.',
},
{
name: 'Jim Green',
age: 42,
address: 'London No. 1 Lake Park',
description: 'My name is Jim Green, I am 42 years old, living in London No. 1 Lake Park.',
},
{
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
description: 'My name is Joe Black, I am 32 years old, living in Sidney No. 1 Lake Park.',
},
];
this.expandRowRender = record =>
{record.description}
;
}
render() {
return (
);
}
}
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 } from '@douyinfe/semi-ui';
class App extends React.Component {
constructor() {
this.expandColumns = [
{ title: 'Name', dataIndex: 'name', key: 'name' },
{ title: 'Age', dataIndex: 'age', key: 'age' },
{ title: 'Address', dataIndex: 'address', key: 'address' },
{
expandIcon: true,
title: 'Action',
dataIndex: '',
key: 'x',
render: () => Delete,
},
];
this.rowSelection = {
onChange: (selectedRowKeys, selectedRows) => {
// console.log(`selectedRowKeys: ${selectedRowKeys}`, 'selectedRows: ', selectedRows);
},
getCheckboxProps: record => ({
disabled: record.name === 'Michael James', // Column configuration not to be checked
name: record.name,
}),
};
this.expandData = [
{
name: 'John Brown',
age: 32,
address: 'New York No. 1 Lake Park',
description: 'My name is John Brown, I am 32 years old, living in New York No. 1 Lake Park.',
},
{
name: 'Jim Green',
age: 42,
address: 'London No. 1 Lake Park',
description: 'My name is Jim Green, I am 42 years old, living in London No. 1 Lake Park.',
},
{
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
description: 'My name is Joe Black, I am 32 years old, living in Sidney No. 1 Lake Park.',
},
];
this.expandRowRender = record =>
{record.description}
;
}
render() {
return (
record.name !== 'Jim Green'}
rowSelection={this.rowSelection}
expandedRowRender={this.expandRowRender}
dataSource={this.expandData}
/>
);
}
}
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';
const Demo = () => {
const columns = [
{
title: 'Name',
dataIndex: 'name',
key: 'name',
},
{
title: 'Age',
dataIndex: 'age',
key: 'age',
width: 150,
},
{
title: 'Address',
dataIndex: 'address',
key: 'address',
width: 400,
},
];
const data = [
{
key: 1,
name: 'John Brown sr.',
age: 60,
address: 'New York No. 1 Lake Park',
children: [
{
key: 11,
name: 'John Brown',
age: 42,
address: 'New York No. 2 Lake Park',
},
{
key: 12,
name: 'John Brown jr.',
age: 30,
address: 'New York No. 3 Lake Park',
children: [
{
key: 121,
name: 'Jimmy Brown',
age: 16,
address: 'New York No. 3 Lake Park',
},
],
},
{
key: 13,
name: 'Jim Green sr.',
age: 72,
address: 'London No. 1 Lake Park',
children: [
{
key: 131,
name: 'Jim Green',
age: 42,
address: 'London No. 2 Lake Park',
children: [
{
key: 1311,
name: 'Jim Green jr.',
age: 25,
address: 'London No. 3 Lake Park',
},
{
key: 1312,
name: 'Jimmy Green sr.',
age: 18,
address: 'London No. 4 Lake Park',
},
],
},
],
},
],
},
{
key: 2,
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
},
];
return
;
};
render(Demo);
```
#### 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 Demo = () => {
const childrenRecordName = 'children';
const rowKey = 'key';
const [expandedRowKeys, setExpandedRowKeys] = useState([1, 2]);
const [data, setData] = useState([
{
key: 1,
name: 'John Brown sr.',
age: 60,
address: 'New York No. 1 Lake Park',
children: [
{
key: 11,
name: 'John Brown',
age: 42,
address: 'New York No. 2 Lake Park',
},
{
key: 12,
name: 'John Brown jr.',
age: 30,
address: 'New York No. 3 Lake Park',
children: [
{
key: 121,
name: 'Jimmy Brown',
age: 16,
address: 'New York No. 3 Lake Park',
},
],
},
{
key: 13,
name: 'Jim Green sr.',
age: 72,
address: 'London No. 1 Lake Park',
children: [
{
key: 131,
name: 'Jim Green',
age: 42,
address: 'London No. 2 Lake Park',
children: [
{
key: 1311,
name: 'Jim Green jr.',
age: 25,
address: 'London No. 3 Lake Park',
},
{
key: 1312,
name: 'Jimmy Green sr.',
age: 18,
address: 'London No. 4 Lake Park',
},
],
},
],
},
],
},
{
key: 2,
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
},
]);
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: 'Name',
dataIndex: 'name',
key: 'name',
width: 300,
},
{
title: 'Age',
dataIndex: 'age',
key: 'age',
width: 150,
},
{
title: 'Address',
dataIndex: 'address',
key: 'address',
width: 300,
},
{
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 (
setExpandedRowKeys(rows.map(item => item[rowKey]))}
rowSelection={rowSelection}
dataSource={data}
/>
);
}
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, Tooltip, Tag } from '@douyinfe/semi-ui/';
function EventTable(props = {}) {
const dataTotalSize = 46;
const columns = useMemo(
() => [
{
title: 'Name',
dataIndex: 'name',
width: 150,
},
{
title: 'Age',
dataIndex: 'age',
width: 150,
},
{
title: 'Address',
dataIndex: 'address',
},
{
render: (text, record) => (
Show Info
),
width: 150,
},
],
[]
);
const data = useMemo(() => {
const _data = [];
for (let i = 0; i < dataTotalSize; i++) {
let age = 40 + (Math.random() > 0.5 ? 1 : -1) * Math.ceil(i / 3);
let name = `Edward King ${i}`;
_data.push({
key: '' + i,
name,
age,
address: `London, Park Lane no. ${i} Lake Park`,
description: `My name is ${name}, I am ${age} years old, living in New York No. ${i + 1} Lake Park.`,
});
}
return _data;
}, []);
const onRow = useMemo(
() => (record, index) => {
const props = {
className: 'my-tr-class',
};
if (index === 2) {
return {
...props,
onClick: e => console.log('mouse click: ', record, index),
};
} else {
return {
...props,
};
}
},
[]
);
const onHeaderRow = useMemo(
() => (columns, index) => {
return {
onMouseEnter: e => console.log('mouse enter: ', columns, index),
onMouseLeave: e => console.log('mouse leave: ', columns, index),
};
},
[]
);
return
;
}
render(EventTable);
```
### Zebra Pattern Table
Use `OnRow` to set a background color for each row to create a zebra stripped table.
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table } from '@douyinfe/semi-ui';
function App() {
const columns = [
{
title: 'Name',
dataIndex: 'name',
render: (text, record, index) => {
console.log(text, record, index)
return {text};
},
},
{
title: 'Age',
dataIndex: 'age',
},
{
title: 'Address',
dataIndex: 'address',
},
];
const data = [
{
key: '1',
name: 'John Brown',
age: 32,
address: 'New York No. 1 Lake Park, New York No. 1 Lake Park',
},
{
key: '2',
name: 'Jim Green',
age: 42,
address: 'London No. 1 Lake Park',
},
{
key: '3',
name: 'Joe Black',
age: 32,
address: 'Sidney No. 1 Lake Park',
},
{
key: '4',
name: 'Michael James',
age: 99,
address: 'Sidney No. 1 Lake Park',
},
];
const handleRow = (record, index) => {
// Set zebra pattern for even rows
if (index % 2 === 0) {
return {
style: {
background: 'var(--semi-color-fill-0)',
}
};
} else {
return {};
}
};
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)
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table, Tooltip, Tag } from '@douyinfe/semi-ui';
class ResizableDemo extends React.Component {
constructor() {
this.columns = [
{
title: 'Name',
dataIndex: 'name',
width: 150,
},
{
title: 'Age',
dataIndex: 'age',
width: 150,
sorter: (a, b) => (a.age - b.age > 0 ? 1 : -1),
},
{
title: 'Address',
width: 200,
dataIndex: 'address',
},
{
render: (text, record) => (
Show Info
),
},
];
this.data = [];
this.rowSelection = {
onChange: (selectedRowKeys, selectedRows) => {
// console.log(`selectedRowKeys: ${selectedRowKeys}`, 'selectedRows: ', selectedRows);
},
getCheckboxProps: record => ({
disabled: record.name === 'Michael James', // Column configuration not to be checked
name: record.name,
}),
};
for (let i = 0; i < 46; i++) {
let age = 40 + (Math.random() > 0.5 ? 1 : -1) * Math.ceil(i / 3);
let name = `Edward King ${i}`;
this.data.push({
key: '' + i,
name,
age,
address: `London, Park Lane no. ${i}`,
description: `My name is ${name}, I am ${age} years old, living in New York No. ${i + 1} Lake Park.`,
});
}
}
render() {
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 from 'react';
import { Table, Tooltip, Tag } from '@douyinfe/semi-ui';
import { addClass, removeClass } from '@douyinfe/semi-foundation/utils';
class ResizableDemo extends React.Component {
constructor() {
this.columns = [
{
title: 'Name',
dataIndex: 'name',
width: 150,
},
{
title: 'Age',
dataIndex: 'age',
width: 150,
},
{
title: 'Address',
width: 200,
dataIndex: 'address',
},
{
render: (text, record) => (
Show Info
),
},
];
this.data = [];
this.rowSelection = {
onChange: (selectedRowKeys, selectedRows) => {
// console.log(`selectedRowKeys: ${selectedRowKeys}`, 'selectedRows: ', selectedRows);
},
getCheckboxProps: record => ({
disabled: record.name === 'Michael James', // Column configuration not to be checked
name: record.name,
}),
};
for (let i = 0; i < 46; i++) {
let age = 40 + (Math.random() > 0.5 ? 1 : -1) * Math.ceil(i / 3);
let name = `Edward King ${i}`;
this.data.push({
key: '' + i,
name,
age,
address: `London, Park Lane no. ${i}`,
description: `My name is ${name}, I am ${age} years old, living in New York No. ${i + 1} Lake Park.`,
});
}
this.resizable = {
onResizeStart: curColumn => {
const className = addClass(curColumn.className, 'my-resizing');
return { className };
},
onResizeStop: curColumn => {
const className = removeClass(curColumn.className, 'my-resizing');
return { className };
},
};
this.pagination = {
pageSize: 5,
};
}
render() {
return (
);
}
}
render(ResizableDemo);
```
The CSS style definition used in this example:
```css
#components-table-demo-resizable-column .my-resizing {
border-right: 2px solid red;
}
#components-table-demo-resizable-column .react-resizable-handle:hover {
background-color: red;
}
#components-table-demo-resizable-column .my-resizing:hover .react-resizable-handle {
background-color: inherit;
}
```
### Drag Sorting
With custom elements, we can integrate `react-dnd` To implement drag and drop sorting.
```jsx live=true dir="column" noInline=true
import React, { useState, useMemo, useCallback } from 'react';
import { Table, Tooltip, Tag } from '@douyinfe/semi-ui';
import { DndProvider, DragSource, DropTarget } from 'react-dnd';
import HTML5Backend from 'react-dnd-html5-backend';
let draggingIndex = -1;
const PAGE_SIZE = 5;
function BodyRow(props) {
const { isOver, connectDragSource, connectDropTarget, moveRow, currentPage, ...restProps } = props;
const style = { ...restProps.style, cursor: 'move' };
let { className } = restProps;
if (isOver) {
console.log('true');
if (restProps.index > draggingIndex) {
className += ' drop-over-downward';
}
if (restProps.index < draggingIndex) {
className += ' drop-over-upward';
}
}
return connectDragSource(connectDropTarget(
({
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 } from '@douyinfe/semi-ui';
function Demo() {
const rowKey = record => `${record.city && record.city.toLowerCase()}-${record.job && record.job.toLowerCase()}`;
/**
* FE => frontend engineer
* BE => backend engineer
* Andoird => android engineer
* IOS => ios engineer
* SE => software engineer
*/
const data = [
{ city: 'Beijing', job: 'FE', department: 'IES' },
{ city: 'Beijing', job: 'BE', department: 'IES' },
{ city: 'Shanghai', job: 'Android', department: 'IES' },
{ city: 'Tokyo', job: 'Android', department: 'IES' },
{ city: 'Shanghai', job: 'IOS', department: 'EE' },
{ city: 'LA', job: 'SE', department: 'EE' },
{ city: 'Beijing', job: 'Android', department: 'EE' },
{ city: 'Tokyo', job: 'IOS', department: 'EE' },
{ city: 'Tokyo', job: 'SE', department: 'DATA' },
{ city: 'Shanghai', job: 'BE', department: 'DATA' },
{ city: 'LA', job: 'Android', department: 'DATA' },
{ city: 'LA', job: 'IOS', department: 'DATA' },
];
const columns = [
{ dataIndex: 'city', title: 'City', width: 400, sorter: (a, b) => (a.city > b.city ? 1 : -1) },
{
dataIndex: 'job',
title: 'Job',
width: 200,
filters: [
{ text: 'IOS', value: 'IOS' },
{ text: 'Android', value: 'Android' },
],
onFilter: (value, record) => record.job && record.job.indexOf(value) === 0,
},
{ dataIndex: 'department', title: 'Department' },
];
return (
Jobs in {groupKey}:}
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 from 'react';
import { Table, Tag, Tooltip } from '@douyinfe/semi-ui';
class VirtualizedFixedDemo extends React.Component {
constructor(props = {}) {
super(props);
this.columns = [
{
title: 'Name',
dataIndex: 'name',
width: 150,
fixed: true,
filters: [
{
text: 'Code 45',
value: '45',
},
{
text: 'King 4',
value: 'King 4',
},
],
onFilter: (value, record) => record.name.includes(value),
},
{
title: 'Age',
dataIndex: 'age',
width: 150,
sorter: (a, b) => (a.age - b.age > 0 ? 1 : -1),
},
{
title: 'Address',
// width: 200,
dataIndex: 'address',
},
{
fixed: 'right',
width: 250,
render: (text, record) => (
Show Info
),
},
];
this.data = [];
for (let i = 0; i < 1000; i++) {
let age = 40 + (Math.random() > 0.5 ? 1 : -1) * (i % 9);
let name = `Edward King ${i}`;
this.data.push({
key: '' + i,
name,
age,
address: `London, Park Lane no. ${i}`,
description: `My name is ${name}, I am ${age} years old, living in New York No. ${i + 1} Lake Park.`,
});
}
this.scroll = { y: 400, x: 1600 };
this.style = { width: 750, margin: '0 auto' };
}
render() {
return (
);
}
}
render(VirtualizedFixedDemo);
```
### Infinite Scroll
Based on the virtualization feature, we can achieve infinite scroll loading data by passing in `virtualized.onScroll`.
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table, Tag, Tooltip } from '@douyinfe/semi-ui';
class InfiniteScrollDemo extends React.Component {
constructor(props = {}) {
super(props);
this.state = {
data: [],
};
this.columns = [
{
title: 'Name',
dataIndex: 'name',
width: 150,
fixed: true,
filters: [
{
text: 'Code 45',
value: '45',
},
{
text: 'King 4',
value: 'King 4',
},
],
onFilter: (value, record) => record.name.includes(value),
},
{
title: 'Age',
dataIndex: 'age',
width: 150,
sorter: (a, b) => (a.age - b.age > 0 ? 1 : -1),
},
{
title: 'Address',
// width: 200,
dataIndex: 'address',
},
{
fixed: 'right',
width: 250,
render: (text, record) => (
Show Info
),
},
];
this.scroll = { y: 600, x: 1000 };
this.style = { width: 750, margin: '0 auto' };
const itemSize = 56;
this.virtualized = {
itemSize,
onScroll: ({ scrollDirection, scrollOffset, scrollUpdateWasRequested }) => {
const { data } = this.state;
if (
scrollDirection === 'forward' &&
scrollOffset >= (data.length - Math.ceil(this.scroll.y / itemSize) * 1.5) * itemSize &&
!scrollUpdateWasRequested
) {
this.loadMore();
}
},
};
this.loadMore = this.loadMore.bind(this);
}
loadMore() {
const pageSize = 20; // load 20 records every time
const data = [...this.state.data];
const currentLenght = data.length;
for (let i = currentLenght; i < currentLenght + pageSize; i++) {
let age = 40 + (Math.random() > 0.5 ? 1 : -1) * (i % 9);
let name = `Edward King ${i}`;
data.push({
key: '' + i,
name,
age,
address: `London, Park Lane no. ${i}`,
description: `My name is ${name}, I am ${age} years old, living in New York No. ${i + 1} Lake Park.`,
});
}
this.setState({ data });
}
componentDidMount() {
this.loadMore();
}
render() {
return (
);
}
}
render(InfiniteScrollDemo);
```
### Controlled Dynamic Tables
```jsx live=true noInline=true dir="column"
import React from 'react';
import { Table, Switch, ButtonGroup, Button, Tooltip, Tag } from '@douyinfe/semi-ui';
class App extends React.Component {
constructor(props) {
super(props);
const dataTotalSize = 46;
const columns = [
{
title: 'Name',
dataIndex: 'name',
width: 150,
},
{
title: 'Age',
dataIndex: 'age',
width: 150,
},
{
title: 'Address',
dataIndex: 'address',
},
{
render: (text, record) => (
Show Info
),
width: 150,
},
];
const data = [];
for (let i = 0; i < dataTotalSize; i++) {
let age = 40 + (Math.random() > 0.5 ? 1 : -1) * Math.ceil(i / 3);
let name = `Edward King ${i}`;
data.push({
key: '' + i,
name,
age,
address: `London, Park Lane no. ${i} Lake Park`,
description: `My name is ${name}, I am ${age} years old, living in New York No. ${i + 1} Lake Park.`,
});
}
this.data = data;
this.mergeColumns = (column, columns, keys = ['dataIndex']) => {
columns = [...columns];
columns.forEach((curColumn, index) => {
let isTarget = !!(keys && keys.length);
for (let key of keys) {
if (column[key] !== curColumn[key]) {
isTarget = false;
break;
}
}
if (isTarget) {
columns[index] = { ...curColumn, ...column };
}
});
return columns;
};
this.filterData = (filters, dataSource) => {
dataSource = [...dataSource];
filters.forEach(filter => {
let filteredValue = filter.filteredValue;
let dataIndex = filter.dataIndex;
if (Array.isArray(filteredValue) && filteredValue.length && dataIndex) {
dataSource = dataSource.filter(
data => filteredValue.filter(value => String(data[dataIndex]).indexOf(value) > -1).length
);
}
});
return dataSource;
};
this.getSelfSorterColumn = columns => {
columns = columns || this.state.columns;
return columns.filter(column => !!column.sorter)[0];
};
this.getSelfFilterColumns = columns => {
columns = columns || this.state.columns;
return columns.filter(column => Array.isArray(column.filteredValue) && column.filteredValue.length);
};
this.sortData = (sortObj, dataSource) => {
let { sorter, sortOrder, dataIndex } = sortObj;
if (sorter && sortOrder && typeof sorter !== 'function') {
sorter = (a, b) => (a[dataIndex] > b[dataIndex] ? 1 : -1);
}
if (typeof sorter === 'function') {
dataSource = [...dataSource].sort(sorter);
if (sortOrder === 'descend') {
dataSource = dataSource.reverse();
}
}
return dataSource;
};
this.fetchData = (currentPage = 1, sorter = {}, filters = []) => {
// console.log(`FetchData currentPage: `, currentPage);
let pagination = { ...this.state.pagination, currentPage };
return new Promise((res, rej) => {
setTimeout(() => {
let data = [...this.data];
data = this.sortData(sorter, data);
data = this.filterData(filters, data);
let dataSource = data.slice(
(currentPage - 1) * pagination.pageSize,
currentPage * pagination.pageSize
);
pagination.total = data.length;
res({
dataSource,
pagination,
sorter,
filters,
});
}, 1500);
});
};
this.setPage = (currentPage, sorter, filters) => {
if (this.state.loading) {
return;
}
if (typeof currentPage !== 'number') {
currentPage = (this.state.pagination && this.state.pagination.currentPage) || 1;
}
sorter = sorter || this.getSelfSorterColumn();
filters = filters || this.getSelfFilterColumns();
this.setState({ loading: true });
this.fetchData(currentPage, sorter, filters)
.then(({ dataSource, pagination, sorter, filters }) => {
let columns = [...this.state.columns];
columns = this.mergeColumns(sorter, columns);
for (let filterObj of filters) {
columns = this.mergeColumns(filterObj, columns);
}
this.setState({
loading: false,
pagination,
dataSource,
columns,
});
})
.catch(err => {
console.error(err);
this.setState({ loading: false });
});
};
this.toggleFixHeader = checked => {
let scroll = { ...this.state.scroll };
if (checked) {
scroll.y = 300;
} else {
scroll.y = null;
}
this.setState({ scroll });
};
this.toggleFixColumns = checked => {
let columns = [...this.state.columns];
let scroll = { ...this.state.scroll };
let expandCellFixed = this.state.expandCellFixed;
let rowSelection = this.state.rowSelection;
if (checked) {
columns[0].fixed = true;
if (rowSelection) {
rowSelection = { ...rowSelection, fixed: true };
}
if (columns.length > 1) {
columns[columns.length - 1].fixed = 'right';
}
scroll.x = '150%';
expandCellFixed = true;
} else {
columns.forEach(column => {
column.fixed = false;
});
scroll.x = null;
expandCellFixed = false;
if (rowSelection) {
rowSelection = { ...rowSelection, fixed: false };
}
}
this.setState({
rowSelection,
expandCellFixed,
columns,
scroll,
});
};
this.toggleRowSelection = checked => {
let rowSelection = this.state.rowSelection;
// const anyColumnFixed = this.state.columns.some(column => !!column.fixed);
if (checked) {
rowSelection = {
width: 48,
fixed: true,
onChange: (selectedRowKeys, selectedRows) =>
console.log(
'Selection changed, selectedRowKeys: ',
selectedRowKeys,
'selectedRows: ',
selectedRows
),
};
} else {
rowSelection = null;
}
this.setState({ rowSelection });
};
this.toggleLoading = checked => {
let loading = this.state.loading;
if (checked) {
loading = true;
} else {
loading = false;
}
this.setState({ loading });
};
this.toggleExpandedRowRender = checked => {
let expandedRowRender = this.state.expandedRowRender;
if (checked) {
expandedRowRender = record => {
return {
children:
);
}
render(Demo);
```
### colSpan and rowSpan
- In addition to merging the headers by writing children, you can merge the headers by setting column.colSpan.
- Table supports row/column merging. When the cell attribute colSpan or rowSpan in render is set to 0, the set table will not be rendered.
```tsx
type Render = (text: string, record: Object, index: number, options?: RenderOptions) => {
children: React.ReactNode;
props: {
colSpan?: number,
rowSpan?: number,
},
[x: string]: any;
}
interface RenderOptions {
expandIcon?: React.ReactNode;
}
```
```jsx live=true noInline=true dir="column"
import React, { useMemo } from 'react';
import { Table } from '@douyinfe/semi-ui';
const App = () => {
const renderContent = (value, row, index) => {
const obj = {
children: value,
props: {},
};
if (index === 4) {
obj.props.colSpan = 0;
}
return obj;
};
const columns = [
{
title: 'Name',
dataIndex: 'name',
render: (text, row, index) => {
if (index < 4) {
return {text};
}
return {
children: {text},
props: {
colSpan: 5,
},
};
},
},
{
title: 'Age',
dataIndex: 'age',
render: renderContent,
},
{
title: 'Home phone',
colSpan: 2,
dataIndex: 'tel',
render: (value, row, index) => {
const obj = {
children: value,
props: {},
};
if (index === 2) {
obj.props.rowSpan = 2;
}
// These two are merged into above cell
if (index === 3) {
obj.props.rowSpan = 0;
}
if (index === 4) {
obj.props.colSpan = 0;
}
return obj;
},
},
{
title: 'Phone',
colSpan: 0,
dataIndex: 'phone',
render: renderContent,
},
{
title: 'Address',
dataIndex: 'address',
render: renderContent,
},
];
const data = [
{
key: '1',
name: 'John Brown',
age: 32,
tel: '0571-22098909',
phone: 18889898989,
address: 'New York No. 1 Lake Park',
},
{
key: '2',
name: 'Jim Green',
tel: '0571-22098333',
phone: 18889898888,
age: 42,
address: 'London No. 1 Lake Park',
},
{
key: '3',
name: 'Joe Black',
age: 32,
tel: '0575-22098909',
phone: 18900010002,
address: 'Sidney No. 1 Lake Park',
},
{
key: '4',
name: 'Jim Red',
age: 18,
tel: '0575-22098909',
phone: 18900010002,
address: 'London No. 2 Lake Park',
},
{
key: '5',
name: 'Jake White',
age: 18,
tel: '0575-22098909',
phone: 18900010002,
address: 'Dublin No. 2 Lake Park',
},
];
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?: 'foward' \| '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
{
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. | string | |
| 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 | (selectedRowKeys: number[]\|string[], selectedRows: RecordType[]) => void | | |
| onSelect | The user manually selects / unselects the callback of a line | (record: RecordType, selected: boolean, selectedRows: RecordType[], nativeEvent: MouseEvent) => void | | |
| onSelectAll | User manually selects / unselects callbacks for all rows | (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 |
## 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:
```jsx
// ...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.
See more Table FAQ and demos, please click Table FAQ