Wie kann man Daten mit PHP paginieren

German (Deutsch) translation by Katharina Nevolina (you can also view the original English article)

Ich kann mich erinnern, dass ich vor Jahren, als ich anfing, in PHP und MySQL zu programmieren, wie aufgeregt ich das erste Mal war, dass ich Informationen aus einer Datenbank in einem Webbrowser anzeigen konnte.

Für jemanden, der wenig Datenbank- und Programmierkenntnisse hatte, zeigte mir diese Tabelle auf dem Bildschirm, basierend auf dem Code, den ich geschrieben habe (okay, ich kopierte ein Beispiel aus einem Buch - lassen Sie uns keine Haare teilen), ein triumphales Hoch. Ich habe damals vielleicht noch nicht all die Magie verstanden, die in der Arbeit herrschte, aber dieser erste Erfolg spornte mich zu größeren und besseren Projekten an.

Während mein Überschwang über Datenbanken vielleicht nicht mehr so ist wie früher,
Seit meiner ersten 'Hallo Welt' Begegnung mit PHP und MySQL bin ich begeistertauf die Fähigkeit,
die Dinge einfach und benutzerfreundlich zu machen.

Als Entwickler ist es ein Problem, mit dem ich ständig konfrontiert bin, eine große Menge an Informationen zu sammeln und leicht verständlich zu machen. Egal, ob es sich um die Kundenliste eines großen Unternehmens oder einen persönlichen MP3-Katalog handelt, die Tatsache, dass Sie sitzen und Reihen um Reihen um Daten anstarren müssen, kann entmutigend sein
und frustrierend. Was kann ein guter Entwickler tun? Paginieren!

1. Pagination

Pagination ist im Wesentlichen der Prozess, eine Reihe von Ergebnissen zu nehmen und zu verbreiten
Sie über die Seiten, damit sie leichter zu sehen sind.

Ich erkannte früh, dass wenn ich 5000 Reihen von Informationen hatte, nicht nur
anzuzeigenwäre es ein Kopfschmerz für jemanden zu versuchen und zu lesen, aber die meisten Browser würden nehmen
eine Internet-Ewigkeit (d. h. mehr als ungefähr fünf Sekunden), um sie anzuzeigen.

Um das zu lösen, kodiere ich verschiedene SQL-Anweisungen, um Datenblöcke herauszuziehen, und wenn ich es wäre
in guter Stimmung könnte ich sogar ein paar "next" und "previous" Buttons einwerfen.
Nach einer Weile müssen Sie diesen Code in jedes ähnliche Projekt einfügen und anpassen
es wurde alt. Schnell. Und wie jeder gute Entwickler weiß, erzeugt Faulheit Erfindungsreichtum
oder sowas ähnliches. Eines Tages habe ich mich hingesetzt und beschlossen, ein einfaches,
flexible und einfach zu bedienende PHP-Klasse, die automatisch die schmutzige Arbeit für
mich.

Ein kurzes Wort über mich und PHP-Klassen. Ich bin kein objektorientiertes Genie. In der Tat, ich kaum
benutze das Zeug. Aber nach dem Lesen einiger OOP Beispiele und Tutorials, und einige
ich habe mich entschieden, es zu drehen und Sie wissen was?
Es funktioniert perfekt für Seitenumbruch. Der hier verwendete Code ist in PHP 4 geschrieben, wird
es aberarbeiten in PHP 5.

2. Die Datenbank

Ich muss MySQL lieben. Nichts gegen die anderen Datenbanksysteme da draußen, aber für
mich, brauche ich nur MySQL. Und eine großartige Eigenschaft von MySQL ist, dass sie Ihnen etwas
kostenlose Beispieldatenbanken zum Spielen mit http://dev.mysql.com/doc/#sampledb geben.

Für meine Beispiele werde ich die World-Datenbank (~ 90k Zip) verwenden, die über
4000 Datensätze zum Spielen enthält, aber die Schönheit des PHP-Skripts, das wir erstellen werden,
dass es mit jeder Datenbank verwendet werden kann. Jetzt denke ich, wir können uns alle einig sein, wenn wir uns entscheiden,
um unsere Ergebnisse nicht zu paginieren, würden wir mit sehr langen und unhandlichen
Ergebnisse enden, wie folgt:

(Klicken Sie für die volle Größe, lächerlich langes Bild ~ 338k)

Also lassen Sie uns unsere Daten in leicht zu verdauende Bissen aufteilen:

Schön ist es nicht? Sobald Sie die Paginierungsklasse in Ihren Code eingefügt haben, können
Sie schnell und einfach verwandeln Sie eine große Menge von Daten in einfach zu navigierende Seiten mit
nur ein paar Zeilen Code. Ja wirklich.

3. Paginator

Dieses Beispiel besteht aus zwei Skripts, der wiederverwendbaren Paginator-Klasse und der Indexdatei, in der die Tabellenelemente und Steuerelemente angezeigt werden.

Paginator.class.php

Die Paginator-Klasse wird nur zwei Methoden und den Konstruktor haben, wir werden sie schrittweise erstellen und jeden Schritt im weiteren Verlauf erklären.

<?php

class Paginator {

     private $_conn;
        private $_limit;
        private $_page;
        private $_query;
        private $_total;

}

Diese Definition legt nur die Paginator-erforderlichen Membervariablen fest, da es sich um eine Hilfsklasse handelt, die nur für die Paginierung bestimmt ist und auf einer gültigen Verbindung zum MySQL-Server und einer bereits definierten Abfrage beruht, die die Parameter zum Paginieren der Ergebnisse anfügt. Wir beginnen mit der Konstruktormethode.

<?php

public function __construct( $conn, $query ) {
    
    $this->_conn = $conn;
    $this->_query = $query;

    $rs= $this->_conn->query( $this->_query );
    $this->_total = $rs->num_rows;
    
}

Ganz einfach oder? Bei dieser Methode wird nur die Datenbankverbindung des Objekts und die erforderliche Abfrage festgelegt. Anschließend wird die Gesamtzahl der von dieser Abfrage abgerufenen Zeilen ohne Limit- und Skip-Parameter berechnet. Diese Summe ist erforderlich, um die Links für den Paginator zu erstellen.

Beachten Sie, dass wir der Einfachheit halber keine Fehlerprüfung oder andere Validierung der gegebenen Parameter durchführen, aber in einer realen Anwendung werden diese Überprüfungen notwendig sein.

Ergebnisse abrufen

Jetzt erstellen wir die Methode, die die Daten paginiert und die Ergebnisse zurückgibt.

<?php
public function getData( $limit = 10, $page = 1 ) {
    
    $this->_limit   = $limit;
    $this->_page    = $page;

    if ( $this->_limit == 'all' ) {
        $query      = $this->_query;
    } else {
        $query      = $this->_query . " LIMIT " . ( ( $this->_page - 1 ) * $this->_limit ) . ", $this->_limit";
    }
    $rs             = $this->_conn->query( $query );

    while ( $row = $rs->fetch_assoc() ) {
        $results[]  = $row;
    }

    $result         = new stdClass();
    $result->page   = $this->_page;
    $result->limit  = $this->_limit;
    $result->total  = $this->_total;
    $result->data   = $results;

    return $result;
}

Analysieren wir diesen einen Schritt nach dem anderen, legen wir zuerst die Grenzwerte und Seitenparameter fest, die standardmäßig auf 10 bzw. 1 gesetzt sind. Wir überprüfen, ob der Benutzer eine bestimmte Anzahl von Zeilen oder alle von ihnen benötigt, basierend auf diesem und dem Seitenparameter, den wir den Parameter LIMIT der Abfrage setzen, berücksichtigt die "- 1" der Seite die Tatsache, dass wir beginnen die Seiten in 1 statt in 0.

Danach werten wir einfach die Abfrage aus und erhalten die Ergebnisse, schließlich erstellen wir ein neues Ergebnisobjekt, das die Limit-, Seiten- und Gesamtparameter der ausgeführten Abfrage sowie die Daten für jede der abgerufenen Zeilen enthält.

Paginierungslinks anzeigen

Lassen Sie uns nun die Methode schreiben, mit der die Paginationslinks abgerufen werden.

<?php
public function createLinks( $links, $list_class ) {
    if ( $this->_limit == 'all' ) {
        return '';
    }

    $last       = ceil( $this->_total / $this->_limit );

    $start      = ( ( $this->_page - $links ) > 0 ) ? $this->_page - $links : 1;
    $end        = ( ( $this->_page + $links ) < $last ) ? $this->_page + $links : $last;

    $html       = '<ul class="' . $list_class . '">';

    $class      = ( $this->_page == 1 ) ? "disabled" : "";
    $html       .= '<li class="' . $class . '"><a href="?limit=' . $this->_limit . '&page=' . ( $this->_page - 1 ) . '">&laquo;</a></li>';

    if ( $start > 1 ) {
        $html   .= '<li><a href="?limit=' . $this->_limit . '&page=1">1</a></li>';
        $html   .= '<li class="disabled"><span>...</span></li>';
    }

    for ( $i = $start ; $i <= $end; $i++ ) {
        $class  = ( $this->_page == $i ) ? "active" : "";
        $html   .= '<li class="' . $class . '"><a href="?limit=' . $this->_limit . '&page=' . $i . '">' . $i . '</a></li>';
    }

    if ( $end < $last ) {
        $html   .= '<li class="disabled"><span>...</span></li>';
        $html   .= '<li><a href="?limit=' . $this->_limit . '&page=' . $last . '">' . $last . '</a></li>';
    }

    $class      = ( $this->_page == $last ) ? "disabled" : "";
    $html       .= '<li class="' . $class . '"><a href="?limit=' . $this->_limit . '&page=' . ( $this->_page + 1 ) . '">&raquo;</a></li>';

    $html       .= '</ul>';

    return $html;
}

Das ist eine ziemlich lange Methode, etwa 34 Zeilen Code. Lassen Sie uns nun erklären, was in dieser Methode vor sich geht.

Zuerst bewerten wir, ob der Benutzer eine bestimmte Anzahl von Verknüpfungen oder alle benötigt, im zweiten Fall geben wir einfach eine leere Zeichenfolge zurück, da keine Seitennumerierung erforderlich ist.
Danach berechnen wir die letzte Seite basierend auf der Gesamtzahl der verfügbaren Zeilen und der benötigten Elemente pro Seite.
Dann nehmen wir den Link-Parameter, der die Anzahl der Links darstellt, die unterhalb und oberhalb der aktuellen Seite angezeigt werden sollen, und berechnen den Start- und End-Link zum Erstellen.
Jetzt erstellen wir das öffnende Tag für die Liste und setzen die Klasse davon mit dem Listenklassenparameter und fügen den Link "vorherige Seite" hinzu. Beachten Sie, dass wir für diesen Link prüfen, ob die aktuelle Seite die erste ist, und wenn ja, setzen wir die deaktivierte Eigenschaft der Verbindung.
An dieser Stelle zeigen wir einen Link zur ersten Seite und ein Auslassungssymbol, falls der Startlink nicht der erste ist.
Als nächstes fügen wir die Links unterhalb und oberhalb der aktuellen Seite basierend auf den zuvor berechneten Start- und Endparametern hinzu. In jedem Schritt werten wir die aktuelle Seite erneut auf der angezeigten Link-Seite aus und setzen die aktive Klasse entsprechend.
Danach zeigen wir ein anderes Ellipsen-Symbol und den Link zur letzten Seite an, falls der End-Link nicht der letzte ist.
Schließlich zeigen wir den Link "nächste Seite" an und setzen den deaktivierten Status, wenn der Benutzer die letzte Seite anzeigt, die Liste schließt und die generierte HTML-Zeichenfolge zurückgibt.

Das ist alles, was es in der Paginator.class gibt, natürlich könnten wir Setter und Getter für die Datenbankverbindung, die Begrenzung, die Seite, die Abfrage und die Gesamtparameter hinzufügen, aber der Einfachheit halber behalten wir es so bei.

4. Index.php

Jetzt erstellen wir die Datei, die für die Verwendung der Paginator-Klasse zuständig ist, und zeigen die Daten an. Lassen Sie mich Ihnen zunächst das Basis-HTML zeigen.

<!DOCTYPE html>
    <head>
        <title>PHP Pagination</title>
        <link rel="stylesheet" href="css/bootstrap.min.css">
    </head>
    <body>
        <div class="container">
                <div class="col-md-10 col-md-offset-1">
                <h1>PHP Pagination</h1>
                <table class="table table-striped table-condensed table-bordered table-rounded">
                        <thead>
                                <tr>
                                <th>City</th>
                                <th width="20%">Country</th>
                                <th width="20%">Continent</th>
                                <th width="25%">Region</th>
                        </tr>
                        </thead>
                        <tbody></tbody>
                </table>
                </div>
        </div>
        </body>
</html>

Ganz einfach, diese Datei zeigt nur eine Tabelle an, die wir mit den aus der Datenbank abgerufenen Informationen füllen werden. Beachten Sie, dass ich in diesem Beispiel den Bootstrap für das grundlegende Seitenstyling verwende.

Den Paginator benutzen

<?php for( $i = 0; $i < count( $results->data ); $i++ ) : ?>
        <tr>
                <td><?php echo $results->data[$i]['Name']; ?></td>
                <td><?php echo $results->data[$i]['Country']; ?></td>
                <td><?php echo $results->data[$i]['Continent']; ?></td>
                <td><?php echo $results->data[$i]['Region']; ?></td>
        </tr>
<?php endfor; ?>

Um nun unsere Paginator-Klasse nutzen zu können, fügen Sie den folgenden PHP-Code am Anfang des Dokuments hinzu.

<?php
    require_once 'Paginator.class.php';

    $conn       = new mysqli( '127.0.0.1', 'root', 'root', 'world' );

    $limit      = ( isset( $_GET['limit'] ) ) ? $_GET['limit'] : 25;
    $page       = ( isset( $_GET['page'] ) ) ? $_GET['page'] : 1;
    $links      = ( isset( $_GET['links'] ) ) ? $_GET['links'] : 7;
    $query      = "SELECT City.Name, City.CountryCode, Country.Code, Country.Name AS Country, Country.Continent, Country.Region FROM City, Country WHERE City.CountryCode = Country.Code";

    $Paginator  = new Paginator( $conn, $query );

    $results    = $Paginator->getData( $page, $limit );
?>

Dieses Skript ist recht einfach, wir benötigten nur die Paginator-Klasse. Beachten Sie, dass dieser Code davon ausgeht, dass sich diese Datei im selben Verzeichnis wie die index.php-Datei befindet. Wenn das nicht der Fall ist, sollten Sie den Pfad entsprechend aktualisieren.

Wir erstellen die Verbindung zu unserer Datenbank mit der MySQLi-Bibliothek, rufen die Paginator-Parameter aus der GET-Anfrage ab und setzen die Abfrage, da das kein Artikel über MySQL ist oder irgendetwas, das ich nicht in Details über die Verbindung oder die Abfrage bringen werde hier benutzt.

Schließlich erstellen wir das Paginator-Objekt und rufen die Ergebnisse für die aktuelle Seite ab.

Anzeigen der Ergebnisse

Um nun die erhaltenen Ergebnisse anzuzeigen, fügen Sie dem Tabellenkörper den folgenden Code hinzu.

<?php for( $i = 0; $i < count( $results->data ); $i++ ) : ?>
        <tr>
                <td><?php echo $results->data[$i]['Name']; ?></td>
                <td><?php echo $results->data[$i]['Country']; ?></td>
                <td><?php echo $results->data[$i]['Continent']; ?></td>
                <td><?php echo $results->data[$i]['Region']; ?></td>
        </tr>
<?php endfor; ?>

Hier durchlaufen wir einfach das Ergebnisdatenattribut, das die Städtedatensätze enthält, und erstellen für jede eine Tabellenzeile.

Seitenumbruch Links

Um nun die Paginator-Links anzuzeigen, fügen Sie den folgenden Code unterhalb der Tabelle hinzu.

<?php echo $Paginator->createLinks( $links, 'pagination pagination-sm' ); ?>

Für die Paginator createLinks-Methode übergeben wir den erhaltenen Link-Parameter und die css-Klasse für die Paginierungs-Links, die vom Bootstrap verwendet werden. Hier ist das Ergebnis der erstellten Seite.

Schlussfolgerung

Das sollte Ihnen alles liefern, was Sie wissen müssen, um mit der Pagination in Ihrer Anwendung zu beginnen.

Zögern Sie nicht, Fragen, Kommentare oder generelles Feedback im Feed unten zu hinterlassen!