construct en properties
Een vraagje over construct i.c.m. properties. Is het de bedoeling dat class properties ALTIJD vanuit de __construct functie worden gedeclareerd? Anders gezegd, als je class properties gebruikt, betekent dit dan automatisch dat je een __construct functie moet maken? Stel dat je wel class properties wilt gebruiken, maar je wil deze in een aparte functie declareren. Moet je ze dan toch eerst via de __construct functie declareren?
Voorbeeld, ik wil een username declareren in de functie setUsername(). Mag het dan zo:
Code (php)
of moet ik echt perse eerst in de __construct de property $username declareren. Dus zo:
Code (php)
Gewijzigd op 02/01/2013 13:26:51 door Ozzie PHP
Allereerst heeft jou code voorbeeld helemaal geen toegevoegde waarde. Of de username bij default nou '' heeft of null maakt natuurlijk niks uit en ik vind null zelfs mooier.
Als je het hebt over default waardes zet ik die gewoon bij het declareren neer, lekker makkelijk en je houdt je constructor schoon. Bijv:
Om mijn voorbeeldje te pakken... jij zou het dan dus zo doen??
Code (php)
Maar tegenwoordig ben ik daarvan afgestapt en gebruik ik PHPdoc om aan te geven welke type het is, mocht het niet al duidelijk zijn.
Code (php)
Maar het wordt dan gauw zo'n rommeltje.
Maar als ik het dus zo doe, dan is het ook gewoon goed OOP?
Ozzie PHP op 02/01/2013 13:51:02:
alles in de construct liep te declareren met lege strings en arrays
Dat is een beetje raar. Je kunt ook gewoon default parameters kiezen.
Dan kan je kiezen of je je username passed in de constructor of niet, en zoniet kun je nog altijd de username instellen via de setter.
Code (php)
Gewijzigd op 02/01/2013 14:01:41 door - Raoul -
public $username = null;
is hetzelfde als dit
public $username;
Ik snap wel wat je bedoelt, maar als je dit met elkaar vergelijkt:
1)
Code (php)
2)
Code (php)
dan is voorbeeld 1 een stuk rustiger. En nu gaat het maar om 1 variabele, maar wat als het er 10 zijn.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
class User
{
private $username = null;
public function __construct($first_name = null, $last_name = null)
{
if (isset($first_name) && isset($last_name)) {
$this->setUsername($first_name, $last_name);
}
}
public function setUsername($first_name, $last_name)
{
$this->username = $first_name . ' ' . $last_name;
}
}
?>
class User
{
private $username = null;
public function __construct($first_name = null, $last_name = null)
{
if (isset($first_name) && isset($last_name)) {
$this->setUsername($first_name, $last_name);
}
}
public function setUsername($first_name, $last_name)
{
$this->username = $first_name . ' ' . $last_name;
}
}
?>
@Ward: dat snap ik inderdaad, maar het ging erom of je properties wel of niet "moet" declareren in de __construct functie.
Feitelijk declareer je de class properties al direct bij het openen van de container class { … } met public, private of protected. En dat nog vóórdat je aan de slag gaat met de constructor.
Hoewel het technisch overbodig is, zou ik in dit geval dus ook een declaratie met = null gebruiken om expliciet in plaats van impliciet aan te geven dat een eigenschap in eerste instantie null is. Je hebt daarvoor namelijk een aparte setter in het leven geroepen. Bovendien is het niet vanzelfsprekend dat niet elke gebruiker een gebruikersnaam heeft.
Verder gebruik ik in lange listings vaak een lege constructor om aan te geven dat de constructor niet is vergeten maar verder geen rol speelt. Prototype wordt dan verkort:
Als je tienduizenden regels code hebt, voorkomt dit het zoekplaatje: wat zou $Username moeten zijn, waar en wanneer wordt $Username ingesteld, is $Username vereist of niet en waar is de constructor gebleven?
Je kunt dit wel declareren:
private $Username = null;
maar dat is precies hetzelfde als:
private $Username = null;
Dan zou ik dit nog logischer vinden:
private $Username = '';
omdat je dan kunt zien dat de variabele $username een string is.
Overigens grappig opmerking "Als je tienduizenden regels code hebt, voorkomt dit het zoekplaatje". Misschien zou je je classes een beetje korter moeten maken :D
Ozzie PHP op 02/01/2013 14:45:34:
Overigens grappig opmerking "Als je tienduizenden regels code hebt, voorkomt dit het zoekplaatje". Misschien zou je je classes een beetje korter moeten maken :D
Ik denk niet dat hij het heeft over tienduizenden regels code in 1 class. Heb je weleens aan een echt groot (denk aan > 1000 files) project gewerkt? Dan kan het heel goed voorkomen dat, zeker als je met meerdere mensen eraan werkt, de variablen op een rare plek aangepast worden
private $stringUsername = (string) null;
Met (string) null geef je aan dat je een lege string declareert. Wie daar overheen leest, kan uit het prefix ‘string’ in $stringUsername en $User::stringUsername afleiden dat dit een string is.
Inderdaad... kwestie van smaak en stijl.
Dat is het zeker Ward. Ik heb ook een tijd gehad dat ik alles aan het declareren was. Dan krijg je dit soort grappen:
Code (php)
Dan leest dit toch een stuk prettiger en rustiger:
Code (php)
Uit veel variabelen namen kun je al afleiden wat het zou moeten zijn. En die enkele keer dat je het echt niet weet, zoek je het even op. Maar inderdaad, kwestie van smaak en stijl.
Gewijzigd op 02/01/2013 15:04:13 door Ozzie PHP
Code (php)
Elke ontwikkelaar heeft zo zijn gewoonten. En soms ook eigenaardigheden. In een class met veel eigenschappen gebruik ik bijvoorbeeld liefst een alfabetische volgorde, zelfs als dat betekent dat $Achternaam met een A ver voor $Voornaam richting de staart van het alfabet staat.