rc-tree vs react-treebeard vs react-checkbox-tree vs react-sortable-tree
React Tree View Libraries
rc-treereact-treebeardreact-checkbox-treereact-sortable-treeSimilar Packages:
React Tree View Libraries

These libraries provide various implementations of tree structures in React applications, allowing developers to create interactive and hierarchical data representations. They cater to different use cases, from simple checkbox trees to sortable trees, each with unique features and functionalities that enhance user experience and data manipulation capabilities.

Npm Package Weekly Downloads Trend
3 Years
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
rc-tree2,434,8421,264359 kB16610 months agoMIT
react-treebeard111,3921,690-726 years agoMIT
react-checkbox-tree106,684727233 kB88-MIT
react-sortable-tree60,2564,977-3475 years agoMIT
Feature Comparison: rc-tree vs react-treebeard vs react-checkbox-tree vs react-sortable-tree

Customization

  • rc-tree:

    rc-tree offers extensive customization options, allowing developers to define their own node rendering, styles, and behaviors. This flexibility makes it suitable for complex applications that require tailored tree structures.

  • react-treebeard:

    react-treebeard is designed for simplicity and ease of use, offering basic customization options for node rendering. It is less flexible than rc-tree but is quick to implement for straightforward tree structures.

  • react-checkbox-tree:

    react-checkbox-tree provides limited customization primarily focused on checkbox functionality. While you can style the tree, the core behavior is centered around selection, making it less flexible than rc-tree.

  • react-sortable-tree:

    react-sortable-tree allows for customization of node rendering and drag-and-drop behavior, but it is primarily designed for reordering items. Customization is available but may require more effort compared to rc-tree.

User Interaction

  • rc-tree:

    rc-tree supports various user interactions, including drag-and-drop, selection, and context menus. This makes it suitable for applications that require rich user engagement with the tree structure.

  • react-treebeard:

    react-treebeard provides basic interactions like expanding and collapsing nodes, making it user-friendly for simple navigation through hierarchical data without complex interactions.

  • react-checkbox-tree:

    react-checkbox-tree focuses on checkbox interactions, allowing users to select multiple nodes easily. It is ideal for scenarios where selection is the primary interaction, such as filtering or categorizing items.

  • react-sortable-tree:

    react-sortable-tree emphasizes drag-and-drop functionality, enabling users to reorder nodes intuitively. This interaction model is perfect for applications where the organization of items is user-driven.

Performance

  • rc-tree:

    rc-tree is optimized for performance, supporting features like virtual scrolling and lazy loading, which are essential for handling large datasets efficiently without compromising user experience.

  • react-treebeard:

    react-treebeard is lightweight and performs well for small to medium-sized trees. However, it may not handle very large datasets as efficiently as rc-tree due to its simpler architecture.

  • react-checkbox-tree:

    react-checkbox-tree performs well for moderate datasets, but may face performance issues with very large trees due to its reliance on rendering all nodes at once. It's best suited for smaller to medium-sized trees.

  • react-sortable-tree:

    react-sortable-tree is designed for performance with drag-and-drop functionality, but performance can degrade with very large trees if not implemented with optimizations like memoization.

Learning Curve

  • rc-tree:

    rc-tree has a moderate learning curve due to its extensive features and customization options. Developers may need to invest time to understand its API and capabilities fully.

  • react-treebeard:

    react-treebeard is easy to learn and implement, making it suitable for developers looking for a simple tree structure without complex interactions or configurations.

  • react-checkbox-tree:

    react-checkbox-tree is relatively easy to learn, especially for developers familiar with checkbox inputs. Its straightforward API allows for quick implementation in projects requiring checkbox functionality.

  • react-sortable-tree:

    react-sortable-tree has a moderate learning curve, particularly for implementing drag-and-drop features. Developers will need to understand how to manage state effectively for reordering items.

Use Cases

  • rc-tree:

    rc-tree is ideal for applications that require complex tree structures with features like drag-and-drop, lazy loading, and dynamic updates, such as file explorers or hierarchical data management systems.

  • react-treebeard:

    react-treebeard is suitable for applications needing a basic tree view for navigation or simple data representation, such as displaying organizational structures or simple category trees.

  • react-checkbox-tree:

    react-checkbox-tree is best for scenarios where users need to select multiple items from a hierarchical structure, such as category selection in e-commerce or filtering options in search interfaces.

  • react-sortable-tree:

    react-sortable-tree is perfect for applications that require user-driven reordering of items, such as task management apps or content organization tools.

How to Choose: rc-tree vs react-treebeard vs react-checkbox-tree vs react-sortable-tree
  • rc-tree:

    Choose rc-tree if you need a flexible and customizable tree component that supports various features like drag-and-drop, lazy loading, and dynamic rendering. It's suitable for applications that require extensive customization and performance optimization.

  • react-treebeard:

    Use react-treebeard if you want a simple and lightweight tree view with a focus on performance and ease of use. It's suitable for applications that require a basic tree structure without complex interactions, making it easy to implement and customize.

  • react-checkbox-tree:

    Select react-checkbox-tree if your application requires a straightforward checkbox tree structure, where users can select multiple items in a hierarchical format. It's ideal for scenarios where user selection is crucial, such as file management or category selection.

  • react-sortable-tree:

    Opt for react-sortable-tree if you need a tree structure that allows users to reorder items through drag-and-drop functionality. This package is perfect for applications that require user-driven organization of hierarchical data, such as task lists or content management systems.

README for rc-tree

rc-tree

Tree component.

NPM version npm download build status Codecov bundle size dumi

Screenshots

Feature

  • Support all popular browsers, including Internet Explorer 9 and above.

Example

http://localhost:9001/

online example: https://tree.react-component.now.sh/

Install

rc-tree

Usage

Note: import "rc-tree/assets/index.css"

see examples

API

Tree props

namedescriptiontypedefault
autoExpandParentwhether auto expand parent treeNodesboolfalse
checkablewhether support checkedbool/React Nodefalse
checkedKeysControlled checked treeNodes(After setting, defaultCheckedKeys will not work). Note: parent and children nodes are associated, if the parent node's key exists, it all children node will be checked, and vice versa. When set checkable and checkStrictly, it should be an object, which contains checked array and halfChecked array.String[]/{checked:Array,halfChecked:Array}[]
checkStrictlycheck node precisely, parent and children nodes are not associatedboolfalse
classNameadditional css class of root dom nodeString''
defaultCheckedKeysdefault checked treeNodesString[][]
defaultExpandedKeysexpand specific treeNodesString[][]
defaultExpandAllexpand all treeNodesboolfalse
defaultExpandParentauto expand parent treeNodes when initbooltrue
defaultSelectedKeysdefault selected treeNodesString[][]
disabledwhether disabled the treeboolfalse
draggablewhether can drag treeNode. (drag events are not supported in Internet Explorer 8 and earlier versions or Safari 5.1 and earlier versions.)bool | ({ node }) => booleanfalse
expandedKeysControlled expand specific treeNodesString[]-
filterTreeNodefilter some treeNodes as you need. it should return truefunction(node)-
iconcustomize icon. When you pass component, whose render will receive full TreeNode props as component propselement/Function(props)-
loadedKeysMark node is loaded when loadData is trueString[]-
loadDataload data asynchronously and the return value should be a promisefunction(node)-
multiplewhether multiple selectboolfalse
prefixClsprefix classString'rc-tree'
selectablewhether can be selectedbooltrue
selectedKeysControlled selected treeNodes(After setting, defaultSelectedKeys will not work)String[][]
showIconwhether show iconbooltrue
showLinewhether show lineboolfalse
treeDatatreeNodes data Array, if set it then you need not to construct children TreeNode. (value should be unique across the whole array)array<{key,title,children, [disabled, selectable]}>-
onCheckclick the treeNode/checkbox to firefunction(checkedKeys, e:{checked: bool, checkedNodes, node, event, nativeEvent})-
onExpandfire on treeNode expand or notfunction(expandedKeys, {expanded: bool, node, nativeEvent})-
onDragEndit execs when fire the tree's dragend eventfunction({event,node})-
onDragEnterit execs when fire the tree's dragenter eventfunction({event,node,expandedKeys})-
onDragLeaveit execs when fire the tree's dragleave eventfunction({event,node})-
onDragOverit execs when fire the tree's dragover eventfunction({event,node})-
onDragStartit execs when fire the tree's dragstart eventfunction({event,node})-
onDropit execs when fire the tree's drop eventfunction({event, node, dragNode, dragNodesKeys})-
onLoadTrigger when a node is loaded. If you set the loadedKeys, you must handle onLoad to avoid infinity loopfunction(loadedKeys, {event, node})-
onMouseEntercall when mouse enter a treeNodefunction({event,node})-
onMouseLeavecall when mouse leave a treeNodefunction({event,node})-
onRightClickselect current treeNode and show customized contextmenufunction({event,node})-
onSelectclick the treeNode to firefunction(selectedKeys, e:{selected: bool, selectedNodes, node, event, nativeEvent})-
switcherIconspecific the switcher icon.ReactNode / (props: TreeNodeAttribute) => ReactNode-
virtualDisable virtual scroll when falseboolean-
allowDropWhether to allow drop on node({ dragNode, dropNode, dropPosition }) => boolean-
dropIndicatorRenderThe indicator to render when dragging({ dropPosition, dropLevelOffset, indent: number, prefixCls }) => ReactNode-
directionDisplay direction of the tree, it may affect dragging behaviorltr | rtl-
expandActionTree open logic, optional: false | click | doubleClickstring | booleanclick

TreeNode props

note: if you have a lot of TreeNode, like more than 1000,
make the parent node is collapsed by default, will obvious effect, very fast.
Because the children hide TreeNode will not insert into dom.

namedescriptiontypedefault
classNameadditional class to treeNodeString''
checkablecontrol node checkable if Tree is checkableboolfalse
styleset style to treeNodeObject''
disabledwhether disabled the treeNodeboolfalse
disableCheckboxwhether disable the treeNode' checkboxboolfalse
titletree/subTree's titleString/element/((data: DataNode) => React.ReactNode)'---'
keyit's used with tree props's (default)ExpandedKeys / (default)CheckedKeys / (default)SelectedKeys. you'd better to set it, and it must be unique in the tree's all treeNodesStringtreeNode's position
isLeafwhether it's leaf nodeboolfalse
iconcustomize icon. When you pass component, whose render will receive full TreeNode props as component propselement/Function(props)-
switcherIconspecific the switcher icon.ReactNode / (props: TreeNodeAttribute) => ReactNode-

Note

The number of treeNodes can be very large, but when enable checkable, it will spend more computing time, so we cached some calculations(e.g. this.treeNodesStates), to avoid double computing. But, this bring some restrictions, when you async load treeNodes, you should render tree like this {this.state.treeData.length ? <Tree ...>{this.state.treeData.map(t => <TreeNode ... />)}</Tree> : 'loading tree'}

Development

npm install
npm start

Test Case

http://localhost:8018/tests/runner.html?coverage

Coverage

http://localhost:8018/node_modules/rc-server/node_modules/node-jscover/lib/front-end/jscoverage.html?w=http://localhost:8018/tests/runner.html?coverage

License

rc-tree is released under the MIT license.

Other tree views