分页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））您可以利用的另一种方法是使用。过滤器，请看：

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

更新所选页面和/或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
以下是一个解决方案：


功能分页（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*页码
，返回空数组。因此
page_number
attr的最小值应该是1，除非在函数中处理该情况，否则不能小于1

2.）拆分的起始索引和结束索引相同。因此，返回一个空数组。因此，分割应为：

return array.split(page_number * page_size, page_number * page_size + page_size)


constmyarray=[1,2,3,4,5,6,7,8,9,10]；
常量paginateBad1=（数组、页面大小、页面编号）=>{
返回数组.slice（（页码-1）*页码大小，页码*页码大小）；
};
常量paginateBad2=（数组、页面大小、页面编号）=>{
返回数组.slice（页码*页码大小，页码*页码大小）；
};
const paginateGood=（数组、页面大小、页面编号）=>{
返回数组.slice（页码*页码大小，页码*页码大小+页码大小）；
};
log（“bad1”，paginateBad1（myArray，2，0））；
log（“bad2”，paginateBad2（myArray，2，1））；
log（“良好”，分页良好（myArray，2，1））嘿，很抱歉，我迟到了一点，但是我们可以使用
数组.splice（开始，结束）
方法，不过这要简单得多

const page = 2
const step = 2;
const start = page * step - step;
const end = start + step;

const array = [1,2,3,4,5,6]
console.log(array.splice(start, end))


函数分页（数组、页码大小、页码）{
//人类可读的页码通常以1开头，因此我们在第一个参数中减少1
返回数组.slice（（页码-1）*页码大小，页码*页码大小）；
}
var arr=[1,2,3,4,5,6]
常量选项={
//页面：parseInt（请求查询页面）| | 1，
页码：1，
限额：10
//限制：parseInt（请求查询限制）| | 10，
//customLabels:servCustomLabels，
};
设上一页=0；
让下一页=0；
设h_p_p=null；
设h_n_p=null；
让page_count=Math.ceil（（arr.length/options.limit））；
如果（options.page>=页数）{//2 3
下一页=0；
}        
如果（options.page>=1&&options.page如果（options.page）
[3,4]
相对于所有其他变量代表什么？这是一种关键，你可以解释清楚->
array.slice（（页码-1）*page\u size，page\u size）
（类似的东西应该可以用）@DarrenSweeney，如果数组被划分为“页面”，我们将得到3页，其中每页的大小最多为2:
[1,2]
，
[3,4]
和
[5]
。此场景中的第2页将是
[3,4]
@casraf：你先减少
页码
，然后在
页码+1
切片时添加1。我不明白背后的逻辑。我可能看起来很幼稚，但