Esta definición solo establece las variables miembro requeridas por el paginador, ya que se trata de una clase auxiliar y está destinada a la paginación solo porque se basará en una conexión válida con el servidor MySQL y en una consulta ya definida que agregaremos los parámetros necesarios para paginar los resultados. Comenzaremos con el método constructor..

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

Muy simple ¿verdad? Este método solo establece la conexión de la base de datos del objeto y la consulta necesaria, después de eso calcula el número total de filas recuperadas por esa consulta sin ningún límite ni parámetro de salto, este total es necesario para crear los enlaces para el paginador.

Tenga en cuenta que, para simplificar, no estamos realizando una comprobación de errores ni ninguna otra validación de los parámetros dados, pero en una aplicación real, estas comprobaciones serán necesarias..

Recuperando resultados

Ahora vamos a crear el método que realmente pagine los datos y devuelva los resultados.

_limit = $ limit; $ this -> _ page = $ page; if ($ this -> _ limit == 'all') $ query = $ this -> _ query;  else $ query = $ this -> _ query. " LÍMITE " . (($ this -> _ page - 1) * $ this -> _ limit). ", $ esto -> _ límite";  $ rs = $ this -> _ conn-> query ($ query); while ($ row = $ rs-> fetch_assoc ()) $ results [] = $ row;  $ result = new stdClass (); $ result-> page = $ this -> _ page; $ result-> limit = $ this -> _ limit; $ resultado-> total = $ esto -> _ total; $ resultado-> datos = $ resultados; devuelve $ resultado;  

Analicemos esto paso a paso, primero establecemos el límite y los parámetros de la página, que de forma predeterminada se establecen en 10 y 1 respectivamente. Luego verificamos si el usuario requiere un número determinado de filas o todas ellas, basándonos en esto y en el parámetro de página que configuramos LÍMITE parámetro de la consulta, el "- 1" de la página tiene en cuenta el hecho de que estamos comenzando las páginas en 1 en lugar de 0.

Después de esto, simplemente evaluamos la consulta y obtenemos los resultados, finalmente creamos un nuevo objeto de resultados que contiene el límite, la página y los parámetros totales de la consulta ejecutada, así como los datos para cada una de las filas recuperadas..

Visualización de enlaces de paginación

Ahora escribamos el método usado para obtener los enlaces de paginación..

_limit == 'all') return "; $ last = ceil ($ this -> _ total / $ this -> _ limit); $ start = (($ $ this -> _ page - $ links)> 0)? $ this -> _ page - $ enlaces: 1; $ fin = (($ $ esto -> _ página + $ enlaces) < $last ) ? $this->_page + $ links: $ last; $ html = '
'; $ class = ($ this -> _ page == 1)? "discapacitado" : ""; $ html. = '
_límite . '& page ='. ($ esto -> _ página - 1). '">«
'; if ($ start> 1) $ html. = '
_límite . '& page = 1 "> 1
'; $ html. = '
... 
';  para ($ i = $ inicio; $ i <= $end; $i++ )  $class = ( $this->_page == $ i)? "activo": ""; $ html. = '
_límite . '& page ='. $ i. '">'. $ i. '
';  si ($ fin < $last )  $html .= '
... 
'; $ html. = '
_límite . '& page ='. $ ultimo. '">'. $ último. '
';  $ class = ($ this -> _ page == $ last)? "discapacitado" : ""; $ html. = '
_límite . '& page ='. ($ esto -> _ página + 1). '">»
'; $ html. = '
'; devuelve $ html;  

Este es un método bastante largo, algo así como 34 líneas de código, así que ahora vamos a explicar lo que está pasando en este método..

1. Primero evaluamos si el usuario requiere un número dado de enlaces o todos ellos, en el segundo caso simplemente devolvemos una cadena vacía ya que no se requiere paginación.
2. Después de esto, calculamos la última página según el número total de filas disponibles y los elementos requeridos por página.
3. Luego tomamos el parámetro de enlaces que representa la cantidad de enlaces que se muestran debajo y encima de la página actual, y calculamos el enlace de inicio y fin para crear.
4. Ahora creamos la etiqueta de apertura para la lista y configuramos la clase con el parámetro de clase de lista y agregamos el enlace "página anterior", tenga en cuenta que para este enlace verificamos si la página actual es la primera, y si es así, establecemos La propiedad deshabilitada del enlace..
5. En este punto, mostramos un enlace a la primera página y un símbolo de puntos suspensivos en caso de que el enlace de inicio no sea el primero..
6. A continuación, agregamos los enlaces a continuación y por encima de la página actual en función de los parámetros de inicio y finalización calculados previamente. En cada paso, evaluamos la página actual de nuevo, la página de enlace mostrada y configuramos la clase activa en consecuencia..
7. Después de esto, mostramos otro símbolo de puntos suspensivos y el enlace a la última página en caso de que el enlace final no sea el último..
8. Finalmente, mostramos el enlace "siguiente página" y establecemos el estado de desactivación cuando el usuario está viendo la última página, cerramos la lista y devolvemos la cadena HTML generada..

Eso es todo lo que hay en el Paginator.class, por supuesto, podríamos agregar definidores y captadores para la conexión de la base de datos, el límite, la página, la consulta y los parámetros totales, pero por simplicidad lo mantendremos de esta manera.

4. Index.php

Ahora crearemos el archivo a cargo de usar la clase Paginator y mostrar los datos, así que primero permítame mostrarle la base HTML.

      
 
 
Paginación de PHP
 
 
 
 
Ciudad
 
País
 
Continente
 
Región
 
 
 
 
 
 
   

Bastante simple, este archivo solo muestra una tabla que rellenaremos con la información recuperada de la base de datos, tenga en cuenta que para este ejemplo estoy usando bootstrap para el estilo de página básico.

Usando el paginador

datos); $ i ++):?>  datos [$ i] ['Nombre']; ?> datos [$ i] ['País']; ?> datos [$ i] ['Continente']; ?> datos [$ i] ['Región']; ?>   

Ahora para hacer uso de nuestra clase Paginator, agregue el siguiente código php en la parte superior del documento.

getData ($ page, $ limit); ?>

Este script es bastante simple, solo requerimos nuestra clase Paginator, tenga en cuenta que este código asume que este archivo está en el mismo directorio que el index.php archivo, si este no es el caso, debe actualizar la ruta en consecuencia.

Luego creamos la conexión a nuestra base de datos utilizando la biblioteca MySQLi, recuperamos los parámetros del paginador de la solicitud GET y configuramos la consulta, ya que este no es un artículo sobre MySQL o ninguno de ellos. No entraré en detalles sobre la conexión o la consulta. utilizado aquí.

Por último, creamos el objeto Paginator y recuperamos los resultados de la página actual..

Mostrando los resultados

Ahora para mostrar los resultados obtenidos, agregue el siguiente código al cuerpo de la tabla.

datos); $ i ++):?>  datos [$ i] ['Nombre']; ?> datos [$ i] ['País']; ?> datos [$ i] ['Continente']; ?> datos [$ i] ['Región']; ?>   

Aquí simplemente estamos iterando a través del atributo de datos de resultados que contiene los registros de ciudades y creando una fila de tabla para cada una de ellas..

Enlaces de paginación

Ahora para mostrar los enlaces del paginador, agregue el siguiente código debajo de la tabla.

createLinks ($ enlaces, 'paginación paginación-sm'); ?> 

Al método Paginator createLinks pasamos los obtenidos. campo de golf parámetro y la clase css para los enlaces de paginación utilizados desde bootstrap. Aquí está el resultado de la página creada..

Conclusión

Esto debería proporcionarle todo lo que necesita saber para comenzar a utilizar la paginación en su aplicación..

No dudes en dejar preguntas, comentarios o comentarios generales en el feed a continuación.!

¿Todavía atascado? Intente contactar a uno de nuestros desarrolladores de PHP con experiencia en Envato Studio.