class properties
Voorbeeld:
Code (php)
Moet ik nou aangeven dat $test een array is? Dus zo:
Code (php)
Of hoef je dit alleen maar aan te geven als een andere functie de $test property zou uitlezen en het risico bestaat dat deze nog niet geset is? Bijvoorbeeld zoiets als dit:
Code (php)
Gewijzigd op 13/02/2012 18:34:46 door Ozzie PHP
edit; als je alleen het initialiseren bedoelt: statics dienen van te voren geinit worden en normale vars binnen de __constructor()
Gewijzigd op 13/02/2012 18:27:51 door Jaron T
Code (php)
Toevoeging op 13/02/2012 18:35:46:
Hoe bedoel je dit?
edit; als je alleen het initialiseren bedoelt: statics dienen van te voren geinit worden en normale vars binnen de __constructor()
Je moet toch altijd initten? Om aan te geve of ie public of private is?
Dit heb je nodig als je later elementen toe wilt voegen en niet wilt hoeven checken of het al een array is.
$test[] = "blabla"
zal een foutmelding opleveren als je er niet eerst een array van hebt gemaakt.
$test = '';
is eigenlijk gewoon een initialisatie. Heb je niet nodig als je later altijd nog controleert of $test wel een (goede) waarde heeft, maar is handig als je er zeker van wilt zijn dat er altijd tenminste een lege string in zit.
Gewijzigd op 13/02/2012 19:01:35 door Jaron T
In strict OO horen properties in de constructor gedefinieerd te worden, alleen PHP is nergens script in en dus ook niet hier in. En dus kun je gewoon de waarde toevoegen terwijl je de property toevoegt aan de class:
Code (php)
Het is altijd verstandig om de properties te initten, maar het moet niet. Maar als je het niet doet krijgt het standaard public:
Code (php)
En dan als laatst, en dan hou ik echt mijn mond, kun je ook nog static properties meegeven aan een object. In dat geval kun je ze niet definiëren in de constructor, dus doe je het meteen. Een voorbeeld van static properties vind je hier.
Gewijzigd op 13/02/2012 19:09:15 door Wouter J
Jaron T op 13/02/2012 19:00:19:
Nee, je haalt declareren en initialiseren door elkaar. Zoals ik zei, static waardens dienen boven de constructor ge-init te worden en de rest er binnen.
Dan is bij mij altijd de vraag waarom. En niet om lullig te doen of om mijn gelijk te halen.
Als het een berekende waarde is dan is is het vanuit de taal al zo, maar voor constante waardes is het in elk geval geen beperking vanuit php zelf.
@Wouter:
"In strict OO horen properties in de constructor gedefinieerd te worden"
Wat bedoel je hier mee? Heb je een voorbeeldje? Of bedoel je gewoon dat je in je __construct zegt $this->test = 'test'.
"En dan als laatst, en dan hou ik echt mijn mond, kun je ook nog static properties meegeven aan een object."
bedoel jij constanten? die zie ik namelijk in het voorbeeld van jou staan.
Echter, bij statische properties dan denk ik aan:
static private test;
Erwin H op 13/02/2012 19:11:11:
Dan is bij mij altijd de vraag waarom. En niet om lullig te doen of om mijn gelijk te halen.
Als het een berekende waarde is dan is is het vanuit de taal al zo, maar voor constante waardes is het in elk geval geen beperking vanuit php zelf.
Jaron T op 13/02/2012 19:00:19:
Nee, je haalt declareren en initialiseren door elkaar. Zoals ik zei, static waardens dienen boven de constructor ge-init te worden en de rest er binnen.
Dan is bij mij altijd de vraag waarom. En niet om lullig te doen of om mijn gelijk te halen.
Als het een berekende waarde is dan is is het vanuit de taal al zo, maar voor constante waardes is het in elk geval geen beperking vanuit php zelf.
Het is eerder van, static waardes kunnen aangeroepen worden zonder dat er een object bestaat van de des betreffende class ( Test::getField(); ). Dus daarom dienen deze "perse" een waarden te krijgen buiten de constructor (waarom zou je hem anders static maken?)
Jaron T op 13/02/2012 19:55:15:
Het is eerder van, static waardes kunnen aangeroepen worden zonder dat er een object bestaat van de des betreffende class ( Test::getField(); ). Dus daarom dienen deze "perse" een waarden te krijgen buiten de constructor (waarom zou je hem anders static maken?)
Dat was precies het deel waar ik het (vanwege precies die reden) helemaal mee eens ben. Het ging me dus meer om de niet static waardes.
>> Wat bedoel je hier mee? Heb je een voorbeeldje? Of bedoel je gewoon dat je in je __construct zegt $this->test = 'test'.
Ja, dit bedoel ik. Een constructor is in de echte OO talen bedoelt om alle object properties te definiëren.
>> bedoel jij constanten? die zie ik namelijk in het voorbeeld van jou staan.
Echter, bij statische properties dan denk ik aan:
Oeps, ja je hebt helemaal gelijk!
>> maar de niet statische waarden moet je die nou wel of niet initten?
Het is een keuze die je maakt. Ik probeer toch wel behoort strak de OO talen te volgen, ook al ben ik in PHP en dus doe ik het vaak wel. Maar door gemak schiet het er ook wel eens in. Zoals in het voorbeeld dat ik hierboven gaf. Om nou helemaal een constructor te maken om StrictOO::someVars een array te laten zijn... Dan zou ik gewoon de class PHPOO gebruiken.
Maar als je toch al een constructor functie hebt, wat vaak zo is, dan zou ik het gewoon in de constructor stoppen.
Code (php)
Maar dit?
Code (php)
Ik ben het nu ff kwijt.
Toevoeging op 13/02/2012 23:35:05:
Hoe kan ik dit nou het beste doen:
- statische variabelen moet je dus altijd initten
- moet ik niet statische variabelen ook initten? of moet je die alleen declaren in de construct... of allebei? Ik wil graag de meest nette manier weten zodat ik dat overal kan doorvoeren. Kan iemand misschien een code voorbeeld geven van een class met daarin de volgende properties: een array, een lege string en een statische property. Kan iemand via een simpel code voorbeeldje even laten zien hoe je dit dan zou moeten initten / declaren???
Gewijzigd op 13/02/2012 23:35:48 door Ozzie PHP
variabelen declareren (bv. private $test;) buiten elke functie. Lijst die mooi op boven de constructor, met wat commentaar, waar nodig.
variabelen initiëren in de constructor.
Statisch betekent dat je het object zelf niet ter beschikking hebt.
Ik associeer static eigenlijk enkel met functies.
Neem nu bv. een class waar je wiskundige berekeningen groepeert.
Nulpunten van een parabool berekenen, op basis van a, b en c (y = ax² + bx + c), om maar iets te noemen
static properties ... het doet me wat denken aan whisky zonder alcohol; het gaat wat aan de essentie voorbij.
Als je properties nodig hebt, ben je in mijn ogen niet meer static bezig.
Php laat echter veel meer toe dan mijn buikgevoel goed acht, en ik ben niet echt de grote autoriteit, wat dit betreft.
Gewijzigd op 14/02/2012 00:26:47 door Kris Peeters
Mag je ook buiten de constructor initiëren?
Dus stel je hebt bijvoorbeeld een set() functie waarmee je wat dingen instelt en ook een paar properties set? Is dat toegestaan?
Toevoeging op 14/02/2012 06:48:02:
En stel nu je haalt in een bepaalde functie (niet de construct functie) informatie op die je wilt storen in een property. Is dat dan niet goed? Dus stel je hebt een user class en op een gegeven moment roep je een bepaalde functie aan, bijv. setBirthday() waarmee de verjaardag van de u ser in een property wordt gestopt. Is dat dan eigenlijk niet goed?
@Kris, als jij de variabelen declareert buiten de functie, geef je dan aan welk type het is?
Ozzie PHP op 14/02/2012 06:32:20:
Mag je ook buiten de constructor initiëren?
Dus stel je hebt bijvoorbeeld een set() functie waarmee je wat dingen instelt ...
Dus stel je hebt bijvoorbeeld een set() functie waarmee je wat dingen instelt ...
Ja.
Initiëren betekent maar dat je ze een beginwaarde geeft; een default; voor het geval die waarde niet geset wordt.
Niet iedere waarde hoeft per se een initiële waarde te hebben.
Het is dan de bedoeling dat je met setters echte waarden invult, zoals je ze nodig hebt op dat moment; bv. je setBirthday().
Je kan ook een aparte functie maken waarin je een hoop waarden initieert. Vaak noemt men die init()
Het is mogelijk dat een functie ook meerdere properties invult ... maar zo'n functie is strikt gezien geen pure setter.
Ozzie PHP op 14/02/2012 06:32:20:
@Kris, als jij de variabelen declareert buiten de functie, geef je dan aan welk type het is?
Ik niet. In php betekent dat trouwens heel weinig. Het geeft je geen enkele garantie dat dat type behouden blijft.
Omzetten naar het juiste type doe je wel in de setter.
bv. Als je weet dat een property een integer moet zijn, laat je in de setter niet toe dat een string wordt ingevoerd.
Het kan ook geen kwaad om, bij de getter, nog eens te parsen naar het juiste type.
bv. bij integers:
return (int) $this->getal;
}
Ik kan nog een voorbeeld geven van een uitgebreide class: (trouwens, heel handige class, om foto's te uploaden/resizen/...)
http://www.verot.net/download/class.upload.php/class.upload.txt
Hierin zie je mooi hoe alles goed gedocumenteerd is; je ziet hoe de constructor (het is wel een constructor in php4 stijl: function upload ) een reeks properties initieert; er is ook een init() functie
En vooral altijd in gedachten houden: hoe meer je regelt binnen de class, hoe minder je er buiten moet regelen, en hoe interessanter de class is om te hergebruiken.
Sakkerjuuu... wat een lange class :-)))))
Ik probeer m'n class nooit te groot te maken en nooit te veel commentaar erbij te zetten... maar als ik dit dan zie :D
Wel vreemd dat in de constructor een hoop variabelen op NULL gezet worden. Is dat daadwerkelijk nodig? Lijkt me overkill toch?
Toch nog ff een vraagje. Stel dat je een property hebt, bijv. private $bla.
Die property wordt uitsluitend geset door de functie bla(). Echter, de functie bla() wordt niet in alle gevallen gebruikt. Moet je die property dan wel per se initiëren in de construct? Of is dat niet nodig en is het onderstaande een goede manier?
Code (php)
Gewijzigd op 14/02/2012 13:49:05 door Ozzie PHP
Het setten op NULL, of "", of 0, of array() geeft je wel al een indicatie van het type.
Kwaad kan dat niet.
Denk er verder vooral aan ... stel dat iemand mijn class gebruikt (desnoods jezelf. Stel je even een beetje schizofreen op :) ) en een getter oproept vooraleer hij de waarde heeft geset.
Gebeurt er dan wat jij en hij verwacht?
Een voorbeeld: stel dat een getter een array moet teruggeven, die wordt dan rechtstreeks in een foreach gezet.
bv.
Code (php)
Dit zal een warning geven, indien je dat commentaar in de constructor niet weghaalt.
(In C++/c# krijg je zelfs een fatal error als je iets get wat niet geset of geïnitieerd is)