react-virtualized
Advanced tools
Package description
The react-virtualized npm package provides efficient rendering of large lists and tabular data by only rendering the items that are currently visible within the viewport. This can significantly improve the performance of applications that need to display large amounts of data.
List
The List component allows you to render large lists of items efficiently. It only renders the rows that are currently visible to the user, based on the scroll position.
{"import { List } from 'react-virtualized';
function MyList({ list }) {
return (
<List
width={300}
height={300}
rowCount={list.length}
rowHeight={20}
rowRenderer={({ index, key, style }) => (
<div key={key} style={style}>
{list[index]}
</div>
)}
/>
);
}"}Table
The Table component is used for rendering large data sets in a tabular format. Similar to List, it only renders the rows that are visible in the viewport.
{"import { Column, Table } from 'react-virtualized';
function MyTable({ list }) {
return (
<Table
width={1000}
height={300}
headerHeight={20}
rowHeight={30}
rowCount={list.length}
rowGetter={({ index }) => list[index]}
>
<Column label='Name' dataKey='name' width={100} />
<Column label='Age' dataKey='age' width={200} />
</Table>
);
}"}Grid
The Grid component can render a virtualized grid of cells, which is useful for displaying data in a spreadsheet-like format. It renders only the cells that are currently in the viewport.
{"import { Grid } from 'react-virtualized';
function MyGrid({ columnCount, rowCount }) {
return (
<Grid
columnCount={columnCount}
columnWidth={100}
height={300}
rowCount={rowCount}
rowHeight={30}
width={300}
cellRenderer={({ columnIndex, key, rowIndex, style }) => (
<div key={key} style={style}>
{`R${rowIndex}, C${columnIndex}`}
</div>
)}
/>
);
}"}InfiniteLoader
The InfiniteLoader component works with List, Table, or Grid to load more items as the user scrolls. It's useful for implementing 'infinite scroll' features where more data is fetched as needed.
{"import { InfiniteLoader, List } from 'react-virtualized';
function MyInfiniteList({ list, loadMoreRows }) {
const isRowLoaded = ({ index }) => !!list[index];
return (
<InfiniteLoader
isRowLoaded={isRowLoaded}
loadMoreRows={loadMoreRows}
rowCount={list.length}
>
{({ onRowsRendered, registerChild }) => (
<List
ref={registerChild}
onRowsRendered={onRowsRendered}
width={300}
height={300}
rowCount={list.length}
rowHeight={20}
rowRenderer={({ index, key, style }) => (
<div key={key} style={style}>
{list[index]}
</div>
)}
/>
)}
</InfiniteLoader>
);
}"}React-window is a complete rewrite of react-virtualized by the same author. It offers similar functionality but with a smaller and faster core. It's designed to be more approachable and easier to use than react-virtualized.
React-infinite is another package for rendering large lists of elements within a scrolling container. It differs from react-virtualized in its API and the way it handles infinite loading, but it also aims to provide efficient rendering for large lists.
React-virtuoso is a virtual list component with a simple API that supports variable-sized items and sticky headers. It provides a different approach to virtualization compared to react-virtualized, focusing on simplicity and automatic handling of item heights.
React-list is a versatile infinite scroll React component. It offers several modes for rendering lists, including simple, variable, and uniform heights. It's a simpler alternative to react-virtualized with fewer features but can be easier to integrate in some cases.
Readme
React components for efficiently rendering large lists and tabular data. Check out the demo for some examples.
The following wonderful companies have sponsored react-virtualized:
Learn more about becoming a sponsor!
react-windowIf you're considering adding react-virtualized to a project, take a look at react-window as a possible lighter-weight alternative. Learn more about how the two libraries compare here.
Install react-virtualized using npm.
npm install react-virtualized --save
ES6, CommonJS, and UMD builds are available with each distribution. For example:
// Most of react-virtualized's styles are functional (eg position, size).
// Functional styles are applied directly to DOM elements.
// The Table component ships with a few presentational styles as well.
// They are optional, but if you want them you will need to also import the CSS file.
// This only needs to be done once; probably during your application's bootstrapping process.
import 'react-virtualized/styles.css';
// You can import any component you want as a named export from 'react-virtualized', eg
import {Column, Table} from 'react-virtualized';
// But if you only use a few react-virtualized components,
// And you're concerned about increasing your application's bundle size,
// You can directly import only the components you need, like so:
import AutoSizer from 'react-virtualized/dist/commonjs/AutoSizer';
import List from 'react-virtualized/dist/commonjs/List';
Note webpack 4 makes this optimization itself, see the documentation.
If the above syntax looks too cumbersome, or you import react-virtualized components from a lot of places, you can also configure a Webpack alias. For example:
// Partial webpack.config.js
{
alias: {
'react-virtualized/List': 'react-virtualized/dist/es/List',
},
...rest
}
Then you can just import like so:
import List from 'react-virtualized/List';
// Now you can use <List {...props} />
You can also use a global-friendly UMD build:
<link rel="stylesheet" href="path-to-react-virtualized/styles.css" />
<script src="path-to-react-virtualized/dist/umd/react-virtualized.js"></script>
Now you're ready to start using the components. You can learn more about which components react-virtualized has to offer below.
React Virtualized has very few dependencies and most are managed by NPM automatically.
However the following peer dependencies must be specified by your project in order to avoid version conflicts:
react,
react-dom.
NPM will not automatically install these for you but it will show you a warning message with instructions on how to install them.
By default all react-virtualized components use shallowCompare to avoid re-rendering unless props or state has changed.
This occasionally confuses users when a collection's data changes (eg ['a','b','c'] => ['d','e','f']) but props do not (eg array.length).
The solution to this is to let react-virtualized know that something external has changed. This can be done a couple of different ways.
The shallowCompare method will detect changes to any props, even if they aren't declared as propTypes.
This means you can also pass through additional properties that affect cell rendering to ensure changes are detected.
For example, if you're using List to render a list of items that may be re-sorted after initial render- react-virtualized would not normally detect the sort operation because none of the properties it deals with change.
However you can pass through the additional sort property to trigger a re-render.
For example:
<List {...listProps} sortBy={sortBy} />
Grid and Collection components can be forcefully re-rendered using forceUpdate.
For Table and List, you'll need to call forceUpdateGrid to ensure that the inner Grid is also updated. For MultiGrid, you'll need to call forceUpdateGrids to ensure that the inner Grids are updated.
API documentation available here.
There are also a couple of how-to guides:
Examples for each component can be seen in the documentation.
Here are some online demos of each component:
And here are some "recipe" type demos:
react-virtualized aims to support all evergreen browsers and recent mobile browsers for iOS and Android. IE 9+ is also supported (although IE 9 will require some user-defined, custom CSS since flexbox layout is not supported).
If you find a browser-specific problem, please report it along with a repro case. The easiest way to do this is probably by forking this Plunker.
Here are some great components built on top of react-virtualized:
Use GitHub issues for requests.
I actively welcome pull requests; learn how to contribute.
Changes are tracked in the changelog.
react-virtualized is available under the MIT License.
FAQs
React components for efficiently rendering large, scrollable lists and tabular data
The npm package react-virtualized receives a total of 929,149 weekly downloads. As such, react-virtualized popularity was classified as popular.
We found that react-virtualized demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 5 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
UnitedHealth Group disclosed that the ransomware attack on Change Healthcare compromised protected health information for millions in the U.S., with estimated costs to the company expected to reach $1 billion.
Security News
GitHub is susceptible to a CDN flaw that allows attackers to host malware on any public repository.
Security News
At Node Congress, Socket CEO Feross Aboukhadijeh uncovers the darker aspects of open source, where applications that rely heavily on third-party dependencies can be exploited in supply chain attacks.