Explication détaillée de l'implémentation de la pagination des tableaux en PHP (hors base de données)-tutoriel php-php.cn

Dans les environnements commerciaux de développement quotidiens, nous utilisons généralement des instructions MySQL pour implémenter des fonctions 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.

À l'heure actuelle, 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;

Copier après la connexion

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 et la plus basique et la plus courante méthode de pagination consiste à utiliser la fonction array_slice(). 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"
//   }

Copier après la connexion

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"
//   }

Copier après la connexion

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é moins souvent, et probablement personne ne le sait, mais en fait. la classe LimitIterator Elle a été 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"

Copier après la connexion

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 paramètres suivants 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"

Copier après la connexion

Performances lorsque les paramètres sont erronés

Ensuite, regardons ce qui se passera si les paramètres sont erronés, c'est-à-dire qu'il y a un problème avec le décalage ou la taille des données requise .Une telle performance. 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) {
// }

Copier après la connexion

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

Copier après la connexion

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

Copier après la connexion

LimitIterator renvoie directement des informations sur les exceptions d'erreur pour les données avec un décalage incorrect. C'est également l'avantage du traitement en mode classe. Toutes les erreurs seront renvoyées sous forme d'exceptions, ce qui facilite notre traitement ultérieur des exceptions.

Vous pouvez également détecter d'autres tests par vous-même, par exemple lorsque le décalage est de 0 ou un nombre négatif, et lorsque la quantité de données est de 0 ou un nombre négatif. Je n'écrirai pas plus à ce sujet. Vous pouvez d'abord deviner quels seront les résultats en fonction de vos connaissances existantes, puis écrire votre propre code pour vérifier que les résultats sont conformes à vos attentes. L'effet d'apprentissage sera excellent ! (Il y a un test dans le lien du code de test ci-dessous, et le résultat est qu'il y a des pièges)

总结

一个功能使用了三种方式来实现，这就是代码的魅力。至于哪个好哪个坏我们不多做评价，一切都是以业务为核心来进行选取。类似的功能虽说并不常见，但很多项目里都会遇到，比如说后台用户组管理就会非常常见，一般来说后台用户分组如果不是特别大型的 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

Copier après la connexion

参考文档：

https://www.php.net/manual/zh/function.array-slice.php
https://www.php.net/manual/zh/function.array-chunk.php
https://www.php.net/limititerator

Copier après la connexion

推荐学习：《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!