Comment implémenter la pagination de tableaux en PHP sans utiliser de base de données

Cet article vous présentera comment implémenter la pagination de tableaux en PHP sans utiliser de base de données. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Implémentation de la pagination de tableaux en PHP (hors base de données)

Dans un environnement commercial de développement quotidien, nous utilisez généralement des instructions MySQL pour implémenter la fonction de pagination. Cependant, certaines données ne sont souvent pas volumineuses, ou la fonction de pagination n'est nécessaire que pour obtenir certaines données de tableau définies en PHP. Pour le moment, nous n'avons pas besoin d'interroger la base de données à chaque fois. Nous pouvons récupérer toutes les données en une seule requête, puis implémenter la fonction de pagination au niveau du code PHP. Aujourd'hui, nous allons apprendre quelques techniques fonctionnelles qui peuvent atteindre cette capacité.

Tout d'abord, nous préparons toujours les données de test.

$data = [
    'A',
    'B',
    'C',
    'D',
    'E',
    'F',
    'G',
    'H',
    'I',
    'J',
    'K',
];

// $p = $_GET['p'];
$p = 2;
$currentPage = $p <= 1 ? 0 : $p - 1;
$pageSize = 3;
$offset = $currentPage * $pageSize;

Supposons que $data soit toutes les données extraites de la base de données, ou les données que nous avons codées en dur dans le code PHP. Ensuite, nous définissons $p comme paramètre de requête reçue, et la page actuellement consultée est la deuxième page. $currentPage est utilisé pour interroger la correction de décalage. Dans le monde du développement de code, les index d'indice commencent tous à 0, nous devons donc décrémenter les paramètres reçus de un. Bien sûr, vous pouvez également définir les paramètres transmis par le front-end pour utiliser 0 comme première page. Je n’expliquerai pas grand-chose. Je pense que tout le monde comprendra sa signification à condition de l’avoir étudié formellement ou de participer à un projet de développement.

Ensuite, nous définissons le nombre d'informations affichées sur la page actuelle $pageSize, c'est-à-dire que seules 3 données sont obtenues. Enfin, nous avons calculé le décalage, qui est similaire au paramètre LIMIT de MySQL. Sa fonction est de nous indiquer à partir de quel élément commencer l'interrogation, puis d'utiliser $pageSize pour interroger le nombre d'éléments. De cette façon, nous pouvons obtenir les données correspondant à la page actuelle. (Il semble que les principes de la pagination aient été expliqués)

array_slice

La première méthode de pagination, la plus basique et la plus courante, consiste à utiliser la fonction array_slice() accomplie. . Sa fonction est d'intercepter un élément de contenu d'un tableau et de renvoyer un tableau de ce contenu. La fonction

var_dump(array_slice($data, $offset, $pageSize));
// array(3) {
//     [0]=>
//     string(1) "D"
//     [1]=>
//     string(1) "E"
//     [2]=>
//     string(1) "F"
//   }

array_slice() nécessite trois paramètres, le deuxième paramètre est le décalage et le troisième paramètre consiste à interroger plusieurs éléments de données. Parmi eux, le troisième paramètre est facultatif. S'il n'est pas renseigné, toutes les données après le décalage actuellement défini seront affichées. Est-ce exactement la même chose que notre instruction de requête MySQL ? Oui, ce sont elles-mêmes des opérations similaires. La fonction

array_chunk

array_chunk() regroupe un tableau en fonction d'un paramètre numérique, c'est-à-dire divise le tableau en sous-tableaux. Nous pouvons obtenir le contenu du sous-tableau de l'indice spécifié en fonction du tableau divisé. Ces contenus sont les données qui doivent être affichées sur la page actuelle.

$pages = array_chunk($data, $pageSize);
var_dump($pages);
// array(4) {
//     [0]=>
//     array(3) {
//       [0]=>
//       string(1) "A"
//       [1]=>
//       string(1) "B"
//       [2]=>
//       string(1) "C"
//     }
//     [1]=>
//     array(3) {
//       [0]=>
//       string(1) "D"
//       [1]=>
//       string(1) "E"
//       [2]=>
//       string(1) "F"
//     }
//     [2]=>
//     array(3) {
//       [0]=>
//       string(1) "G"
//       [1]=>
//       string(1) "H"
//       [2]=>
//       string(1) "I"
//     }
//     [3]=>
//     array(2) {
//       [0]=>
//       string(1) "J"
//       [1]=>
//       string(1) "K"
//     }
//   }

var_dump($pages[$currentPage]);
// array(3) {
//     [0]=>
//     string(1) "A"
//     [1]=>
//     string(1) "B"
//     [2]=>
//     string(1) "C"
//   }

Dans ce code, nous affichons le contenu du tableau divisé, puis ce dont nous avons besoin est la deuxième page, qui est les données avec l'indice 1. Nous pouvons facilement obtenir les informations requises directement via le tableau divisé . contenu. L'utilisation de cette fonction pour effectuer la pagination des tableaux est très simple et intuitive, et elle n'a pas besoin de calculer le décalage. Vous pouvez utiliser directement la page actuelle $currentPage et $pageSize pour compléter le regroupement des données. Il est fortement recommandé de l'utiliser. fonction. Faites quelque chose de similaire.

LimitIterator

La dernière chose que nous devons apprendre est la possibilité d'utiliser une classe itérateur pour implémenter la pagination de tableau. Ceci est utilisé relativement rarement, et probablement pas beaucoup de gens. utilisez-le. Je sais, mais en fait la classe LimitIterator était déjà fournie en PHP5.1. Son objectif est de permettre l'itération sur un sous-ensemble restreint d'éléments d'un itérateur. En d'autres termes, si notre code utilise le modèle d'itérateur et implémente l'interface d'itérateur, alors ces classes d'itérateur peuvent utiliser cette classe pour les opérations de pagination.

foreach (new LimitIterator(new ArrayIterator($data), $offset, $pageSize) as $d) {
    var_dump($d);
}
// string(1) "D"
// string(1) "E"
// string(1) "F"

Il nécessite 3 paramètres de construction d'instanciation. Le premier est un objet itérateur. Puisque le tableau n'est pas un objet itérateur, nous utilisons l'instance ArrayIterator pour convertir nos données de tableau en un objet itérateur. Les deux derniers paramètres sont le décalage et le nombre de données. Ceci est similaire à la fonction array_slice(), mais la différence est que son paramètre offset est également facultatif. Si nous ne donnons pas les paramètres facultatifs suivants, alors il traversera toutes les données.

foreach (new LimitIterator(new ArrayIterator($data)) as $d) {
    var_dump($d);
}
// string(1) "A"
// string(1) "B"
// string(1) "C"
// string(1) "D"
// string(1) "E"
// string(1) "F"
// string(1) "G"
// string(1) "H"
// string(1) "I"
// string(1) "J"
// string(1) "K"

Performance lorsque les paramètres sont erronés

Ensuite, regardons ce qui se passe si les paramètres sont erronés, c'est-à-dire s'il y a un problème avec le décalage ou le taille de données requise, comment ces opérations se comporteront. La fonction

var_dump(array_slice($data, $offset, 150));
// array(8) {
//     [0]=>
//     string(1) "D"
//     [1]=>
//     string(1) "E"
//     [2]=>
//     string(1) "F"
//     [3]=>
//     string(1) "G"
//     [4]=>
//     string(1) "H"
//     [5]=>
//     string(1) "I"
//     [6]=>
//     string(1) "J"
//     [7]=>
//     string(1) "K"
//   }
var_dump(array_slice($data, 15, $pageSize));
// array(0) {
// }

array_slice() est compatible avec les erreurs de décalage en affichant un tableau vide. Si la quantité de données dépasse la norme, toutes les données après le décalage seront affichées.

var_dump($pages[15]);
// NULL

array_chunk() renverra bien sûr une valeur NULL pour les données dont l'indice n'existe pas.

foreach (new LimitIterator(new ArrayIterator($data), $offset, 150) as $d) {
    var_dump($d);
}
// string(1) "D"
// string(1) "E"
// string(1) "F"
// string(1) "G"
// string(1) "H"
// string(1) "I"
// string(1) "J"
// string(1) "K"

foreach (new LimitIterator(new ArrayIterator($data), 15, $pageSize) as $d) {
    var_dump($d);
}
// Fatal error: Uncaught OutOfBoundsException: Seek position 15 is out of range

LimitIterator 则是对于偏移量错误的数据直接返回错误异常信息了。这也是类模式处理的好处，有错误都会以异常的形式进行返回，方便我们对异常进行后续的处理。

其它的测试大家还可以自行检测，比如偏移是 0 或者是负数的情况，数据量是 0 或者是负数的情况。这些我就不多写了，大家可以根据已有的知识先猜想一下结果会是什么样的，然后再自己写代码验证一下结果是符合自己的预期，这样学习的效果会非常棒哦！（在下方测试代码链接中有测试，结果里面是有坑的哦）

总结

一个功能使用了三种方式来实现，这就是代码的魅力。至于哪个好哪个坏我们不多做评价，一切都是以业务为核心来进行选取。类似的功能虽说并不常见，但很多项目里都会遇到，比如说后台用户组管理就会非常常见，一般来说后台用户分组如果不是特别大型的 ERP 项目都不会很多，但有时候也会达到需要分页的程度，这时候，我们就可以考虑考虑使用今天所学的知识来做咯！

测试代码：

https://github.com/zhangyue0503/dev-blog/blob/master/php/202008/source/PHP%E4%B8%AD%E7%9A%84%E6%95%B0%E7%BB%84%E5%88%86%E9%A1%B5%E5%AE%9E%E7%8E%B0%EF%BC%88%E9%9D%9E%E6%95%B0%E6%8D%AE%E5%BA%93%EF%BC%89.php

推荐学习：php视频教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!