Questa definizione imposta solo le variabili membro richieste dall'impaginatore, poiché questa è una classe helper ed è destinata solo all'impaginazione, si baserà su una connessione valida al server MySQL e una query già definita che aggiungeremo i parametri necessari per impaginare i risultati. Inizieremo con il metodo del costruttore.

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

Abbastanza semplice, vero? Questo metodo imposta solo la connessione al database dell'oggetto e la query necessaria, dopo di che calcola il numero totale di righe recuperate da quella query senza limiti né salta parametri, questo totale è necessario per creare i collegamenti per l'impaginatore.

Si noti che per semplicità non stiamo eseguendo il controllo degli errori o qualsiasi altra convalida dei parametri dati, ma in un'applicazione reale i controlli saranno necessari.

Recupero dei risultati

Ora creiamo il metodo che impaginerà effettivamente i dati e restituirà i risultati.

_limit = $ limit; $ this -> _ page = $ page; if ($ this -> _ limit == 'all') $ query = $ this -> _ query;  else $ query = $ this -> _ query. "LIMITE". (($ 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; ritorno $ risultato;  

Analizziamo questo passo alla volta, prima impostiamo i parametri limite e di pagina, che per impostazione predefinita sono impostati rispettivamente su 10 e 1. Quindi controlliamo se l'utente richiede un dato numero di righe o tutte, basandoci su questo e sul parametro della pagina che impostiamo LIMITE parametro della query, il "- 1" della pagina tiene conto del fatto che stiamo avviando le pagine in 1 anziché in 0.

Dopo questo, valutiamo semplicemente la query e otteniamo i risultati, infine creiamo un nuovo oggetto risultati che contiene il limite, la pagina e i parametri totali della query eseguita, nonché i dati per ciascuna delle righe recuperate.

Visualizzazione dei collegamenti di impaginazione

Ora scriviamo il metodo usato per ottenere i collegamenti di paginazione.

_limit == 'all') return "; $ last = ceil ($ this -> _ total / $ this -> _ limit); $ start = (($ this -> _ page - $ links)> 0)? $ this -> _ pagina - $ link: 1; $ end = (($ this -> _ pagina + $ link) < $last ) ? $this->_page + $ links: $ last; $ html = '
'; $ class = ($ this -> _ page == 1)? "Disabilitato" : ""; $ html. = '
_limit. '& page ='. ($ this -> _ page - 1). '">«
'; if ($ start> 1) $ html. = '
_limit. '& Page = 1" > 1
'; $ html. = '
... 
';  for ($ i = $ start; $ i <= $end; $i++ )  $class = ( $this->_page == $ i)? "attivo" : ""; $ html. = '
_limit. '& page ='. $ i. '">'. $ i. '
';  if ($ end < $last )  $html .= '
... 
'; $ html. = '
_limit. '& page ='. $ ultimo. '">'. $ ultimo. '
';  $ class = ($ this -> _ page == $ last)? "Disabilitato" : ""; $ html. = '
_limit. '& page ='. ($ questo -> _ pagina + 1). '">»
'; $ html. = '
'; return $ html;  

Questo è un metodo piuttosto lungo, qualcosa come 34 linee di codice, quindi ora spieghiamo cosa sta succedendo in questo metodo.

1. Per prima cosa valutiamo se l'utente richiede un determinato numero di collegamenti o tutti loro, nel secondo caso restituiamo semplicemente una stringa vuota poiché non è richiesta alcuna impaginazione.
2. Successivamente, calcoliamo l'ultima pagina in base al numero totale di righe disponibili e agli elementi richiesti per pagina.
3. Quindi prendiamo il parametro links che rappresenta il numero di link da visualizzare sotto e sopra la pagina corrente e calcola il link di inizio e fine per creare.
4. Ora creiamo il tag di apertura per l'elenco e ne impostiamo la classe con il parametro list class e aggiungiamo il link "pagina precedente", osservando che per questo link controlliamo se la pagina corrente è la prima e, in tal caso, impostiamo la proprietà disabilitata del collegamento.
5. A questo punto viene visualizzato un collegamento alla prima pagina e un simbolo di puntini di sospensione nel caso in cui il collegamento iniziale non sia il primo.
6. Successivamente aggiungiamo i collegamenti sotto e sopra la pagina corrente in base ai parametri di inizio e fine calcolati in precedenza, in ogni passaggio valutiamo nuovamente la pagina corrente e visualizziamo la classe attiva di conseguenza..
7. Successivamente visualizziamo un altro simbolo di ellissi e il link all'ultima pagina nel caso in cui il link finale non sia l'ultimo.
8. Infine mostriamo il link "pagina successiva" e impostiamo lo stato disabilitato quando l'utente sta visualizzando l'ultima pagina, chiudi l'elenco e restituisci la stringa HTML generata.

Questo è tutto ciò che c'è in Paginator.class, ovviamente potremmo aggiungere setter e getter per la connessione al database, il limite, la pagina, la query e i parametri totali, ma per semplicità lo manterremo in questo modo.

4. Index.php

Ora creeremo il file responsabile dell'uso della classe Paginator e della visualizzazione dei dati, quindi prima lascia che ti mostri l'HTML di base.

      
 
 
Impaginazione PHP
 
 
 
 
Città
 
Nazione
 
Continente
 
Regione
 
 
 
 
 
 
   

Abbastanza semplice, questo file mostra solo una tabella che compileremo con le informazioni recuperate dal database, notare che per questo esempio sto usando bootstrap per lo stile di pagina di base.

Utilizzando The Paginator

dati); $ i ++):?>  dati [$ i] [ 'name']; ?> dati [$ i] [ 'Country']; ?> dati [$ i] [ 'Continente']; ?> dati [$ i] [ 'Regione']; ?>   

Ora per fare uso della nostra classe Paginator aggiungi il seguente codice php nella parte superiore del documento.

getData ($ page, $ limit); ?>

Questo script è abbastanza semplice, abbiamo appena richiesto la nostra classe Paginator, si noti che questo codice presuppone che questo file sia nella stessa directory del index.php file, se questo non è il caso, è necessario aggiornare il percorso di conseguenza.

Quindi creiamo la connessione al nostro database usando la libreria MySQLi, recuperiamo i parametri di paginator dalla richiesta GET e impostiamo la query, poiché non si tratta di un articolo su MySQL o di uno di questi non entrerò nei dettagli sulla connessione o sulla query usato qui.

Infine, creiamo l'oggetto Paginator e recuperiamo i risultati per la pagina corrente.

Visualizzazione dei risultati

Ora per visualizzare i risultati ottenuti aggiungere il seguente codice al corpo della tabella.

dati); $ i ++):?>  dati [$ i] [ 'name']; ?> dati [$ i] [ 'Country']; ?> dati [$ i] [ 'Continente']; ?> dati [$ i] [ 'Regione']; ?>   

Qui, semplicemente, stiamo iterando attraverso l'attributo dei dati dei risultati contenente i record delle città e creando una riga della tabella per ognuno di essi.

Collegamenti di paginazione

Ora per visualizzare i collegamenti di impaginatore aggiungere il seguente codice sotto la tabella.

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

Al metodo createLink di Paginator passiamo il risultato ottenuto link parametro e la classe css per i collegamenti di paginazione usati da bootstrap. Ecco il risultato della pagina creata.

Conclusione

Questo dovrebbe fornirti tutto ciò che devi sapere per essere operativo con paginazione nella tua applicazione.

Non esitare a lasciare domande, commenti o commenti generali nel feed sottostante!

Ancora bloccato? Prova a contattare uno dei nostri esperti sviluppatori PHP su Envato Studio.