Vous êtes sur la page 1sur 13

Atelier Zend Framework : Utiliser Zend

Paginator dans un environnement MVC simple

par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

Date de publication : 03/12/2008

Dernière mise à jour :

Beaucoup de questions se posent sur Zend_Paginator, avec parfois des problèmes.


Pourtant ce composant, apparu dans ZendFramework 1.6, est très simple à prendre en
main, à condition toujours de savoir comment il fonctionne en interne. Un composant
principal, qui pilote un adaptateur basé sur un pattern Itérateur, rien de plus, rien de moins.
Nous allons tenter de décortiquer tout cela ensemble.
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

I - Présentation du composant Zend_Paginator......................................................................................................... 3


II - Mise en place de l'architecture d'exemple.............................................................................................................5
II-A - Base de données..........................................................................................................................................5
II-B - Modèle MVC................................................................................................................................................. 6
III - Utiliser le paginateur............................................................................................................................................. 8
III-A - Pagination de la liste des membres............................................................................................................ 8
III-B - Afficher la barre de pagination.................................................................................................................... 9
IV - Améliorer.............................................................................................................................................................10
IV-A - Des URLs plus propres............................................................................................................................. 10
IV-B - Gestion des contextes XML et JSON....................................................................................................... 10
V - Autres utilisations du paginateur......................................................................................................................... 12
VI - Conclusions.........................................................................................................................................................13

-2-
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

I - Présentation du composant Zend_Paginator

Zend_Paginator est un composant apparu en version 1.6 de Zend Framework. Son nom est explicite, je ne vais pas
faire un dessin, encore que si, allez :

Diagramme de classes simplifié de Zend_Paginator

Voila, ça va mieux déja pour la compréhension. Ce diagramme de classes est simplifié, il ne présente pas toutes
les méthodes, ni les attributs de classe.
Zend_Paginator est la classe principale qui va piloter la pagination d'un objet adaptateur. Zend_Paginator ne
fonctionne donc pas sans adaptateur, il y a agrégation comme on peut le noter.
Une méthode factory() sert à simplifier la création d'un paginateur avec directement le bon adaptateur dedans, en
sachant qu'il existe déjà à ce jour 5 adaptateurs dans la distribution de Zend Framework.
Vous pouvez créer vos propres adaptateurs, à condition qu'ils implémentent Zend_Paginator_Adapter_Interface,
et vous pouvez les charger dans Zend_Paginator grâce à sa dépendance envers Zend_Loader_PluginLoader
(classe permettant de charger des composants utilisateurs de manière simple et pratique).

Les adaptateurs ont tous un nom très explicite. Je rappelle que pour Iterator, il prend en paramètre une classe
implémentant l'interface PHP Iterator. Null lui, sert à charger dans le paginateur rien... Le but est d'avoir une instance
de Zend_Paginator mais sans données à piloter (je rappelle qu'on ne peut créer une instance de Zend_Paginator
sans adaptateur).
Il n'y a ensuite plus rien à faire au sujet de l'adaptateur, tout va se passer sur l'instance de Zend_Paginator.

Zend_Paginator va alors avoir les rôles suivants :

-3-
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

1 Créer une fenêtre de visibilité paramétrable sur les données de l'adaptateur


2 Proposer une façade de pilotage des données, via itération entre autres
3 Donner le moyen d'afficher, via une vue Zend_View, le contrôle de la pagination

-4-
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

II - Mise en place de l'architecture d'exemple

Nous allons mettre en place un petit exemple concret en utilisant le modèle MVC de Zend Framework, basé sur le
composant Zend_Controller.
Rien de bien complexe, le but est de se pencher sur Zend_Paginator en affichant une liste de membres, depuis une
table d'une base de données. Accessoirement, nous verrons en dernière partie d'autres listes.

A ce titre, voici un détail de l'architecture :

1 MembresController va contenir une méthode liste qui renverra une liste paginée des membres en base
2 IndexController servira pour deux exemples annexes du paginateur, n'ayant rien à voir avec les membres

architecture du projet Paginateur

II-A - Base de données

Notre base de données est des plus simples, nous n'allons même pas la détailler. Nous supposerons une table
"membres", avec une seule colonne "nom".
En revanche, nous allons utiliser quelques artefacts de Zend Framework pour nous simplifier la vie.
Voici déjà la configuration de la base de données, sous forme de fichier .ini gérable par Zend_Config.

-5-
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

main.ini
cache.lifetime = 3600

db.adapter = pdo_mysql
db.params.host = localhost
db.params.password = anaska
db.params.username = julien
db.params.dbname = mle

Nous vous supposons à l'aise avec le paquet Zend_Db, et ses sous paquets comme Zend_Db_Table ou
Zend_Db_Select, même si nous tâcherons de rester très simples.

II-B - Modèle MVC

Concernant le modèle MVC, nous allons détailler les fichiers un à un, là encore le but est de ne pas faire dans le
superflu pour ne pas compliquer la compréhension.
Nous rajouterons cependant quelques fonctionnalités annexes, comme par exemple une route personnalisée
permettant de bénéficer d'URL plus sympas.
L'architecture MVC présentée ici est très classique. index.php ne fait qu'inclure bootstrap.php, dont voici le détail :

bootstrap.php
<?php
require_once 'Zend/Loader.php';
Zend_Loader::registerAutoload();

$appPath = dirname(__FILE__);
$rootPath = dirname($appPath);

set_include_path(get_include_path() . PATH_SEPARATOR .
$appPath . '/default/models/' . PATH_SEPARATOR
);

// --------------------- CONFIG -----------------------------------


$config = new Zend_Config_Ini($appPath .'/default/config/main.ini');

// ------------------------ CACHE ----------------------------------


$backOptions = array();
$frontOptions = array('lifetime' => $config->cache->lifetime,
'automatic_serialization'=>true);
$cache = Zend_Cache::factory('Core', 'APC', $frontOptions, $backOptions);

// ----------------------- DB ---------------------------------------
try {
$db = Zend_Db::factory($config->db);
$db->getConnection();
Zend_Db_Table_Abstract::setDefaultAdapter($db);
Zend_Db_Table_Abstract::setDefaultMetadataCache($cache);
} catch (Zend_Exception $e) {
exit($e);
}

// ------------------------------ PAGINATOR --------------------------


Zend_View_Helper_PaginationControl::setDefaultViewPartial('pagination.phtml');

// ------------------------- MVC -------------------------------------


$vr = Zend_Controller_Action_HelperBroker::getStaticHelper('ViewRenderer');
$vr->setViewScriptPathSpec(":controller-:action.:suffix");

$frontController = Zend_Controller_Front::getInstance();
$frontController->setControllerDirectory($appPath . '/default/controllers/');
$frontController->throwExceptions(true);

$frontController->dispatch();

-6-
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

Les sections logiques sont séparées par des lignes de commentaires pour plus de visibilité.
Idem pour la gestion des erreurs : nous demandons explicitement une connexion à la base ( $db->getConnection()
), et si problème, on fait un vulgaire exit() PHP.

Concernant la partie Zend_Db, que du "classique" nous prenons soin par contre d'insérer
une instance de Zend_Cache_Core afin de mettre en cache les métadonnées issues de
la base de données. Ceci pour des raisons de performance évidentes, même si ici ce
genre de problématique est loin de nous concerner.

Vient ensuite la section MVC. Rien de particulier, si ce n'est que l'on change la manière dont les vues sont appelées
avec une inflection 'controller-action.suffix' au lieu de 'controller/action.suffix' par défaut. Question de convenance...
Aussi, nous instruisons le contrôleur frontal de renvoyer les exceptions qu'il rencontre. Il n'y a donc pas de contrôleur
dédié à la gestion d'erreurs.

-7-
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

III - Utiliser le paginateur

La paginateur n'est pas difficile d'utilisation. Il utilise obligatoirement un adaptateur (nous allons voir cela), et il peut
en option utiliser une aide de vue (Zend_View_Helper_PaginationControl).
Cette aide est très pratique pour piloter de manière simple le paginateur depuis une vue. Aussi, cette aide va permettre
de gérer la barre de navigation qui affichera les pages restantes, précédentes, suivantes.
Cette barre est totalement isolée du reste de la vue, et est représentée par un fichier, ici pagination.phtml, aussi
appelé "partial" ou vue partielle. Ce fichier est pris relativement au scriptPath de la vue, soit dans notre cas default/
view/scripts/
La méthode setDefaultViewPartial() de l'aide de vue Zend_View_Helper_PaginationControl, va permettre de
spécifier quelle sera la vue partielle utilisée dans toutes les vues, pour la navigation. Autrement, il faudra le préciser
à chaque fois que l'on fait un rendu, ce qui est un peu pénible.

III-A - Pagination de la liste des membres

Voyons dès lors à quoi ressemble notre MembresController :

MembresController
<?php
class MembresController extends Zend_Controller_Action
{
public function listeAction()
{
$TMembres = new TMembres();
$select = $TMembres->select();
$page = Zend_Paginator::factory($select);
$page->setPageRange(2);
$page->setCurrentPageNumber($this->_getParam('page', 1));
$page->setItemCountPerPage($this->_getParam('par', 1));
$this->view->listeMembres = $page;
}
}

Notre classe TMembres est une Zend_Db_Table très classique, mise en include_path, nous pouvons donc l'appeler
directement, nous ne détaillerons pas son code ici.
Nous créons ensuite une instance de Zend_Paginator, grâce à sa fabrique factory(). Celle-ci va automatiquement
reconnaitre l'objet Zend_Db_Table_Select, et agir en conséquence, c'est à dire créer un objet Zend_Paginator
encapsulant un objet Zend_Paginator_Adapter_DbTableSelect

Dès lors, Zend_Paginator va piloter l'objet select sous-jacent, et nous, nous allons piloter le paginateur. Il n'y a rien
à faire sur l'objet select : pas besoin de chercher des résultats, ou quoi que ce soit d'autre, au lieu de cela, il faut dire
au paginateur quelles données il va devoir chercher.
La méthode setCurrentPageNumber() définit la page en cours dans la fenêtre de pagination des données.
La méthode setItemCountPerPage() renseigne sur le nombre de résultats par page
A partir de là, Zend_Paginator va piloter l'objet adaptateur pour lui faire chercher la bonne fenêtre de données, il
n'y a plus rien à faire (d'obligatoire). Eventuellement, nous décidons de changer l'amplitude des pages que l'aide
partielle de vue nous présentera. Au lieu de montrer 10 numéros de pages par défaut, nous choisissons grâce à
setPageRange() de n'en afficher que 2.
Enfin, nous passons directement l'instance du paginateur ($page ici) à la vue, et c'est fini pour la partie contrôleur.
Passons à la vue : l'affichage des données

membres-liste.phtml
<ul>
<?php
foreach ($this->listeMembres as $membre) {
echo "<li>$membre->nom</li>";
}
?>
</ul>

-8-
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

membres-liste.phtml
<?php
echo $this->listeMembres;

La vue va se servir de l'instance Zend_Paginator passée (listeMembres) et va itérer dessus. Zend_Paginator


implémentant l'interface IteratorAggregate, il va en fait proxier les appels de l'itérateur sur l'objet adaptateur sous-
jacent.
Un simple foreach fait donc l'affaire ! Et dans notre cas, nous récupérons des objets Zend_Db_Table_Row, en réalité
la boucle foreach a traversé l'itérateur des Zend_Db_Table_Rowset aussi (la magie des itérateurs de PHP5 est
toujours impressionnante)
La ligne echo $this->listeMembres; demande d'afficher l'instance Zend_Paginator. Celle-ci possède une méthode
__toString(), et elle va chercher la vue partielle que nous lui avions définie (setDefaultViewPartial()) afin d'afficher
la barre de pagination. A quoi ressemble-t-elle ? C'est ce que nous allons voir.

III-B - Afficher la barre de pagination

pagination.phtml
<?php if ($this->pageCount): ?>
<div id="paginationControl">

<!-- Previous page link -->


<?php if (isset($this->previous)): ?>
<a href="<?php echo $this->url(array('page' => $this->previous)); ?>">&lt; <?php echo "précédent"; ?
></a> |
<?php else: ?>
<span class="disabled">&lt; <?php echo "précédent"; ?></span> |
<?php endif; ?>

<!-- Numbered page links -->


<?php foreach ($this->pagesInRange as $page): ?>
<?php if ($page != $this->current): ?>
<a href="<?php echo $this->url(array('page' => $page)); ?>"><?php echo $page; ?></a> |
<?php else: ?>
<span class="current"><?php echo $page; ?></span> |
<?php endif; ?>
<?php endforeach; ?>

<!-- Next page link -->


<?php if (isset($this->next)): ?>
<a href="<?php echo $this->url(array('page' => $this->next)); ?>"><?php echo "suivant" ?> &gt;</a>
<?php else: ?>
<span class="disabled"><?php echo "suivant" ?> &gt;</span>
<?php endif; ?>
</div>
<?php endif; ?>

En fait, on ne s'est pas embêtés puisque le code ci-dessus est issu de la documentation officielle, tel quel
(short_open_tags PHP épurés).
Toutes les données $this-> sont mises à disposition par Zend_Paginator, la documentation officielle les détaille
toutes.

Pagination au format HTML

-9-
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

IV - Améliorer

IV-A - Des URLs plus propres

Actuellement pour interroger nos pages, nous sommes obligés d'utiliser le routeur par défaut. Nous avons donc des
URLs comme http://somehost/paginateur/membres/liste/page/2/par/4 pour afficher la page 2 de la liste des membres
à raison de 4 résultats par page.
C'est pas très joli, nous allons monter rapidement une URL plus sympathique :

rajout à bootstrap.php
<?php
$configRoute = new Zend_Config_Ini($appPath .'/default/config/routes.ini');
$frontController->getRouter()->addConfig($configRoute);

routes.ini
listemembre.type = "Zend_Controller_Router_Route_Regex"
listemembre.route = "liste-des-membres(?:-page-(\d+))?(?:-par-(\d+))?\.html"
listemembre.reverse = "liste-des-membres-page-%d-par-%d.html"
listemembre.defaults.controller = membres
listemembre.defaults.action = liste
listemembre.defaults.page = 1
listemembre.defaults.par = 2
listemembre.map.1 = page
listemembre.map.2 = par

Voila, nous pouvons dès lors interroger nos pages avec http://somehost/paginateur/liste-des-membres-page-2-
par-4.html , plus cool non?
Et les paramètres sont facultatifs, donc ceci fonctionne : http://somehost/paginateur/liste-des-membres-page-2.html,
ou encore http://somehost/paginateur/liste-des-membres-par-4.html
Des problèmes restent à prévoir sur les URLs inverses, car l'inverseur va créer des liens dans lesquels ces paramètres
là apparaitront obligatoirement. Pour éviter cela, il faut dériver les classes de routage, si vous vous sentez, c'est
votre exercice ;-)

IV-B - Gestion des contextes XML et JSON

La commutation de contextes est un sujet à part entière, nous allons juste en toucher 2 mots très rapides.
Il est tellement simple, partant de notre belle liste HTML, d'en faire des listes XML et JSON, que nous n'allons pas
nous en priver. Pour faire réagir les contextes, par défaut, il faut passer un paramètre GET appelé 'format', et lui
donner les valeurs 'xml' ou 'json'.

rajouts à MembresController
<?php
class MembresController extends Zend_Controller_Action
{
public function init()
{
$this->_helper->contextSwitch->addActionContext('liste', array('json','xml'))
->initContext();
}

public function postDispatch()


{
if ($this->_helper->contextSwitch->getCurrentContext() == 'json') {
$this->_helper->json->sendJson($this->view->listeMembres->getCurrentItems()->toArray());
}
}
}

init() initialise la commutation de contexte.

- 10 -
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

postDispatch() permet de court-circuiter les actions par défaut du commutateur, car notre objet Zend_Paginator ne
peut être encodé en JSON de manière directe.
Il faut donc détecter le contexte JSON, et demander le rendu JSON des entités actuellement dans le paginateur
(getCurrentItems()), sous forme de tableau (c'est un Zend_Db_Table_Rowset sinon)
On obtient donc quelque chose comme ceci :

liste au format json


[{"nom":"Julien"},{"nom":"estelle"}]

Pour le XML, il suffit de créer une vue avec l'extension xml.phtml, et de créer le XML que l'on souhaite dedans. Par
exemple comme cela :

membres-liste.xml.phtml
<?php
$xml = new XMLWriter();
$xml->openMemory();
$xml->startDocument();
$xml->startElement('membres');
foreach ($this->listeMembres as $membre) {
$xml->writeElement('membre', $membre->nom);
}
$xml->endElement();
$xml->endDocument();
echo $xml->flush();
?>

Liste au format XML

- 11 -
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

V - Autres utilisations du paginateur

Sortons de la liste des membres, pour montrer d'autres utilisations du paginateur.


Par exemple avec l'adaptateur array, ou iterator, voyez plutôt cet IndexController qui démontre ceci :

indexController
<?php
class IndexController extends Zend_Controller_Action
{
public function xmlAction()
{
$xml = "<data><nom>julien</nom><nom>estelle</nom></data>";
$page = Zend_Paginator::factory(new SimpleXMLIterator($xml));
$page->setCurrentPageNumber($this->_getParam('page'));
$page->setItemCountPerPage(2);
$this->view->items = $page;
}

public function arrayAction()


{
$phpFunctions = get_defined_functions();
$page = Zend_Paginator::factory(array_shift($phpFunctions));
$page->setCurrentPageNumber($this->_getParam('page'));
$page->setItemCountPerPage(50);
$this->view->items = $page;
}
}

Nous ne montrons pas les vues, qui coulent de source. xmlAction() utilise un SimpleXMLIterator pour itérer sur tous
les noeuds d'un code XML. arrayAction() nous montre une liste paginée de toutes les fonctions internes à PHP.
On aurait pu tout aussi bien choisir un Zend_Feed::factory('une-url') qui retourne un objet implémentant Iterator, par
exemple.

- 12 -
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/
Atelier Zend Framework : Utiliser Zend Paginator dans un environnement MVC simple
par Julien Pauli (Tutoriels, article et conférences PHP et developpement web) (Blog)

VI - Conclusions

Oui Zend_Paginator possède encore tout un tas de méthodes que nous n'avons pas vues. Elles restent
simples à maitriser tant qu'on a compris le principe d'agrégation et de pilotage de Zend_Paginator sur le
Zend_Paginator_Adapter_* qu'il contient. Aussi, on aurait pu utiliser un objet Zend_Config avec le paginateur,
on aurait pu changer le style de la barre de navigation à travers les pages. Le composant est (comme d'habitude
avec Zend Framework) très souple : l'étendre pour le personnaliser n'est pas compliqué, j'ai d'ailleurs quelques
idées à proposer prochainement, comme le fait de pouvoir mettre en cache permanent les données sur lesquelles le
paginateur est déjà passé (la proposition est lancée sur le tracker de ZF).

La SPL et les itérateurs


Zend_Db expliqué en détail
Les expressions régulières en PHP
Débuter avec le modèle MVC de ZendFramework

- 13 -
Copyright © 2008 - Julien Pauli. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes,
documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E
de dommages et intérêts.
http://julien-pauli.developpez.com/tutoriels/zend-framework/atelier/paginator/