Concis组件库封装——Pagination分页器

简介: Concis组件库封装——Pagination分页器组件封装

您好,如果喜欢我的文章,可以关注我的公众号「量子前端」,将不定期关注推送前端好文~

分页器组件,文档页面如下:
在这里插入图片描述
在这里插入图片描述
组件封装代码如下:

import React, {
   
    useState, useEffect, FC, useMemo, memo } from 'react';
import {
   
    EllipsisOutlined, LeftOutlined, RightOutlined, DownOutlined } from '@ant-design/icons';
import {
   
    Select } from '..';
import style from './index.module.less'

interface PaginationProps {
   
   
    /**
     * @description 总数据条数
     * @default 0
     */
    total: number
    /**
     * @description 显示每页条数Select
     * @default false
     */
    showSizeChanger?: Boolean
    /**
     * @description 每页条数配置
     * @default 每页10条数据
     */
    pageSizeOptions?: Array<number>
    /**
     * @description 改变页码后的回调
     * @default {}
     */
    showJumpInput?: Boolean
    /**
     * @description 显示跳转页面输入框
     * @default false
     */
    changePageCallback: Function
}
const Pagination: FC<PaginationProps> = (props) => {
   
   
    const {
   
    changePageCallback, total, pageSizeOptions, showJumpInput, showSizeChanger } = props

    const [nowIndex, setNowIndex] = useState<number>(1);
    const [pageRenderArray, setPageRenderArray] = useState<Array<number>>([]);
    const [sizePage, setSizePage] = useState<number>(pageSizeOptions ? pageSizeOptions[0] : 10)
    const [showSizeOptions, setShowSizeOptions] = useState(false);

    const totalPage = useMemo(() => {
   
   
        setNowIndex(1)
        if (Math.ceil(total / sizePage) > 6) {
   
   
            setPageRenderArray([2, 3, 4, 5, 6])
        } else {
   
   
            if (Math.ceil(total / sizePage) > 2) {
   
   
                const array = new Array(Math.ceil(total / sizePage) as number - 2).fill(0);
                array.forEach((item, index) => {
   
   
                    array[index] = index + 2;
                })
                setPageRenderArray(array)
            } else {
   
   
                setPageRenderArray([])
            }
        }
        return Math.ceil(total / sizePage)
    }, [total, sizePage])
    useEffect(() => {
   
   
        console.log(typeof nowIndex)
    }, [nowIndex])

    //点击改页码
    const changePage = (pageNum: number) => {
   
   
        return () => {
   
   
            //小型分页器
            if (totalPage <= 6) {
   
   
                changePageCallback(pageNum)
                return setNowIndex(pageNum)
            }
            if (pageNum > 4 && pageNum <= totalPage - 4) {
   
   
                setPageRenderArray([pageNum - 2, pageNum - 1, pageNum, pageNum + 1, pageNum + 2])
            }
            //页码为1的情况
            if (pageNum <= 4) {
   
   
                setPageRenderArray([2, 3, 4, 5, 6])
            }
            //页码到倒数第四页内的情况
            if (pageNum > totalPage - 4) {
   
   
                setPageRenderArray([totalPage - 5, totalPage - 4, totalPage - 3, totalPage - 2, totalPage - 1])
            }
            setNowIndex(pageNum)
            changePageCallback(pageNum)
        }
    }
    //向前翻一页
    const prevPage = () => {
   
   
        if (nowIndex === 1) {
   
   
            return;
        }
        setNowIndex(nowIndex - 1);
        if (totalPage > 6) {
   
   
            if (nowIndex > totalPage - 3) {
   
   
                return
            } else if (nowIndex > 4) {
   
   
                setPageRenderArray(pageRenderArray.map(item => {
   
   
                    return item - 1;
                }))
            } else if (nowIndex - 5 <= 4) {
   
          //开头几页翻页的情况,回到第一页
                setPageRenderArray([2, 3, 4, 5, 6])
            }
        }
        changePageCallback(nowIndex - 1);
    }
    //向后翻一页
    const nextPage = () => {
   
   

        if (nowIndex === totalPage) {
   
   
            return;
        }
        setNowIndex(nowIndex + 1);
        if (totalPage > 6) {
   
   
            if (nowIndex + 5 > totalPage) {
   
   
                setPageRenderArray([totalPage - 5, totalPage - 4, totalPage - 3, totalPage - 2, totalPage - 1])
            }
            else if (nowIndex < 4) {
   
   
                return
            } else if (nowIndex + 5 < totalPage) {
   
   
                setPageRenderArray(pageRenderArray.map(item => {
   
   
                    return item + 1;
                }))
            }
        }
        changePageCallback(nowIndex + 1)
    }
    //向前翻五页
    const prevFivePage = () => {
   
   
        var updateIndex: number = 0;
        if (nowIndex - 5 <= 4) {
   
          //开头几页翻页的情况,回到第一页
            setPageRenderArray([2, 3, 4, 5, 6])
            updateIndex = nowIndex - 5 <= 1 ? 1 : nowIndex - 5
        }
        else if (nowIndex + 5 > totalPage) {
   
   
            setPageRenderArray([nowIndex - 7, nowIndex - 6, nowIndex - 5, nowIndex - 4, nowIndex - 3])
            updateIndex = nowIndex - 5;
        }
        else if (nowIndex - 5 > 4) {
   
         //中间翻页的情况
            setPageRenderArray(pageRenderArray.map(item => {
   
   
                return item - 5;
            }))
            updateIndex = nowIndex - 5;
        }
        setNowIndex(updateIndex);
        changePageCallback(updateIndex);
    }
    //向后翻五页
    const nextFivePage = () => {
   
   
        var updateIndex: number = 0;
        if (nowIndex + 7 >= totalPage) {
   
   
            setPageRenderArray([totalPage - 5, totalPage - 4, totalPage - 3, totalPage - 2, totalPage - 1]);
            updateIndex = nowIndex + 5 > totalPage ? totalPage : nowIndex + 5;
        }
        else if (nowIndex - 5 < 0) {
   
   
            setPageRenderArray([nowIndex + 3, nowIndex + 4, nowIndex + 5, nowIndex + 6, nowIndex + 7])
            updateIndex = nowIndex + 5;
        }
        else if (nowIndex + 5 < totalPage) {
   
   
            setPageRenderArray(pageRenderArray.map(item => {
   
   
                return item + 5;
            }))
            updateIndex = nowIndex + 5;
        }
        setNowIndex(updateIndex)
        changePageCallback(updateIndex)
    }
    //跳页
    const jumpPageNum = (e: any) => {
   
   
        if (e.keyCode === 13) {
   
   
            const jumpPage = Number(e.target.value);
            if (jumpPage > totalPage || jumpPage < 0 || isNaN(jumpPage)) {
   
          //超出页码范围,不挑
                return e.target.value = '';
            }
            if (jumpPage > 6 && jumpPage < totalPage - 6) {
   
   
                setPageRenderArray([jumpPage - 2, jumpPage - 1, jumpPage, jumpPage + 1, jumpPage + 2]);
            } else if (jumpPage - 5 < 0) {
   
   
                setPageRenderArray([2, 3, 4, 5, 6]);
            } else if (jumpPage + 5 > totalPage) {
   
   
                setPageRenderArray([totalPage - 5, totalPage - 4, totalPage - 3, totalPage - 2, totalPage - 1])
            }
            setNowIndex(jumpPage);
            changePageCallback(jumpPage)
            e.target.value = '';
        }
    }
    //select回调
    const handleSelectCallback = (pageSize: number) => {
   
   
        setSizePage(pageSize);
    }

    return (
        <div className={
   
   style.pagination}>
            <div className={
   
   nowIndex === 1 ? `${style.prev} ${style.disabled}` : `${
     
     style.prev}`} onClick={
   
   prevPage}>
                <LeftOutlined />
            </div>
            <div className={
   
   nowIndex === 1 ? `${style.actived} ${style.numberBox}` : `${
     
     style.numberBox}`} onClick={
   
   changePage(1)}>
                1
            </div>
            {
   
   
                nowIndex > 4 && totalPage > 6
                &&
                <div className={
   
   style.numberBox} onClick={
   
   prevFivePage}><EllipsisOutlined /></div>
            }

            {
   
   (totalPage <= 4 && pageRenderArray.length >= 1)
                &&
                pageRenderArray.map(index => {
   
   
                    return (
                        <div
                            className={
   
   nowIndex === index + 2 ? `${style.actived} ${style.numberBox}` : `${
     
     style.numberBox}`}
                            key={
   
   index}
                            onClick={
   
   changePage(index + 2)}>
                            {
   
   index + 2}
                        </div>
                    )
                })}
            {
   
   
                totalPage > 4
                &&
                pageRenderArray.map((item, index) => {
   
   
                    {
   
   
                        return (
                            <div
                                className={
   
   nowIndex === item
                                    ?
                                    `${style.actived} ${style.numberBox}`
                                    :
                                    `${
     
     style.numberBox}`}
                                key={
   
   index}
                                onClick={
   
   changePage(item)}>
                                {
   
   item}
                            </div>
                        )
                    }

                })
            }
            {
   
   
                totalPage - nowIndex >= 4 && totalPage > 6
                &&
                <div
                    className={
   
   style.numberBox}
                    onClick={
   
   nextFivePage}><EllipsisOutlined /></div>
            }
            {
   
   
                totalPage > 1
                &&
                <div
                    className={
   
   nowIndex === totalPage
                        ?
                        `${style.actived} ${style.numberBox}`
                        :
                        `${
     
     style.numberBox}`}
                    onClick={
   
   changePage(totalPage)}>
                    {
   
   totalPage}
                </div>
            }
            <div className={
   
   nowIndex === totalPage || totalPage <= 1
                ?
                `${style.next} ${style.disabled}`
                :
                `${
     
     style.next}`}
                onClick={
   
   nextPage}>
                <RightOutlined />
            </div>
            {
   
   /* {
                Array.isArray(pageSizeOptions) && showSizeChanger
                &&
                <div className={style.pageSizeSelect} onClick={() => setShowSizeOptions(!showSizeOptions)}>
                    <>
                        <span className={style.size}>{sizePage} 条/页</span>
                        <DownOutlined />

                    </>
                    {
                        showSizeOptions
                        &&
                        <div className={style.options}>
                            {
                                pageSizeOptions.map(s => {
                                    return (
                                        <div key={s as number} className={style.option} onClick={() => setSizePage(s as number)}>
                                            {s} 条/页
                                        </div>
                                    )
                                })
                            }
                        </div>
                    }
                </div>
            } */}
            {
   
   
                Array.isArray(pageSizeOptions) && showSizeChanger
                &&
                <Select 
                option={
   
   pageSizeOptions.map(item => {
   
   
                    return (
                        {
   
   
                            label: `${
     
     item} 条/页`,
                            value: item
                        }
                    )
                })}
                width={
   
   100}
                handleSelectCallback={
   
   handleSelectCallback}/>
            }
            {
   
   
                showJumpInput
                &&
                <div className={
   
   style.jumpBox}>
                    <span>跳至</span>
                    <input type="text" className={
   
   style.jump} onKeyUp={
   
   jumpPageNum}></input>
                    <span></span>
                </div>
            }
        </div>
    )
}
export default memo(Pagination);
目录
相关文章
|
1月前
|
前端开发 UED 开发者
React 分页组件 Pagination
本文介绍了如何在 React 中实现分页组件,从基础概念到常见问题及解决方案。分页组件用于将大量数据分成多个页面,提升用户体验。文章详细讲解了分页组件的基本结构、快速入门步骤、以及如何处理页面跳转不平滑、页码过多导致布局混乱、边界条件处理和数据加载延迟等问题。通过本文,读者可以全面了解并掌握 React 分页组件的开发技巧。
37 2
VUE3(二十三)自定义分页组件Pagination
刚开始使用vue3写博客的时候,其相关配套的UI库并没有正式发布,但是我还要用,所以这里我自定义了一个分页组件。
679 0
VUE3(二十三)自定义分页组件Pagination
|
3月前
elementUI使用Pagination分页组件增加自定义slot
本文介绍了如何在Element UI的Pagination分页组件中使用自定义slot。通过在`el-pagination`标签内的适当位置添加slot内容,可以在分页组件中插入自定义的HTML或组件。文章提供了一个示例代码,展示了如何添加两个自定义slot,并展示了最终效果。
403 4
elementUI使用Pagination分页组件增加自定义slot
|
3月前
封装react-antd-table组件参数以及方法如rowSelection、pageNum、pageSize、分页方法等等
文章介绍了如何封装React-Antd的Table组件,包括参数和方法,如行选择(rowSelection)、页码(pageNum)、页面大小(pageSize)、分页方法等,以简化在不同表格组件中的重复代码。
81 0
|
6月前
iView分页表格封装
iView分页表格封装
|
7月前
|
资源调度 JavaScript 前端开发
将Elementui里的Table表格做成响应式并且和Pagination分页组件封装在一起(Vue实战系列)
将Elementui里的Table表格做成响应式并且和Pagination分页组件封装在一起(Vue实战系列)
375 2
|
7月前
|
前端开发
antd-protable的分页逻辑封装
antd-protable的分页逻辑封装
458 0
|
JavaScript 前端开发 数据格式
Jquery前端分页插件pagination使用
Jquery前端分页插件pagination使用
146 1
|
前端开发 JavaScript
Jquery前端分页插件pagination同步加载和异步加载
Jquery前端分页插件pagination同步加载和异步加载
79 0
|
存储 JavaScript 前端开发
Vue 3和Element组件库的分页功能实现
随着Web应用程序的发展,数据量的增加和复杂性的提高,分页功能成为了用户友好和高效展示数据的重要手段。Vue 3是由Evan You于2020年推出的JavaScript框架,具有响应式和组件化开发的特点。Element是一套基于Vue.js的UI组件库,提供了大量易于使用和高度定制化的组件。本论文将介绍如何利用Vue 3和Element组件库实现优秀的分页功能,提升用户体验。
1036 3