分页Javascript数组

我正在尝试编写一个Javascript函数，该函数将

数组

、

页面大小

和

页面编号

作为参数，并返回一个模拟分页结果的数组：

paginate: function (array, page_size, page_number) {
  return result;
}

例如：

array = [1, 2, 3, 4, 5],
page size = 2,
page_number = 2,

函数应该返回：

[3,4]

任何想法都将不胜感激。

您可以使用并提供

（开始、结束）

的参数

函数分页（数组、页码大小、页码）{
//人类可读的页码通常以1开头，因此我们在第一个参数中减少1
返回数组.slice（（页码-1）*页码大小，页码*页码大小）；
}
日志（分页（[1,2,3,4,5,6]，2,2））；
日志（分页（[1,2,3,4,5,6,7,8,9,10,11]，4,1））您可以使用并仅提供
（开始、结束）
的参数


函数分页（数组、页码大小、页码）{
//人类可读的页码通常以1开头，因此我们在第一个参数中减少1
返回数组.slice（（页码-1）*页码大小，页码*页码大小）；
}
日志（分页（[1,2,3,4,5,6]，2,2））；
日志（分页（[1,2,3,4,5,6,7,8,9,10,11]，4,1））您可以利用的另一种方法是使用。过滤器，请看：

const paginate = function (array, index, size) {
        // transform values
        index = Math.abs(parseInt(index));
        index = index > 0 ? index - 1 : index;
        size = parseInt(size);
        size = size < 1 ? 1 : size;

        // filter
        return [...(array.filter((value, n) => {
            return (n >= (index * size)) && (n < ((index+1) * size))
        }))]
    }

var array = [
  {id: "1"}, {id: "2"}, {id: "3"}, {id: "4"}, {id: "5"}, {id: "6"}, {id: "7"}, {id: "8"}, {id: "9"}, {id: "10"}
 ]


var transform = paginate(array, 2, 5);

console.log(transform) // [{"id":"6"},{"id":"7"},{"id":"8"},{"id":"9"},{"id":"10"}] 

const paginate=函数（数组、索引、大小）{
//转换值
index=Math.abs（parseInt（index））；
索引=索引>0？索引-1：索引；
size=parseInt（size）；
尺寸=尺寸<1？1：尺寸；
//滤器
返回[…（array.filter）（（值，n）=>{
返回（n>=（索引*大小））&&（n<（（索引+1）*大小））
}))]
}
变量数组=[
{id:'1}，{id:'2}，{id:'3}，{id:'4}，{id:'5}，{id:'6}，{id:'7}，{id:'8}，{id:'9}，{id:'10}
]
var变换=分页（数组，2，5）；
console.log（transform）/[{“id”：“6”}，{“id”：“7”}，{“id”：“8”}，{“id”：“9”}，{“id”：“10”}]
您可以利用的另一种方法是使用.filter，look:

const paginate = function (array, index, size) {
        // transform values
        index = Math.abs(parseInt(index));
        index = index > 0 ? index - 1 : index;
        size = parseInt(size);
        size = size < 1 ? 1 : size;

        // filter
        return [...(array.filter((value, n) => {
            return (n >= (index * size)) && (n < ((index+1) * size))
        }))]
    }

var array = [
  {id: "1"}, {id: "2"}, {id: "3"}, {id: "4"}, {id: "5"}, {id: "6"}, {id: "7"}, {id: "8"}, {id: "9"}, {id: "10"}
 ]


var transform = paginate(array, 2, 5);

console.log(transform) // [{"id":"6"},{"id":"7"},{"id":"8"},{"id":"9"},{"id":"10"}] 

const paginate=函数（数组、索引、大小）{
//转换值
index=Math.abs（parseInt（index））；
索引=索引>0？索引-1：索引；
size=parseInt（size）；
尺寸=尺寸<1？1：尺寸；
//滤器
返回[…（array.filter）（（值，n）=>{
返回（n>=（索引*大小））&&（n<（（索引+1）*大小））
}))]
}
变量数组=[
{id:'1}，{id:'2}，{id:'3}，{id:'4}，{id:'5}，{id:'6}，{id:'7}，{id:'8}，{id:'9}，{id:'10}
]
var变换=分页（数组，2，5）；
console.log（transform）/[{“id”：“6”}，{“id”：“7”}，{“id”：“8”}，{“id”：“9”}，{“id”：“10”}]
可以在第二个参数（数组中正在处理的当前元素的索引）的帮助下使用

您还需要当前选择的页面和每页显示的项目数，以便找到所需元素的最小和最大索引

const indexMin = selectedPage * elementsPerPage;
const indexMax = indexMin + elementsPerPage;
const paginatedArray = arrayToPaginate.filter(
  (x, index) => index >= indexMin && index < indexMax
);

const indexMin=selectedPage*elementsPerPage；
常量indexMax=indexMin+elementsPerPage；
常数paginatedArray=arrayToPaginate.filter(
（x，index）=>index>=indexMin&&index

更新selectedPage和/或elementsPerPage值将允许返回要显示的正确项目。
您可以在其第二个参数（数组中正在处理的当前元素的索引）的帮助下使用

您还需要当前选择的页面和每页显示的项目数，以便找到所需元素的最小和最大索引

const indexMin = selectedPage * elementsPerPage;
const indexMax = indexMin + elementsPerPage;
const paginatedArray = arrayToPaginate.filter(
  (x, index) => index >= indexMin && index < indexMax
);

const indexMin=selectedPage*elementsPerPage；
常量indexMax=indexMin+elementsPerPage；
常数paginatedArray=arrayToPaginate.filter(
（x，index）=>index>=indexMin&&index

更新所选页面和/或elementsPerPage值将允许返回要显示的正确项目。
预期答案是使用
数组#切片

在这里，我使用创建一个


const arr=[1,2,3,4,5,6,7,8,9,10]
函数页（{arr，pageSize，pageNumber}）{
const start=pageSize*（页码-1）
const end=pageSize*pageNumber
返回{
*[符号.迭代器]（）{
for（让i=start；i
使用
Array#slice
是预期的答案

在这里，我使用创建一个


const arr=[1,2,3,4,5,6,7,8,9,10]
函数页（{arr，pageSize，pageNumber}）{
const start=pageSize*（页码-1）
const end=pageSize*pageNumber
返回{
*[符号.迭代器]（）{
for（让i=start；i
以下是一个解决方案：


功能分页（arr，大小）{
返回arr.reduce（（acc、val、i）=>{
设idx=数学地板（i/尺寸）
让page=acc[idx]| |（acc[idx]=[]）
页面推送（val）
返回acc
}, [])
}
让数组=[1,2,3,4,5]
让页面大小=2
让页面=分页（数组，页面大小）
console.log（pages）//所有页面
console.log（第[1]页）//第二页
以下是一个解决方案：


功能分页（arr，大小）{
返回arr.reduce（（acc、val、i）=>{
设idx=数学地板（i/尺寸）
让page=acc[idx]| |（acc[idx]=[]）
页面推送（val）
返回acc
}, [])
}
让数组=[1,2,3,4,5]
让页面大小=2
让页面=分页（数组，页面大小）
console.log（pages）//所有页面
log（第[1]页）//第二页
我看到了上面的一个例子，它正确地做到了这一点（某种程度上），并希望在此基础上进行扩展

这就是一个例子

function paginate(array, page_size, page_number) {
  // human-readable page numbers usually start with 1, so we reduce 1 in the first argument
  return array.slice((page_number - 1) * page_size, page_number * page_size);
}

这有几个地方不对劲

1.）如果
页码
为0，则它将尝试将起始拆分设置为
-1*页码
，其中