Transfer

Double column transfer choice box.

When To Use#

  • It is a select control essentially which can be use for selecting multiple items.

  • Transfer can display more information for items and take up more space.

Transfer the elements between two columns in an intuitive and efficient way.

One or more elements can be selected from either column, one click on the proper direction button, and the transfer is done. The left column is considered the source and the right column is considered the target. As you can see in the API description, these names are reflected in.

Examples

11 itemsSource
  • content1
  • content2
  • content3
  • content4
  • content5
  • content6
  • content7
  • content8
  • content9
  • content10
  • content11
9 itemsTarget
  • content12
  • content13
  • content14
  • content15
  • content16
  • content17
  • content18
  • content19
  • content20

The most basic usage of Transfer involves providing the source data and target keys arrays, plus the rendering and some callback functions.

expand codeexpand code
import React, { useState } from 'react';
import { Transfer } from 'antd';

const mockData = [];
for (let i = 0; i < 20; i++) {
  mockData.push({
    key: i.toString(),
    title: `content${i + 1}`,
    description: `description of content${i + 1}`,
  });
}

const initialTargetKeys = mockData.filter(item => +item.key > 10).map(item => item.key);

const App = () => {
  const [targetKeys, setTargetKeys] = useState(initialTargetKeys);
  const [selectedKeys, setSelectedKeys] = useState([]);
  const onChange = (nextTargetKeys, direction, moveKeys) => {
    console.log('targetKeys:', nextTargetKeys);
    console.log('direction:', direction);
    console.log('moveKeys:', moveKeys);
    setTargetKeys(nextTargetKeys);
  };

  const onSelectChange = (sourceSelectedKeys, targetSelectedKeys) => {
    console.log('sourceSelectedKeys:', sourceSelectedKeys);
    console.log('targetSelectedKeys:', targetSelectedKeys);
    setSelectedKeys([...sourceSelectedKeys, ...targetSelectedKeys]);
  };

  const onScroll = (direction, e) => {
    console.log('direction:', direction);
    console.log('target:', e.target);
  };

  return (
    <Transfer
      dataSource={mockData}
      titles={['Source', 'Target']}
      targetKeys={targetKeys}
      selectedKeys={selectedKeys}
      onChange={onChange}
      onSelectChange={onSelectChange}
      onScroll={onScroll}
      render={item => item.title}
    />
  );
};

ReactDOM.render(<App />, mountNode);
14 itemsSource
  • content1
  • content2
  • content4
  • content5
  • content7
  • content8
  • content10
  • content11
  • content13
  • content14
  • content16
  • content17
  • content19
  • content20
6 itemsTarget
  • content3
  • content6
  • content9
  • content12
  • content15
  • content18

Use oneWay to makes Transfer to one way style.

expand codeexpand code
import { Transfer, Switch } from 'antd';

const mockData = [];
for (let i = 0; i < 20; i++) {
  mockData.push({
    key: i.toString(),
    title: `content${i + 1}`,
    description: `description of content${i + 1}`,
    disabled: i % 3 < 1,
  });
}

const oriTargetKeys = mockData.filter(item => +item.key % 3 > 1).map(item => item.key);

class App extends React.Component {
  state = {
    targetKeys: oriTargetKeys,
    selectedKeys: [],
    disabled: false,
  };

  handleChange = (nextTargetKeys, direction, moveKeys) => {
    this.setState({ targetKeys: nextTargetKeys });

    console.log('targetKeys: ', nextTargetKeys);
    console.log('direction: ', direction);
    console.log('moveKeys: ', moveKeys);
  };

  handleSelectChange = (sourceSelectedKeys, targetSelectedKeys) => {
    this.setState({ selectedKeys: [...sourceSelectedKeys, ...targetSelectedKeys] });

    console.log('sourceSelectedKeys: ', sourceSelectedKeys);
    console.log('targetSelectedKeys: ', targetSelectedKeys);
  };

  handleScroll = (direction, e) => {
    console.log('direction:', direction);
    console.log('target:', e.target);
  };

  handleDisable = disabled => {
    this.setState({ disabled });
  };

  render() {
    const { targetKeys, selectedKeys, disabled } = this.state;
    return (
      <>
        <Transfer
          dataSource={mockData}
          titles={['Source', 'Target']}
          targetKeys={targetKeys}
          selectedKeys={selectedKeys}
          onChange={this.handleChange}
          onSelectChange={this.handleSelectChange}
          onScroll={this.handleScroll}
          render={item => item.title}
          disabled={disabled}
          oneWay
          style={{ marginBottom: 16 }}
        />
        <Switch
          unCheckedChildren="disabled"
          checkedChildren="disabled"
          checked={disabled}
          onChange={this.handleDisable}
        />
      </>
    );
  }
}

ReactDOM.render(<App />, mountNode);

Advanced Usage of Transfer.

You can customize the labels of the transfer buttons, the width and height of the columns, and what should be displayed in the footer.

expand codeexpand code
import { Transfer, Button } from 'antd';

class App extends React.Component {
  state = {
    mockData: [],
    targetKeys: [],
  };

  componentDidMount() {
    this.getMock();
  }

  getMock = () => {
    const targetKeys = [];
    const mockData = [];
    for (let i = 0; i < 20; i++) {
      const data = {
        key: i.toString(),
        title: `content${i + 1}`,
        description: `description of content${i + 1}`,
        chosen: Math.random() * 2 > 1,
      };
      if (data.chosen) {
        targetKeys.push(data.key);
      }
      mockData.push(data);
    }
    this.setState({ mockData, targetKeys });
  };

  handleChange = targetKeys => {
    this.setState({ targetKeys });
  };

  renderFooter = (props, { direction }) => {
    if (direction === 'left') {
      return (
        <Button size="small" style={{ float: 'left', margin: 5 }} onClick={this.getMock}>
          Left button reload
        </Button>
      );
    }
    return (
      <Button size="small" style={{ float: 'right', margin: 5 }} onClick={this.getMock}>
        Right button reload
      </Button>
    );
  };

  render() {
    return (
      <Transfer
        dataSource={this.state.mockData}
        showSearch
        listStyle={{
          width: 250,
          height: 300,
        }}
        operations={['to right', 'to left']}
        targetKeys={this.state.targetKeys}
        onChange={this.handleChange}
        render={item => `${item.title}-${item.description}`}
        footer={this.renderFooter}
      />
    );
  }
}

ReactDOM.render(<App />, mountNode);
0 item
No Data
0 item
No Data

Custom each Transfer Item, and in this way you can render a complex datasource.

expand codeexpand code
import { Transfer } from 'antd';

class App extends React.Component {
  state = {
    mockData: [],
    targetKeys: [],
  };

  componentDidMount() {
    this.getMock();
  }

  getMock = () => {
    const targetKeys = [];
    const mockData = [];
    for (let i = 0; i < 20; i++) {
      const data = {
        key: i.toString(),
        title: `content${i + 1}`,
        description: `description of content${i + 1}`,
        chosen: Math.random() * 2 > 1,
      };
      if (data.chosen) {
        targetKeys.push(data.key);
      }
      mockData.push(data);
    }
    this.setState({ mockData, targetKeys });
  };

  handleChange = (targetKeys, direction, moveKeys) => {
    console.log(targetKeys, direction, moveKeys);
    this.setState({ targetKeys });
  };

  renderItem = item => {
    const customLabel = (
      <span className="custom-item">
        {item.title} - {item.description}
      </span>
    );

    return {
      label: customLabel, // for displayed item
      value: item.title, // for title and filter matching
    };
  };

  render() {
    return (
      <Transfer
        dataSource={this.state.mockData}
        listStyle={{
          width: 300,
          height: 300,
        }}
        targetKeys={this.state.targetKeys}
        onChange={this.handleChange}
        render={this.renderItem}
      />
    );
  }
}

ReactDOM.render(<App />, mountNode);
0 item
No Data
0 item
No Data

large count of items with pagination.

expand codeexpand code
import { Transfer, Switch } from 'antd';

const App = () => {
  const [oneWay, setOneWay] = React.useState(false);
  const [mockData, setMockData] = React.useState([]);
  const [targetKeys, setTargetKeys] = React.useState([]);

  React.useEffect(() => {
    const newTargetKeys = [];
    const newMockData = [];
    for (let i = 0; i < 2000; i++) {
      const data = {
        key: i.toString(),
        title: `content${i + 1}`,
        description: `description of content${i + 1}`,
        chosen: Math.random() * 2 > 1,
      };
      if (data.chosen) {
        newTargetKeys.push(data.key);
      }
      newMockData.push(data);
    }

    setTargetKeys(newTargetKeys);
    setMockData(newMockData);
  }, []);

  const onChange = (newTargetKeys, direction, moveKeys) => {
    console.log(newTargetKeys, direction, moveKeys);
    setTargetKeys(newTargetKeys);
  };

  return (
    <>
      <Transfer
        dataSource={mockData}
        targetKeys={targetKeys}
        onChange={onChange}
        render={item => item.title}
        oneWay={oneWay}
        pagination
      />
      <br />
      <Switch
        unCheckedChildren="one way"
        checkedChildren="one way"
        checked={oneWay}
        onChange={setOneWay}
      />
    </>
  );
};

ReactDOM.render(<App />, mountNode);
14 items
NameTagDescription
content1catdescription of content1
content2dogdescription of content2
content4catdescription of content4
content5dogdescription of content5
content7catdescription of content7
content8dogdescription of content8
content10catdescription of content10
content11dogdescription of content11
content13catdescription of content13
content14dogdescription of content14
  • Rows per page
    10
  • Showing 1-10 of 14
1
of 2 page
  • 6 items
    Name
    content3
    content6
    content9
    content12
    content15
    content18

    Customize render list with Table component.

    expand codeexpand code
    import { Transfer, Switch, Table, Tag } from 'antd';
    import difference from 'lodash/difference';
    
    // Customize Table Transfer
    const TableTransfer = ({ leftColumns, rightColumns, ...restProps }) => (
      <Transfer {...restProps}>
        {({
          direction,
          filteredItems,
          onItemSelectAll,
          onItemSelect,
          selectedKeys: listSelectedKeys,
          disabled: listDisabled,
        }) => {
          const columns = direction === 'left' ? leftColumns : rightColumns;
    
          const rowSelection = {
            getCheckboxProps: item => ({ disabled: listDisabled || item.disabled }),
            onSelectAll(selected, selectedRows) {
              const treeSelectedKeys = selectedRows
                .filter(item => !item.disabled)
                .map(({ key }) => key);
              const diffKeys = selected
                ? difference(treeSelectedKeys, listSelectedKeys)
                : difference(listSelectedKeys, treeSelectedKeys);
              onItemSelectAll(diffKeys, selected);
            },
            onSelect({ key }, selected) {
              onItemSelect(key, selected);
            },
            selectedRowKeys: listSelectedKeys,
          };
    
          return (
            <Table
              rowSelection={rowSelection}
              columns={columns}
              dataSource={filteredItems}
              size="small"
              style={{ pointerEvents: listDisabled ? 'none' : null }}
              onRow={({ key, disabled: itemDisabled }) => ({
                onClick: () => {
                  if (itemDisabled || listDisabled) return;
                  onItemSelect(key, !listSelectedKeys.includes(key));
                },
              })}
            />
          );
        }}
      </Transfer>
    );
    
    const mockTags = ['cat', 'dog', 'bird'];
    
    const mockData = [];
    for (let i = 0; i < 20; i++) {
      mockData.push({
        key: i.toString(),
        title: `content${i + 1}`,
        description: `description of content${i + 1}`,
        disabled: i % 4 === 0,
        tag: mockTags[i % 3],
      });
    }
    
    const originTargetKeys = mockData.filter(item => +item.key % 3 > 1).map(item => item.key);
    
    const leftTableColumns = [
      {
        dataIndex: 'title',
        title: 'Name',
      },
      {
        dataIndex: 'tag',
        title: 'Tag',
        render: tag => <Tag>{tag}</Tag>,
      },
      {
        dataIndex: 'description',
        title: 'Description',
      },
    ];
    const rightTableColumns = [
      {
        dataIndex: 'title',
        title: 'Name',
      },
    ];
    
    class App extends React.Component {
      state = {
        targetKeys: originTargetKeys,
        disabled: false,
        showSearch: false,
      };
    
      onChange = nextTargetKeys => {
        this.setState({ targetKeys: nextTargetKeys });
      };
    
      triggerDisable = disabled => {
        this.setState({ disabled });
      };
    
      triggerShowSearch = showSearch => {
        this.setState({ showSearch });
      };
    
      render() {
        const { targetKeys, disabled, showSearch } = this.state;
        return (
          <>
            <TableTransfer
              dataSource={mockData}
              targetKeys={targetKeys}
              disabled={disabled}
              showSearch={showSearch}
              onChange={this.onChange}
              filterOption={(inputValue, item) =>
                item.title.indexOf(inputValue) !== -1 || item.tag.indexOf(inputValue) !== -1
              }
              leftColumns={leftTableColumns}
              rightColumns={rightTableColumns}
            />
            <Switch
              unCheckedChildren="disabled"
              checkedChildren="disabled"
              checked={disabled}
              onChange={this.triggerDisable}
              style={{ marginTop: 16 }}
            />
            <Switch
              unCheckedChildren="showSearch"
              checkedChildren="showSearch"
              checked={showSearch}
              onChange={this.triggerShowSearch}
              style={{ marginTop: 16 }}
            />
          </>
        );
      }
    }
    
    ReactDOM.render(<App />, mountNode);
    #components-transfer-demo-table-transfer .ant-table td {
      background: transparent;
    }
    5 items
    0-0
    0-1
    0-1-0
    0-1-1
    0-3
    0 item
    No Data

    Customize render list with Tree component.

    expand codeexpand code
    import React, { useState } from 'react';
    import { Transfer, Tree } from 'antd';
    
    // Customize Table Transfer
    const isChecked = (selectedKeys, eventKey) => selectedKeys.indexOf(eventKey) !== -1;
    
    const generateTree = (treeNodes = [], checkedKeys = []) =>
      treeNodes.map(({ children, ...props }) => ({
        ...props,
        disabled: checkedKeys.includes(props.key),
        children: generateTree(children, checkedKeys),
      }));
    
    const TreeTransfer = ({ dataSource, targetKeys, ...restProps }) => {
      const transferDataSource = [];
      function flatten(list = []) {
        list.forEach(item => {
          transferDataSource.push(item);
          flatten(item.children);
        });
      }
      flatten(dataSource);
    
      return (
        <Transfer
          {...restProps}
          targetKeys={targetKeys}
          dataSource={transferDataSource}
          className="tree-transfer"
          render={item => item.title}
          showSelectAll={false}
        >
          {({ direction, onItemSelect, selectedKeys }) => {
            if (direction === 'left') {
              const checkedKeys = [...selectedKeys, ...targetKeys];
              return (
                <Tree
                  blockNode
                  checkable
                  checkStrictly
                  defaultExpandAll
                  checkedKeys={checkedKeys}
                  treeData={generateTree(dataSource, targetKeys)}
                  onCheck={(_, { node: { key } }) => {
                    onItemSelect(key, !isChecked(checkedKeys, key));
                  }}
                  onSelect={(_, { node: { key } }) => {
                    onItemSelect(key, !isChecked(checkedKeys, key));
                  }}
                />
              );
            }
          }}
        </Transfer>
      );
    };
    
    const treeData = [
      { key: '0-0', title: '0-0' },
      {
        key: '0-1',
        title: '0-1',
        children: [
          { key: '0-1-0', title: '0-1-0' },
          { key: '0-1-1', title: '0-1-1' },
        ],
      },
      { key: '0-2', title: '0-3' },
    ];
    
    const App = () => {
      const [targetKeys, setTargetKeys] = useState([]);
      const onChange = keys => {
        setTargetKeys(keys);
      };
      return <TreeTransfer dataSource={treeData} targetKeys={targetKeys} onChange={onChange} />;
    };
    
    ReactDOM.render(<App />, mountNode);

    API#

    PropertyDescriptionTypeDefaultVersion
    dataSourceUsed for setting the source data. The elements that are part of this array will be present the left column. Except the elements whose keys are included in targetKeys propRecordType extends TransferItem = TransferItem[][]
    disabledWhether disabled transferbooleanfalse
    filterOptionA function to determine whether an item should show in search result list(inputValue, option): boolean-
    footerA function used for rendering the footer(props, { direction }) => ReactNode-direction: 4.17.0
    listStyleA custom CSS style used for rendering the transfer columnsobject | ({direction: left | right}) => object-
    localeThe i18n text including filter, empty text, item unit, etc{ itemUnit: string; itemsUnit: string; searchPlaceholder: string; notFoundContent: ReactNode | ReactNode[]; }{ itemUnit: item, itemsUnit: items, notFoundContent: The list is empty, searchPlaceholder: Search here }
    oneWayDisplay as single direction stylebooleanfalse4.3.0
    operationsA set of operations that are sorted from top to bottomstring[][>, <]
    operationStyleA custom CSS style used for rendering the operations columnobject-
    paginationUse pagination. Not work in render propsboolean | { pageSize: number }false4.3.0
    renderThe function to generate the item shown on a column. Based on an record (element of the dataSource array), this function should return a React element which is generated from that record. Also, it can return a plain object with value and label, label is a React element and value is for title(record) => ReactNode-
    selectAllLabelsA set of customized labels for select all checkboxs on the header(ReactNode | (info: { selectedCount: number, totalCount: number }) => ReactNode)[]-
    selectedKeysA set of keys of selected itemsstring[][]
    showSearchIf included, a search box is shown on each columnbooleanfalse
    showSelectAllShow select all checkbox on the headerbooleantrue
    targetKeysA set of keys of elements that are listed on the right columnstring[][]
    titlesA set of titles that are sorted from left to rightReactNode[]-
    onChangeA callback function that is executed when the transfer between columns is complete(targetKeys, direction, moveKeys): void-
    onScrollA callback function which is executed when scroll options list(direction, event): void-
    onSearchA callback function which is executed when search field are changed(direction: left | right, value: string): void-
    onSelectChangeA callback function which is executed when selected items are changed(sourceSelectedKeys, targetSelectedKeys): void-

    Render Props#

    Transfer accept children to customize render list, using follow props:

    PropertyDescriptionTypeVersion
    directionList render directionleft | right
    disabledDisable list or notboolean
    filteredItemsFiltered itemsRecordType[]
    selectedKeysSelected itemsstring[]
    onItemSelectSelect item(key: string, selected: boolean)
    onItemSelectAllSelect a group of items(keys: string[], selected: boolean)

    example#

    <Transfer {...props}>{listProps => <YourComponent {...listProps} />}</Transfer>

    Warning#

    According the standard of React, the key should always be supplied directly to the elements in the array. In Transfer, the keys should be set on the elements included in dataSource array. By default, key property is used as an unique identifier.

    If there's no key in your data, you should use rowKey to specify the key that will be used for uniquely identify each element.

    // eg. your primary key is `uid`
    return <Transfer rowKey={record => record.uid} />;

    FAQ#

    How to support fetch and present data from a remote server in Transfer column.#

    In order to keep the page number synchronized, you can disable columns you checked without removing the option: https://codesandbox.io/s/objective-wing-6iqbx