CakePHP pagination

In CakePHP we have different functionality for the developer, if we want to try to develop a flexible and user-friendly web application at that time we can include the pagination concept in the framework. Showing a sensible number of records per page has forever been a basic piece of each application and used to cause numerous cerebral pains for designers. CakePHP facilitates the weight of the designer by giving a fast, simple method for paginating information. One of the principal hindrances of making adaptable and easy-to-use web applications is planning a natural UI.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

What is CakePHP pagination?

The improvement of an easy-to-use connection point is one of the primary issues for the web application designers since when the client composes their source code, then, at that point, the length of code and intricacy expand. Likewise, the overseeing of hundreds or thousands of records on a solitary page was difficult to deal with. Besides, it invests in some opportunity to bring the subtleties on a solitary page because of which the web application experiences their unwavering quality and client fulfillment. Along these lines, CakePHP designers give a pagination capacity to defeat the many records in a solitary page. Numerous applications will more often than not fill in size and intricacy rapidly, and architects and software engineers observe they can’t adapt to showing hundreds or thousands of records.

To show the client’s movement record on a solitary page, then, at that point, the length of the records is excessively extended because of which we have confronted these issues

The client needs to look over different times to see the data.

It won’t be difficult to look through the site on compact gadgets like cell phones, tablets, and so forth
It will diminish the web application execution.

From these circumstances, CakePHP presents an ideal pagination strategy.

Pagination strategy for CakePHP: It isolates all records into equivalent parts and shows a solitary record to the client as indicated by the need of the application.

Model: assume we have 200 records on each page and we need to show just 20 records. Like basic maths to get the full sheets, it’s 200/20 = 10. Because of this, we really want to give away to the client to see the subtleties on each page either in a little screen like a versatile or work area gadget.

How to Configure CakePHP pagination?

Now let’s see how we can configure pagination in CakePHP as follows.

At times we really want to do pagination in CakePHP utilizing a conventional SQL inquiry; subsequently, the CakePHP predefined pagination usefulness is lost. Custom Pagination in CakePHP

We can carry out pagination strategy in the Model or Behavior when we are utilizing standard SQL inquiry in CakePHP. Simply need to ensure that the outcome can’t be gotten with center model techniques or a custom locator prior to carrying out custom questions pagination. However, we can’t simply utilize the standard pagination on the custom questions, we need to abrogate the paginate capacities in model or conduct.

To utilize our own strategy/rationale to supersede the CakePHP pagination in the model, we really want to add two capacities: paginate () and paginateCount().

To show a bunch of information that is colossal, we can utilize pagination and this component is accessible with cake PHP 4 which is exceptionally simple to utilize.

In the following screenshot, we can see multiple database entries with different values as follows.

Now we need to display the records on a single page with few entries so that we can use pagination. So that reason first we need to configure the routes.php file as follows.

<?php use Cake\Http\Middleware\CsrfProtectionMiddleware;
use Cake\Routing\Route\DashedRoute;
use Cake\Routing\RouteBuilder;
$routes->setRouteClass(DashedRoute::class);
$routes->scope('/', function (RouteBuilder $builder) {
$builder->registerMiddleware('csrf', new CsrfProtectionMiddleware([
'httpOnly' => true,
]));
$builder->applyMiddleware('csrf');
//$builder->connect('/pages',['controller'=>'Pages','action'=>'display', 'home']);
$builder->connect('posts',['controller'=>'Posts','action'=>'index']);
$builder->fallbacks();
});

Now we need to create the controller.php file and write the following code as follows.

<?php namespace App\Controller;
use App\Controller\AppController;
class PostsController extends AppController {
public function index(){
$this->loadModel('rounds);
$articles = $this->rounds->find('all')->order(['rounds.id ASC']);
$this->set('rounds', $this->paginate($rounds, ['limit'=> '4']));
}
}
?>

Explanation

In the above file we write the logic of display records, here we try to display 4 records on a single page.

Now we need to create a directory and under that directory create a new index.php file and write the following code as follows.

<div>
<?php foreach ($rounds as $key=>$rounds) {?>
<a href="#">
<div>
<p>= $rounds->title ?> </p>
<p>= $rounds->details ?></p>
</div>
</a>
<br>
<?php }
?>
<ul class="pagination">
= $this->Paginator->prev("
= $this->Paginator->numbers() ?>
= $this->Paginator->next(">>") ?>
</ul>
</div>

Now execute the above code in localhost. The end result of the above implementation we illustrated by using the following screenshot as follows.

Using Controller Cakephp pagination

In the regulator, we start by characterizing the default question conditions pagination will use in the $paginate regulator variable. These circumstances serve as the reason for your pagination questions. They are increased by the sort, direction, limit, and page boundaries passed in from the URL. It is critical to note that the request key should be characterized in an exhibit structure like beneath:

class RoundController extends AppController
{
public $paginate = [
'limit' => 20,
'order' => [
'Round.title' => 'Desc'
]
];
public function initialize()
{
parent::initialize();
$this->loadComponent('Paginator');
}
}

In this code, we can include different options that are supported by the find () method as per our requirements.

class RoundController extends AppController
{
public $paginate = [
'fields' => ['Rounds.id', 'Rounds.created'],
'limit' => 20,
'order' => [
'Rounds.title' => 'Desc'
]
];
public function initialize()
{
parent::initialize();
$this->loadComponent('Paginator');
}
}

While you can pass the vast majority of the question choices from the paginate property it is often cleaner and more straightforward to wrap up your pagination choices into a Custom Finder Method. You can characterize the locater pagination utilizing finder choice.

Conclusion

From the above article, we have taken in the essential idea of the CakePHP pagination and we also see the representation and examples. From this article, we learned how and when we use the CakePHP pagination.

The above is the detailed content of CakePHP pagination. For more information, please follow other related articles on the PHP Chinese website!