So implementieren Sie Array-Paging in PHP, ohne eine Datenbank zu verwenden

In diesem Artikel erfahren Sie, wie Sie Array-Paging in PHP implementieren, ohne eine Datenbank zu verwenden. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.

Array-Paging-Implementierung in PHP (keine Datenbank)

In der täglichen Entwicklungsgeschäftsumgebung verwenden wir im Allgemeinen MySQL-Anweisungen, um die Paging-Funktion zu implementieren. Allerdings gibt es oft einige Daten, die nicht groß sind, oder die Paging-Funktion wird nur benötigt, um einige in PHP definierte Array-Daten abzurufen. Zu diesem Zeitpunkt müssen wir die Datenbank tatsächlich nicht jedes Mal abfragen. Wir können alle Daten in einer Abfrage abrufen und dann die Paging-Funktion auf PHP-Codeebene implementieren. Heute lernen wir einige Funktionstechniken kennen, mit denen diese Fähigkeit erreicht werden kann.

Zuerst bereiten wir noch die Testdaten vor.

$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;

Angenommen, $data sind alle Daten, die aus der Datenbank entnommen wurden, oder die Daten, die wir im PHP-Code fest codiert haben. Dann legen wir $p als empfangenen Anforderungsparameter fest und die aktuell aufgerufene Seite ist die zweite Seite. $currentPage wird verwendet, um die Offset-Korrektur abzufragen. In der Welt der Codeentwicklung beginnen alle Indexindizes bei 0, daher müssen wir die empfangenen Parameter um eins dekrementieren. Natürlich können Sie die vom Frontend übergebenen Parameter auch so einstellen, dass 0 als erste Seite verwendet wird. Ich werde nicht so viel erklären. Ich glaube, dass jeder seine Bedeutung verstehen wird, solange er es formell studiert oder an einem Entwicklungsprojekt teilgenommen hat.

Dann definieren wir die Anzahl der auf der aktuellen Seite angezeigten Informationen $pageSize, dh es werden nur 3 Daten erhalten. Schließlich haben wir den Offset berechnet, der dem Parameter in MySQLs LIMIT ähnelt. Seine Funktion besteht darin, uns mitzuteilen, von welchem ​​Element aus wir mit der Abfrage beginnen sollen, und dann mit $pageSize die Anzahl der Elemente abzufragen. Auf diese Weise können wir die Daten erhalten, die der aktuellen Seite entsprechen. (Es scheint, dass die Prinzipien des Pagings erklärt wurden)

array_slice

Die erste und grundlegendste und gebräuchlichste Paging-Methode ist die Verwendung der Funktion array_slice(). Seine Funktion besteht darin, einen Inhalt aus einem Array abzufangen und ein Array dieses Inhalts zurückzugeben. Die Funktion

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

array_slice() erfordert drei Parameter, der zweite Parameter ist der Offset und der dritte Parameter dient der Abfrage mehrerer Daten. Unter diesen ist der dritte Parameter optional. Wenn er nicht ausgefüllt wird, werden alle Daten nach dem aktuell eingestellten Offset angezeigt. Ist es genau das Gleiche wie unsere MySQL-Abfrageanweisung? Ja, sie selbst sind ähnliche Operationen. Die Funktion

array_chunk

array_chunk() gruppiert ein Array nach einem numerischen Parameter, d. h. sie teilt das Array in Unterarrays auf. Wir können den Subarray-Inhalt des angegebenen Indexes basierend auf dem geteilten Array erhalten. Diese Inhalte sind die Daten, die auf der aktuellen Seite angezeigt werden müssen.

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

In diesem Code geben wir den Inhalt des geteilten Arrays aus, und dann brauchen wir die zweite Seite, das sind die Daten mit Index 1. Wir können den erforderlichen Inhalt einfach direkt über das geteilte Array erhalten. Die Verwendung dieser Funktion zum Durchführen von Array-Paging ist sehr einfach und intuitiv und erfordert keine Berechnung des Offsets. Sie können die aktuelle Seite $currentPage und $pageSize direkt verwenden, um die Gruppierung von Daten abzuschließen Funktion. Machen Sie etwas Ähnliches.

LimitIterator

Das Letzte, was wir lernen müssen, ist die Fähigkeit, eine Iterator-Klasse zum Implementieren von Array-Paging zu verwenden. Dies wird seltener verwendet und wahrscheinlich wissen es nicht viele Leute, aber tatsächlich wurde die LimitIterator-Klasse eingeführt PHP5.1 Bereits bereitgestellt. Sein Zweck besteht darin, die Iteration über eine eingeschränkte Teilmenge der Elemente eines Iterators zu ermöglichen. Mit anderen Worten: Wenn unser Code das Iteratormuster verwendet und die Iteratorschnittstelle implementiert, können diese Iteratorklassen diese Klasse für Paging-Vorgänge verwenden.

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

Es sind 3 Instanziierungsparameter erforderlich. Der erste ist ein Iteratorobjekt. Da das Array kein Iteratorobjekt ist, verwenden wir eine ArrayIterator-Instanz, um unsere Array-Daten in ein Iteratorobjekt zu konvertieren. Die letzten beiden Parameter sind der Offset und die Anzahl der Daten. Dies ähnelt der Funktion array_slice(), der Unterschied besteht jedoch darin, dass der Offset-Parameter ebenfalls optional ist. Wenn wir die folgenden optionalen Parameter nicht angeben, werden alle Daten durchlaufen.

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"

Leistung bei falschen Parametern

Als nächstes schauen wir uns an, wie sich diese Vorgänge verhalten, wenn die Parameter falsch sind, das heißt, es liegt ein Problem mit dem Offset oder der erforderlichen Datengröße vor. Die Funktion

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() ist mit Offset-Fehlern kompatibel, indem sie ein leeres Array anzeigt. Wenn die Datenmenge den Standard überschreitet, werden alle Daten nach dem Offset angezeigt.

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

array_chunk() gibt natürlich einen NULL-Wert für Daten zurück, deren Index nicht existiert.

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视频教程

Das obige ist der detaillierte Inhalt vonSo implementieren Sie Array-Paging in PHP, ohne eine Datenbank zu verwenden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!