Deze definitie is alleen de paginator vereiste lidvariabelen, omdat dit een helperklasse is en het is bestemd voor paginering alleen zal het vertrouwen op een geldige verbinding met de MySQL-server en een reeds gedefinieerde vraag dat we de parameters zullen toevoegen die nodig zijn om de resultaten te pagineren. We zullen beginnen met de constructormethode.

_conn = $ conn; $ this -> _ query = $ query; $ rs = $ this -> _ conn-> query ($ this -> _ query); $ this -> _ total = $ rs-> num_rows;  

Heel eenvoudig toch? Deze methode stelt alleen de databaseverbinding van het object en de benodigde query in, waarna het het totale aantal rijen berekent dat door die query is opgehaald zonder enige beperking of parameters overslaan, dit totaal is nodig om de koppelingen voor de paginator te maken.

Merk op dat we voor de eenvoud geen foutcontrole of andere validatie van de gegeven parameters uitvoeren, maar in een toepassing in de echte wereld zijn deze controles noodzakelijk.

Resultaten ophalen

Laten we nu de methode maken die de gegevens daadwerkelijk pagineert en de resultaten retourneert.

_limit = $ limiet; $ this -> _ page = $ pagina; if ($ this -> _ limit == 'all') $ query = $ this -> _ query;  else $ query = $ this -> _ query. " BEGRENZING " . (($ this -> _ page - 1) * $ this -> _ limit). ", $ this -> _ limit";  $ rs = $ this -> _ conn-> query ($ query); while ($ row = $ rs-> fetch_assoc ()) $ results [] = $ row;  $ resultaat = nieuwe stdClass (); $ result-> page = $ this -> _ pagina; $ result-> limit = $ this -> _ limit; $ resultaat-> totaal = $ dit -> _ totaal; $ result-> data = $ resultaten; return $ resultaat;  

Laten we dit stap voor stap analyseren, eerst stellen we de limiet- en paginaparameters in, die standaard respectievelijk de 10 en 1 instellen. Vervolgens controleren we of de gebruiker een bepaald aantal rijen of allemaal nodig heeft, baseer hierop en de paginaparameter die we hebben ingesteld BEGRENZING parameter van de query, houdt de "- 1" van de pagina rekening met het feit dat we de pagina's beginnen in 1 in plaats van 0.

Hierna evalueren we eenvoudig de query en krijgen de resultaten. Als laatste maken we een nieuw resultatenobject met de limiet, pagina en totale parameters van de uitgevoerde query en de gegevens voor elk van de opgehaalde rijen.

Pagineringkoppelingen weergeven

Laten we nu de methode schrijven die wordt gebruikt om de paginakoppelingen te krijgen.

_limit == 'all') return "; $ last = ceil ($ this -> _ total / $ this -> _ limit); $ start = (($ this -> _ page - $ links)> 0)? $ this -> _ pagina - $ links: 1; $ end = (($ this -> _ pagina + $ links) < $last ) ? $this->_page + $ links: $ laatste; $ html = '
'; $ class = ($ this -> _ page == 1)? "uitgeschakeld": ""; $ html. = '
_begrenzing . '& page ='. ($ this -> _ page - 1). '">«
'; if ($ start> 1) $ html. = '
_begrenzing . '& Page = 1" > 1
'; $ html. = '
... 
';  voor ($ i = $ start; $ i <= $end; $i++ )  $class = ( $this->_page == $ i)? "actief" : ""; $ html. = '
_begrenzing . '& page ='. $ i. '">'. $ i. '
';  if ($ end < $last )  $html .= '
... 
'; $ html. = '
_begrenzing . '& page ='. $ last. '">'. $ laatste. '
';  $ class = ($ this -> _ page == $ last)? "uitgeschakeld": ""; $ html. = '
_begrenzing . '& page ='. ($ this -> _ page + 1). '">»
'; $ html. = '
'; return $ html;  

Dit is een vrij lange methode, zoiets als 34 regels code, dus laten we nu eens uitleggen wat er in deze methode aan de hand is.

1. Eerst evalueren we of de gebruiker een bepaald aantal links of allemaal nodig heeft, in het tweede geval geven we gewoon een lege string terug omdat er geen paginering vereist is.
2. Hierna berekenen we de laatste pagina op basis van het totale aantal beschikbare rijen en de items die per pagina zijn vereist.
3. Vervolgens nemen we de parameter links die het aantal links weergeeft dat onder en boven de huidige pagina moet worden weergegeven, en berekenen we de begin- en eindlink om te maken.
4. Nu maken we de openingstag voor de lijst en stellen we de klasse daarvan in met de parameter lijstklasse en voegen we de koppeling "vorige pagina" toe, merk op dat we voor deze link controleren of de huidige pagina de eerste is en, zo ja, we instellen de gehandicapte eigenschap van de link.
5. Op dit punt tonen we een link naar de eerste pagina en een ellips-symbool in het geval dat de startlink niet de eerste is.
6. Vervolgens voegen we de links toe onder en boven de huidige pagina op basis van de eerder berekende start- en eindparameters, bij elke stap evalueren we de huidige pagina opnieuw de weergegeven koppelingspagina en stelt de actieve klasse dienovereenkomstig in.
7. Hierna tonen we een ander ellips-symbool en de link naar de laatste pagina in het geval dat de eindlink niet de laatste is.
8. Ten slotte geven we de link "volgende pagina" weer en stellen de uitgeschakelde status in wanneer de gebruiker de laatste pagina bekijkt, sluit de lijst en retourneert de gegenereerde HTML-tekenreeks.

Dat is alles wat er is met de Paginator.class, natuurlijk kunnen we setters en getters toevoegen voor de databaseverbinding, limiet, pagina, query en totale parameters, maar voor de eenvoud houden we het zo.

4. Index.php

Nu gaan we het bestand maken dat verantwoordelijk is voor het gebruik van de Paginator-klasse en de gegevens weergeven, dus laat me u eerst de HTML-basis laten zien.

      
 
 
PHP-paginering
 
 
 
 
stad
 
land
 
Continent
 
Regio
 
 
 
 
 
 
   

Heel eenvoudig: dit bestand geeft alleen een tabel weer die we vullen met de informatie die uit de database is opgehaald, merk op dat ik in dit voorbeeld bootstrap gebruik voor basispagina-opmaak.

De Paginator gebruiken

gegevens); $ i ++):?>  data [$ i] [ 'Naam']; ?> data [$ i] [ 'Country']; ?> data [$ i] [ 'Continent']; ?> data [$ i] [ 'Region']; ?>   

Gebruik voor het gebruik van onze Paginator-klasse de volgende php-code bovenaan het document.

getData ($ page, $ limit); ?>

Dit script is vrij eenvoudig, we hadden alleen onze Paginator-klasse nodig, merk op dat deze code veronderstelt dat dit bestand zich in dezelfde directory bevindt als de index.php bestand, als dit niet het geval is, moet u het pad dienovereenkomstig bijwerken.

Vervolgens maken we de verbinding met onze database met behulp van de MySQLi-bibliotheek, halen we de paginatorparameters op uit het GET-verzoek en stellen we de vraag in, omdat dit geen artikel op MySQL is of een daarvan zal ik niet in details over de verbinding of de query krijgen hier gebruikt.

Als laatste maken we het Paginator-object en halen we de resultaten voor de huidige pagina op.

De resultaten weergeven

Om de verkregen resultaten weer te geven, voegt u de volgende code toe aan de tabel.

gegevens); $ i ++):?>  data [$ i] [ 'Naam']; ?> data [$ i] [ 'Country']; ?> data [$ i] [ 'Continent']; ?> data [$ i] [ 'Region']; ?>   

Hier zijn we eenvoudig aan het itereren door het resultaatgegevenskenmerk dat de stedenrecords bevat en een tabelrij maakt voor elk daarvan.

Paginering Links

Om de paginator-links weer te geven, voegt u de volgende code onder de tabel toe.

createLinks ($ links, 'pagination pagination-sm'); ?> 

Aan de Paginator createLinks-methode geven we het verkregen resultaat door koppelingen parameter en de css-klasse voor de paginatielinks die worden gebruikt vanuit bootstrap. Dit is het resultaat van de gemaakte pagina.

Conclusie

Dit moet u alles bieden wat u moet weten om met behulp van paginering in uw toepassing aan de slag te gaan.

Aarzel niet om vragen, opmerkingen of algemene feedback achter te laten in de feed hieronder!

Nog steeds vast? Neem contact op met een van onze ervaren PHP-ontwikkelaars op Envato Studio.