Ik heb een autoload functie in een class staan. Nu heb ik in die class ook een register method staan die die de autoload functie, jawel... registreert :)
In mijn code hoef ik dan alleen dit te doen:
<?php
$autoloader = new Autoloader();
$autoloader->register();
?>
Een tijdje terug hadden we het in een ander topic over het constructen van classes en wanneer je dat doet. Ward gaf toen aan dat als je een class hebt waarbij je altijd dit doet:
<?php
$foo = new Foo();
$foo->doFoo();
?>
Dat je dan net zo goed doFoo() vanuit de constructor kunt laten uitvoeren.
Bij mijn autoloader class heb je nu zo'n zelfde situatie. De enige method die je kunt aanroepen is register. Dus het enige wat je met die class kunt doen is dit:
<?php
$autoloader = new Autoloader();
$autoloader->register();
?>
Nu vraag ik me dus af of ik dan niet beter de register method vanuit de constructor kan triggeren. Als ik dan de autoloader wil registreren, dan hoef ik alleen nog maar dit te doen:
<?php
new Autoloader();
?>
Op zich wel lekker kort, maar is dit gebruikelijk? In principe zie je nu in de code niet wat er gebeurt, maar dat zou je met commentaar kunnen ondervangen:
<?php
// Register the autoload method.
new Autoloader();
?>
Graag jullie reactie.
Hmm goede vraag, over het algemeen wil je alles zo succint mogelijk hebben, dat betekent dat methodes en constructors datgene doen wat ze te horen doen. Als je deze regels na leeft, betekent dat je zelf de register() methode zult moeten aanroepen.
>> over het algemeen wil je alles zo succint mogelijk hebben
Suc-wat?
De vraag is dus inderdaad of je zelf die methode moet willen aanroepen. Je zou ook kunnen zeggen dat de class niet werkt zonder dat die method is aangeroepen, en dat je 'm daarom dus vanuit de constructor aanroept. Daarnaast wil je ook niet dat de register method meer dan 1x wordt aangeroepen. Dus ook dat zou een goede reden kunnen zijn om de constructor te gebruiken. Maar goed, ik weet dus niet of zoiets gebruikelijk is.
Laat ik er nog eens een ander voorbeeld bij geven:
Stel we hebben een class die iets configureert. Dat configureren moet eenmalig gebeuren.
Je zou dan dit kunnen doen:
<?php
$fc = new fooConfigurator($foo_data);
$fc->configure();
$new_foo = $fc->get();
?>
Echter, je zou ook het configureren vanuit de constructor kunnen triggeren:
<?php
$fc = new fooConfigurator($foo_data);
$new_foo = $fc->get();
?>
In het 1e voorbeeld zie je in de code wat er gebeurt. Echter, het enige wat ik van die class wil, is de geconfigureerde gegevens terugkrijgen. Dus het enige wat je eigenlijk aan die class wil vragen, is "geef mij de geconfigureerde gegevens". En als je het zo bekijkt, waarom zou je dan een public configure() method willen hebben?
Succint is Engels voor kort/bondig. Opvallend overigens wel dat succint wordt gebruikt om uit te leggen dat je het dus juist niet kort en bondig moet gaan doen....
Hoe dan ook, volgens mij is het gewoon weer zo'n 'wat heb je liever' vraag. Beide kan, verschil is minimaal en beide zijn duidelijk. Kies dus gewoon zelf en verdoe er niet veel meer tijd aan. Een 'absoluut' antwoord is er toch niet op te geven.
Allright, thanks Erwin. Ik dacht dat het misschien een rare constructie is om een soort "zelfregulerende" class te maken waar je geen variabele aan toekent en waarvan je geen enkele method aanroept. Maar als dat gewoon oké is, dan doet we dat gewoon! :)
Waarschijnlijk heb je gelijk, het is waarschijnlijk een kwestie van smaak. Overigens, wat ik bedoelde met succint is dat je methodes en dus ook constructors zo succint mogelijk moeten zijn. Dat wil zo veel betekenen als dat een methode/constructor alleen datgene hoort te doen wat het aangeeft/claimt te horen doen.
Even breder trekken, als het enige wat jou autoloader doet is register() en je hebt een kale constructor, waarom zou je dat in een aparte methode zetten?
>> Even breder trekken, als het enige wat jou autoloader doet is register() en je hebt een kale constructor, waarom zou je dat in een aparte methode zetten?
Waarom zou je wat in een aparte methode zetten? Je bedoelt de register functie?
Kun je na $foo = new Foo() helemaal niets zonder $foo->doFoo()? Dan hoort de aanroep van Foo::doFoo() volgens mij inderdaad in de constructor. Het draait erom dat de constructor een bruikbaar object oplevert; lukt dat nooit zonder een of meer methoden, dan roep je die in de constructor aan. Je mag hier dus ook een fout verwachten: "Ik kan zonder succesvolle Foo::doFoo() onmogelijk een object van de klasse Foo maken."
Overigens kunnen die vereiste methoden dan zowel public als private zijn. Die keuze staat daar eigenlijk los van.
Ja, aangezien je niets kunt met een autoloader die niet is geregistreerd, kun je in de constructor met $this->register() een private function register() aanroepen.
Het draait er, meer in het algemeen, om dat je niet "een PHP-object" krijgt, maar "een geldig Foo-object". Na bijvoorbeeld $db = new mysqli() verwacht je ook niet zomaar "een PHP-object", maar een MySQLi-object.
Zomaar "een PHP-object" maken kan namelijk ook zo:
<?php
// Dit is een geldig PHP-object:
$foo = (object) null;
// En ook dit is een geldig PHP-object:
$bar = new stdClass();
// Kijk maar, twee instanties #1 en #2:
echo '<pre>';
var_dump($foo);
var_dump($bar);
?>
