In CakePHP, what does parent::initialize() do? - cakephp

Question

I see the line
parent::initialize();
in all the preloaded methods in CakePHP 3.x and in all the 3.x documentation.
Removing the line, or forgetting to add the line to new methods, doesn't seem to have any negative effects.
Which begs the question, what does it do?
Apologies is this is a totally noob question..

Answer 1

It is simple OOP. It calls the parent method of the same name.
Aclass {
public function foo() { echo 'bar'; };
}
Bclass extends Aclass {
public function foo() { parent::foo(); echo 'foobar'; }
}
Just try it and remove the parent call, you'll see what it does. The parents usually should be called, especially in methods like the initialize() callbacks. However, when to call or not to call them is a decision you have to make. It depends on if you want or need to call the parent methods logic or not. This is called "overloading".
This allows you to add functionality before or after the parent call of the method, which is a pretty common thing. I recommend you to read the OOP chapter of the php manual.

Answer 2

In your Controller’s initialize() method you can define any components you want loaded, and any
configuration data for them:
public function initialize()
{
parent::initialize();
$this->loadComponent('Security');
$this->loadComponent('Paginator');
$this->loadComponent('RequestHandler');
}

Answer 3

It is exactly what it says your running a method from the parent class. So the for example.
class AppController extends Controller {
public function initialize() {
echo 'hello world';
// do more sh*t
}
}
class UsersController extends AppController {
public function initialize() {
parent::initialize(); // this will run the method initialize from app controller that will echo 'hello world'
// do more sh*t
}
}

Answer 4

It's not doing anything when you remove it because there's nothing inside the parent initialize function, but it's there just in case you want to extend functionality from your parent controller to a child controller. For example:
In AppController there's a beforeFilter function that defines what I want to run before the page loads. Let's say I want a function to run on every single page - a simple redirect function if the user isn't logged in:
if (!$this->Auth->user()) {
$this->redirect('Users/login');
}
Instead of putting this in the beforeFilter on every single controller I go to, I can put it inside the beforeFilter of AppController.
My other controllers, like UsersController, extend from AppController:
class UsersController extends AppController {
So in the beforeFilter in my UsersController I can do:
public function beforeFilter(Event $event) {
parent::beforeFilter($event);
}
Now I inherit this redirect behavior from the parent controller(AppController), so that same code also runs in my child controller (UsersController) - and no matter what controller users go to they get redirected to the login page if they're not logged in.
This works the same way with parent::initialize(); you're inheriting what functionality exists inside the initialize function in the parent controller. This is just functionality included to eliminate redundant code.
So basically, if you see code that you're using on every single page, find a way to make it a bit object oriented by removing it and placing it in a file that your code can inherit from. It's along the same vein of moving the header and footer code out of HTML documents and placing them in their own php files so you can make a change in one area and have all affected derivatives updated, rather than editing the header and footer in every HTML document.