react-infinite vs react-list vs react-tiny-virtual-list vs react-virtualized vs react-window
虚拟滚动和无限滚动
react-infinitereact-listreact-tiny-virtual-listreact-virtualizedreact-window类似的npm包:

虚拟滚动和无限滚动

虚拟滚动和无限滚动是处理大量数据时提高性能的技术。虚拟滚动只渲染可见区域的元素,从而减少DOM节点的数量,提高渲染效率。无限滚动则在用户滚动时动态加载更多内容,适用于内容量大且不需要一次性加载的场景。这两种技术都能显著提升用户体验,减少页面加载时间和内存消耗。

npm下载趋势

3 年

GitHub Stars 排名

统计详情

npm包名称
下载量
Stars
大小
Issues
发布时间
License
react-infinite02,687243 kB102-BSD-3-Clause
react-list01,97434.9 kB711 年前MIT
react-tiny-virtual-list02,497-548 年前MIT
react-virtualized027,0802.24 MB11 年前MIT
react-window017,113209 kB125 天前MIT

功能对比: react-infinite vs react-list vs react-tiny-virtual-list vs react-virtualized vs react-window

虚拟化技术

  • react-infinite:

    react-infinite主要支持无限滚动,通过监听滚动事件动态加载更多内容,适合长列表但不支持虚拟化。

  • react-list:

    react-list支持虚拟化和无限滚动,能够根据可见区域渲染列表项,减少DOM节点数量,提高性能。

  • react-tiny-virtual-list:

    react-tiny-virtual-list专注于虚拟化,只渲染可见区域的列表项,极大减少渲染开销,适合大规模数据集。

  • react-virtualized:

    react-virtualized提供全面的虚拟化解决方案,支持列表、表格和网格等多种布局,灵活性高,适合复杂场景。

  • react-window:

    react-window提供轻量级的虚拟化解决方案,支持列表和网格,设计简单,易于使用,性能优越。

包大小

  • react-infinite:

    react-infinite包大小适中,但主要关注无限滚动,虚拟化功能有限。

  • react-list:

    react-list相对较小,提供虚拟化和无限滚动功能,适合对性能有一定要求的应用。

  • react-tiny-virtual-list:

    react-tiny-virtual-list是一个极小的虚拟化库,适合对包大小敏感的项目,提供高性能的虚拟化功能。

  • react-virtualized:

    react-virtualized功能强大但包较大,适合需要多种虚拟化功能的复杂应用。

  • react-window:

    react-window相比react-virtualized更小,提供基本的虚拟化功能,适合大多数应用。

易用性

  • react-infinite:

    react-infinite提供简单的API,易于集成到现有项目中,特别是对于无限滚动场景。

  • react-list:

    react-list提供直观的API,支持快速实现虚拟化和无限滚动,文档清晰易懂。

  • react-tiny-virtual-list:

    react-tiny-virtual-listAPI简单,易于使用,适合快速实现虚拟化列表。

  • react-virtualized:

    react-virtualized功能丰富但学习曲线较陡,适合需要深入定制的开发者。

  • react-window:

    react-window提供简单易用的API,文档完善,适合快速上手。

示例代码

  • react-infinite:

    无限滚动示例

    import React from 'react';
    import Infinite from 'react-infinite';
    
    const InfiniteList = () => {
      const items = Array.from({ length: 1000 }, (_, i) => `Item ${i}`);
    
      return (
        <Infinite
          containerHeight={300}
          infiniteLoadBeginEdge={100}
          infiniteLoadBeginBottomOffset={200}
          onInfiniteLoad={() => { /* Load more items */ }}
        >
          {items.map(item => (
            <div key={item} style={{ height: 50 }}>{item}</div>
          ))}
        </Infinite>
      );
    };
    
    export default InfiniteList;
    
  • react-list:

    虚拟化列表示例

    import React from 'react';
    import { List } from 'react-list';
    
    const VirtualizedList = () => {
      const items = Array.from({ length: 1000 }, (_, i) => `Item ${i}`);
    
      return (
        <List
          itemRenderer={(index, key) => (
            <div key={key} style={{ height: 50 }}>{items[index]}</div>
          )}
          length={items.length}
          type="uniform"
        />
      );
    };
    
    export default VirtualizedList;
    
  • react-tiny-virtual-list:

    虚拟列表示例

    import React from 'react';
    import { VariableSizeList } from 'react-tiny-virtual-list';
    
    const itemSize = index => 50; // 每个项的高度
    const items = Array.from({ length: 1000 }, (_, i) => `Item ${i}`);
    
    const VirtualList = () => (
      <VariableSizeList
        height={300}
        itemCount={items.length}
        itemSize={itemSize}
        width="100%"
      >
        {({ index, style }) => (
          <div style={style}>{items[index]}</div>
        )}
      </VariableSizeList>
    );
    
    export default VirtualList;
    
  • react-virtualized:

    虚拟化表格示例

    import React from 'react';
    import { AutoSizer, List } from 'react-virtualized';
    
    const items = Array.from({ length: 1000 }, (_, i) => `Item ${i}`);
    
    const VirtualizedList = () => (
      <AutoSizer>
        {({ height, width }) => (
          <List
            height={height}
            rowCount={items.length}
            rowHeight={() => 50}
            rowRenderer={({ index, style }) => (
              <div style={style} key={index}>{items[index]}</div>
            )}
            width={width}
          />
        )}
      </AutoSizer>
    );
    
    export default VirtualizedList;
    
  • react-window:

    简单虚拟化示例

    import React from 'react';
    import { FixedSizeList } from 'react-window';
    
    const items = Array.from({ length: 1000 }, (_, i) => `Item ${i}`);
    
    const VirtualList = () => (
      <FixedSizeList
        height={300}
        itemCount={items.length}
        itemSize={50}
        width="100%"
      >
        {({ index, style }) => (
          <div style={style}>{items[index]}</div>
        )}
      </FixedSizeList>
    );
    
    export default VirtualList;
    

如何选择: react-infinite vs react-list vs react-tiny-virtual-list vs react-virtualized vs react-window

  • react-infinite:

    选择react-infinite如果你需要一个简单的无限滚动解决方案,支持动态加载更多内容,适合内容列表较长的场景。

  • react-list:

    选择react-list如果你需要一个轻量级的列表组件,支持虚拟化和无限滚动,适合需要高性能渲染的大型列表。

  • react-tiny-virtual-list:

    选择react-tiny-virtual-list如果你需要一个极小的虚拟列表组件,具有简单的API和良好的性能,适合对包大小敏感的项目。

  • react-virtualized:

    选择react-virtualized如果你需要一个功能全面的虚拟化库,支持表格、列表和网格等多种布局,适合需要高度自定义和多功能的应用。

  • react-window:

    选择react-window如果你需要一个现代、轻量级的虚拟化库,提供简单的API和良好的性能,适合大多数虚拟化场景,尤其是在对性能和包大小有要求的项目中。

react-infinite的README

React Infinite

Build Status Coverage Status npm version bitHound Score

A browser-ready efficient scrolling container based on UITableView.

React Infinite 0.7.1 only supports React 0.14 and above. Please pin your package to 0.6.0 for React 0.13 support.

When a long list of DOM elements are placed in a scrollable container, all of them are kept in the DOM even when they are out the user's view. This is highly inefficient, especially in cases when scrolling lists can be tens or hundreds of thousands of items long. React Infinite solves this by rendering only DOM nodes that the user is able to see or might soon see. Other DOM nodes are clustered and rendered as a single blank node.

Installation

In the Browser

The relevant files are dist/react-infinite.js and dist/react-infinite.min.js. You must have React available as a global variable named React on the window. Including either file, through concatenation or a script tag, will produce a global variable named Infinite representing the component.

In NPM

React Infinite uses a Universal Module Definition so you can use it in NPM as well. npm install this package and

var Infinite = require('react-infinite');

In Browserify

If you want to use the source with Browserify, the ES5-compiled source is directly requirable from the /build folder off NPM.

Otherwise, you can follow the instructions for NPM.

Basic Use

Elements of Equal Height

To use React Infinite with a list of elements you want to make scrollable, provide them to React Infinite as children.

<Infinite containerHeight={200} elementHeight={40}>
    <div className="one"/>
    <div className="two"/>
    <div className="three"/>
</Infinite>

Elements of Varying Heights

If not all of the children have the same height, you must provide an array of integers to the elementHeight prop instead.

<Infinite containerHeight={200} elementHeight={[111, 252, 143]}>
    <div className="111-px"/>
    <div className="252-px"/>
    <div className="143-px"/>
</Infinite>

Using the Window to Scroll (useWindowAsScrollContainer mode)

To use the entire window as a scroll container instead of just a single div (thus using window.scrollY instead of a DOM element's scrollTop), add the useWindowAsScrollContainer prop.

<Infinite containerHeight={200} elementHeight={[111, 252, 143]}
          useWindowAsScrollContainer>
    <div className="111-px"/>
    <div className="252-px"/>
    <div className="143-px"/>
</Infinite>

As A Chat or Message Box (displayBottomUpwards mode)

React Infinite now supports being used as a chat box, i.e. appended elements appear at the bottom when added, and the loading of the next page occurs when the user scrolls to the top of the container. To do so, simply add the displayBottomUpwards prop. A sample implementation can be consulted for more information - run gulp develop to compile the example files.

<Infinite containerHeight={200} elementHeight={[111, 252, 143]}
          displayBottomUpwards>
    // insert messages for subsequent pages at this point
    <div className="third-latest-chat"/>
    <div className="second-latest-chat"/>
    <div className="latest-chat-message"/>
</Infinite>

Note on Smooth Scrolling

A wrapper div is applied that disables pointer events on the children for a default of 150 milliseconds after the last user scroll action for browsers with inertial scrolling. To configure this, set timeScrollStateLastsForAfterUserScrolls.

Static Methods

Function Infinite.containerHeightScaleFactor(Number number)

This function allows a value to be specified for preloadBatchSize and preloadAdditionalHeight that is a relative to the container height. Please see the documentation for those two configuration options for further information on how to use it.

Configuration Options

Children

The children of the <Infinite> element are the components you want to render. This gives you as much flexibility as you need in the presentation of those components. Each child can be a different component if you desire. If you wish to render a set of children not all of which have the same height, you must map each component in the children array to an number representing its height and pass it in as the elementHeight prop.

Major Display Modes

By default, React Infinite renders a single element with the provided containerHeight, and the list sticks to the top like a regular table. However, you can choose to use the entire window as the scroll container or make React Infinite like a chatbox with the following options. They can be used together if you wish.

Bool useWindowAsScrollContainer

Defaults to false. This option allows the window to be used as the scroll container, instead of an arbitrary div, when it is set to true. This means that scroll position is detected by window.scrollY instead of the scrollTop of the div that React Infinite creates. Using this option is a way of achieving smoother scrolling on mobile before the problem is solved for container divs.

Bool displayBottomUpwards

Defaults to false. This allows React Infinite to be used as a chatbox. This means that the scroll is stuck to the bottom by default, and the user scrolls up to the top of the container to load the next page. The children are displayed in the same order.

Configuration Options

(Required) Number | [Number] elementHeight

If each child element has the same height, you can pass a number representing that height as the elementHeight prop. If the children do not all have the same height, you can pass an array which is a map the children to numbers representing their heights to the elementHeight prop.

Number containerHeight

The height of the scrolling container in pixels. This is a required prop if useWindowAsScrollContainer is not set to true.

Number | Object preloadBatchSize

Defaults to this.props.containerHeight * 0.5. Imagine the total height of the scrollable divs. Now divide this equally into blocks preloadBatchSize pixels high. Every time the container's scrollTop enters each of these blocks the set of elements rendered in full are those contained within the block and elements that are within preloadAdditionalHeight above and below it.

When working with the window as the scroll container, it is sometimes useful to specify a scale factor relative to the container height as the batch size, so your code does not need to know anything about the window. To do this, use Infinite.containerHeightScaleFactor. So, for example, if you want the preloaded batch size to be twice the container height, write preloadBatchSize={Infinite.containerHeightScaleFactor(2)}.

Number | Object preloadAdditionalHeight

Defaults to this.props.containerHeight. The total height of the area in which elements are rendered in full is height of the current scroll block (see preloadBatchSize) as well as preloadAdditionalHeight above and below it.

When working with the window as the scroll container, it is sometimes useful to specify this relative to the container height. If you want the preloaded additional height to be twice the container height, write preloadAdditionalHeight={Infinite.containerHeightScaleFactor(2)}. Please see preloadBatchSize for more details.

Function handleScroll(DOMNode node)

Defaults to function(){}. A function that is called when the container is scrolled, i.e. when the onScroll event of the infinite scrolling container is fired. The only argument passed to it is the native DOM Node of the scrolling container.

Number infiniteLoadBeginEdgeOffset

Defaults to undefined, which means that infinite loading is disabled. To disable infinite loading, do not provide this property or set it to undefined.

Regular Mode When the user reaches this number of pixels from the bottom, the infinite load sequence will be triggered by showing the infinite load spinner delegate and calling the function onInfiniteLoad.

displayBottomUpwards mode When the user reaches this number of pixels from the top of the container, the infinite load sequence will be triggered by showing the infinite loading spinner delegate at the top of the container and calling onInfiniteLoad.

Function onInfiniteLoad()

Defaults to function(){}. This function is called when the scroll exceeds infiniteLoadBeginEdgeOffset. Before this function is called, the infinite loading spinner is automatically turned on. You can set up infinite scrolling with this function like this:

  1. Fetch a new page of records from the appropriate API
  2. When the AJAX call returns, send the new list of elements (with the items that were just fetched) back as the children of React Infinite.
  3. Set React Infinite's isInfiniteLoading prop to false to hide the loading spinner display

onInfiniteLoad relies heavily on passing props as a means of communication in the style of idiomatic React.

React Node loadingSpinnerDelegate

Defaults to <div/>. The element that is provided is used to render the loading view when React Infinite's isInfiniteLoading property is set to true. A React Node is anything that satisfies React.PropTypes.node.

Bool isInfiniteLoading

Defaults to false. This property determines whether the infinite spinner is showing.

Number timeScrollStateLastsForAfterUserScrolls

Defaults to 150 (in milliseconds). On Apple and some other devices, scroll is inertial. This means that the window continues to scroll for several hundred milliseconds after an onScroll event is fired. To prevent janky behavior, we do not want pointer-events to reactivate before the window has finished moving. Setting this parameter causes the Infinite component to think that the user is still scrolling for the specified number of milliseconds after the last onScroll event is received.

String className

Allows a CSS class to be set on the scrollable container.

Sample Code

Code samples are now available in the /examples directory for your perusal. Two examples are provided, one for constant height with infinite loading and another with random variable heights with infinite loading. To generate the files necessary for the examples, execute npm install && gulp build -E. You may need to first install gulp with npm install -g gulp.

To get you started, here is some sample code that implements an infinite scroll with an simulated delay of 2.5 seconds. A live demo of this example is available on our blog.

var createReactClass = require('create-react-class');

var ListItem = createReactClass({
    render: function() {
        return <div className="infinite-list-item">
        List Item {this.props.num}
        </div>;
    }
});

var InfiniteList = createReactClass({
    getInitialState: function() {
        return {
            elements: this.buildElements(0, 20),
            isInfiniteLoading: false
        }
    },

    buildElements: function(start, end) {
        var elements = [];
        for (var i = start; i < end; i++) {
            elements.push(<ListItem key={i} num={i}/>)
        }
        return elements;
    },

    handleInfiniteLoad: function() {
        var that = this;
        this.setState({
            isInfiniteLoading: true
        });
        setTimeout(function() {
            var elemLength = that.state.elements.length,
                newElements = that.buildElements(elemLength, elemLength + 1000);
            that.setState({
                isInfiniteLoading: false,
                elements: that.state.elements.concat(newElements)
            });
        }, 2500);
    },

    elementInfiniteLoad: function() {
        return <div className="infinite-list-item">
            Loading...
        </div>;
    },

    render: function() {
        return <Infinite elementHeight={40}
                         containerHeight={250}
                         infiniteLoadBeginEdgeOffset={200}
                         onInfiniteLoad={this.handleInfiniteLoad}
                         loadingSpinnerDelegate={this.elementInfiniteLoad()}
                         isInfiniteLoading={this.state.isInfiniteLoading}
                         >
            {this.state.elements}
        </Infinite>;
    }
});

ReactDOM.render(<InfiniteList/>, document.getElementById('react-example-one'));

SeatGeek also currently uses React Infinite in production on our event pages; because we only have pages for events in the future, a link would not be appropriate. To see one, head to one of our team pages for the New York Giants, or the New York Mets, or the New York Knicks, and click on the green button for an event to see them in action in the Omnibox.

Contributing to React Infinite

Useful notes for how to contribute are available.