/
Elaborazione dei dati

Paginatore e paginazione dei risultati in PHP

22. 08. 2019

Obsah článku

Quando abbiamo molti dati da scaricare, è educato dividerli in più pagine. Questo articolo non si occupa dell'implementazione pratica del passaggio dei numeri di pagina e dell'elencazione dei risultati, ma solo dell'estrazione teorica dei valori e del calcolo del codebook ottimale per rendere la consultazione di un gran numero di pagine il più semplice possibile.

Quanti risultati abbiamo

Per cominciare, dobbiamo scoprire quanti risultati abbiamo. Se i dati provengono da un database, possono essere contati in modo molto efficiente con la seguente istruzione SQL:

SELECT COUNT(*) FROM tabulka

Il calcolo è molto veloce perché il database mantiene le statistiche in un file di aiuto, quindi non tocca affatto i dati.

Se i dati vengono da qualche altra parte (e li abbiamo in un array, per esempio), possono essere contati con la funzione count():

$cisla = [3, 1, 4, 1, 5, 9, 2];
echo 'Il campo contiene' . count($cisla) . 'numeri.';

Limitare il numero di risultati

Un altro problema è la limitazione del numero di risultati. Se i dati sono nel database, basta mettere il parametro LIMIT nella dichiarazione SQL:

SELECT * FROM tabulka WHERE (cokoli) LIMIT 10

Questo comando otterrà sempre un massimo di 10 risultati, e renderà anche l'interrogazione più veloce perché il database non dovrà passare attraverso tutti i file di dati.

Se abbiamo dati da un'altra fonte (di nuovo un array), possiamo anche limitare i risultati a livello di PHP usando la variabile helper $iterator:

$pole = [...];
$iterator = 0;
$limit = 10;
foreach ($pole as $prvek) {
// qui è dove i dati vengono scaricati
$iterator++;
if ($iterator >= $limit) {
break; // Arresta il ciclo quando ha eseguito 10 volte
}
}

Saltare i primi X risultati

Quando siamo nella prima pagina, è abbastanza semplice, basta limitare il numero di risultati usando LIMIT. Ma cosa succede se sono alla terza pagina? Allora dobbiamo saltare i primi risultati X.

In SQL abbiamo un'elegante notazione per questo di nuovo:

SELECT * FROM tabulka WHERE (cokoli) LIMIT 10 OFFSET 20

Salta i primi 20 risultati e limita l'output successivo a 10 risultati, quindi emette l'intervallo <21 - 30>.

In PHP puro questo è gestito in due modi.

Se conosciamo gli indici dell'array, possiamo iniziare a leggerlo da un certo punto (il che è molto veloce):

$pole = [...];
$start = 20;
$limit = 10;
for ($i = $start; ($i <= $start + $limit && isset($pole[$i])); $i++) {
// qui è dove i dati vengono scaricati
}

Tuttavia, per un campo sconosciuto dobbiamo usare di nuovo l'iteratore e saltare gli elementi:

$pole = [...];
$iterator = 0;
$start = 20;
$limit = 10;
foreach ($pole as $prvek) {
if ($iterator < $start) {
$iterator++;
continue;
}
// in qualche modo i dati vengono scaricati qui
$iterator++;
if ($iterator >= $start + $limit) break;
}

Visualizzazione del paginatore/stepper ottimale

Supponiamo di conoscere il numero totale di elementi, il numero di elementi nella pagina e il numero di pagina corrente. Ora vogliamo rendere una barra che permetta la navigazione veloce di tutte le pagine con risultati di ricerca. Tuttavia, poiché ci sono molte pagine (dell'ordine di migliaia), non possiamo elencarle tutte in una volta, quindi dobbiamo scegliere intelligentemente alcune rappresentative che rappresentano al meglio la gamma tra le pagine.

Può apparire così:

1 | 15 | 30 | 36 | 45 | 60 | 72

Assegnazione:

Sono a pagina 36 di 72, come posizionare in modo ottimale i numeri di pagina? Bene, attraverso la sequenza.

Suggerimento: Per osservazione pratica ho scoperto che la parte sinistra del Paginator dovrebbe essere calcolata attraverso una sequenza aritmetica (così posso muovermi linearmente dello stesso numero di passi) e la parte destra attraverso una sequenza geometrica, che a sua volta rende facile fare un grande passo. Così, se voglio arrivare a una pagina particolare, salto prima un gran numero di elementi non necessari e poi affino la selezione tornando a sinistra.

Teoria della sequenza aritmetica (continuiamo ad aggiungere lo stesso numero):

$d = 10; // dimensione del passo
$a[1] = 1; // primo elemento
$a[2] = $a[1] + $d; // secondo elemento
$a[3] = $a[1] + 2 * $d;
$a[3] = $a[2] + $d;
$a[$n] = $a[1] + ($n - 1) * $d; // nono elemento
function getAritmeticItem(int $start, int $step, int $n): int
{
return $start + ($n - 1) * $step;
}

Teoria della sequenza geometrica (moltiplicare sempre per lo stesso numero):

$q = 10; // dimensione del passo
$a[1] = 1; // primo elemento
$a[2] = $a[1] * $q; // secondo elemento
$a[3] = $a[1] * $q * $q;
$a[3] = $a[1] * pow($q, 2);
$a[3] = $a[2] * $q;
$a[$n] = $a[1] * pow($q, $n - 1); // nono elemento
function getGeometricItem(int $start, int $step, int $q): int
{
return $start * pow($q, $step - 1);
}

$start = 1;
$current = 36;
$end = 72;

Jan Barášek   Více o autorovi

Autor článku pracuje jako seniorní vývojář a software architekt v Praze. Navrhuje a spravuje velké webové aplikace, které znáte a používáte. Od roku 2009 nabral bohaté zkušenosti, které tímto webem předává dál.

Rád vám pomůžu:

Související články

1.