Een Processor/Core/Kernel class doorloopt allerlei stappen. Mag de consructor deze stappen triggeren/uitvoeren? Even een heeeeel erg versimpeld voorbeeldje met 3 fictieve functies.
<?php
class Processor {
private $request;
public function __constructor($request) {
$this->request = $request.
$this->initializeRequest();
$this->executeRequest();
$this->sendResponse();
}
}
?>
Zou de constructor deze functies mogen triggeren? Is dat oké volgens het OOP principe?
Kun je ook uitleggen waarom Dos? Ik roep geen enkele functie van buiten de class aan. Dus alles moet vanuit de class zelf worden gestart. Hoe kan ik dat dan volgens jou het beste doen?
Ik vind het leuk dat je reageert... maar het is dan ook wel handig als je aangeeft hoe het volgens jou dan wel moet :-)
Dos: ook dat is niet mooi. Een static method die en class aanmaakt is een factory en niks anders en het enige wat een factory mag doen is het aanmaken van een object (die vervolgens zichzelf gebruiksklaar maakt).
Je moet dit soort dingen gewoon nooit bij aanmaken doen :)
>> Omdat je een object met private constructor niet kunt aanmaken.
Oké... maar net zeg je nog dat ik geen static method moet gebruiken :-s
>> Ja, erg hè? :P
Alle gekheid op een stokje. Het gaat er niet om of het wel of niet erg is.
Waar het om gaat is het volgende. En ik hoop dat je dan even kunt meedenken met me ;)
Het enige wat die class kan doen, is een request afhandelen. Niks meer en niks minder. Ward vertelde ooit op het forum dat als je een bepaalde functie hebt die je altijd aanroept na het initialiseren van een class, dat je dan die functie net zo goed in de constructor kunt stoppen, aangezien de functie blijkbaar altijd moet worden aangeroepen. Goed punt toch? Dus vanuit dat oogpunt zou ik de execute functie vanuit de constructor kunnen aanroepen.
Is dit dan wel oké?
<?php
class Processor {
private $request;
public function __constructor($request) {
$this->request = $request.
$this->execute();
}
private function execute() {
$this->initializeRequest();
$this->executeRequest();
$this->sendResponse();
}
Nee, de constructor maakt een object klaar voor gebruik. Niks meer niks minder. Hij voert niks uit, hij doet niks, alleen klaar maken voor gebruik.
Het maakt niks uit als hij het uitvoeren naar een andere functie verplaatst en het vervolgens aanroept. Dan gebeurd het nog steeds tijdens de constructie periode.
Ik zou niet eens die Request meegeven als constructor argument, waarom zou je niet 2 verschillende requesten mogen afhandelen met hetzelfde object?
Nogmaals: Is het erg als je 2 requesten afhandelt? Nee toch? Waarom zou je je dan gaan beperken?
