Constantes in OOP
Uiteraard kan dit ook in OOP, maar ergens vind ik het geen nette OOP oplossing. Dus hoe dan wel, en voornamelijk, hoe het efficient te doen.
Het gebruik van class constants:
kan natuurlijk, maar bij veel constantes lijkt dat nogal geheugen inefficient te zijn (bron: http://www.elxis.org/guides/developers-guides/php-defined-constants-vs-class-defined-variables.html).
Dus wat is dan een verstandige weg om te gaan? Elke groep van constantes zijn eigen class geven? Een grote class te maken die bepaalde dingen kan doen met de constantes (bijvoorbeeld vertalen naar een string waar nodig, waardes checken tegen de constantes, etc) en die de kleinere classes laten laden waarin de constante is gedefinieerd? Static classes gebruiken? Flat php manier blijven gebruiken?
Elke mening c.q. best practice is welkom, liefst wel met een uitleg/onderbouwing. Ik kies namelijk niet snel voor een methode of techniek als ik zelf het nut er niet van kan uitleggen.
Als het om een echte constante gaat is een const binnen een class de juiste weg.
Ik gebruik om configuratie instellingen te lezen een configuratie reader. Afhankelijk van hoe ik de configuratie 'constanten' opsla (xml, ini of php) gebruik ik de XmlConfigReader, IniConfigReader en PhpConfigReader. Voordat ik b.v. een PDO_MSQL_Adapter creeer, creeer ik eerst een XmlConfireader die de host, database, username en password ( en nog wat andere ellende) inleest, waarna ik dat gebruik om de Adapter te creeren.
Globals, Singletons en statics zijn evil. Niet te testen en eigenlijk een fancy manier om procedurele code in classes te stoppen.
Het artikel dat ik daarover ben aan het maken is nog niet helemaal af, maar toch alvast http://www.ganymedes.be/unittester-online
Gewijzigd op 19/08/2012 21:26:56 door John Berg
Het gaat mij puur om constantes die verder in de applicatie gebruikt worden. Bijvoorbeeld constantes die aangeven om wat voor type waarde het gaat (integer, string, date, datetime, etc). Deze gebruik ik door de hele applicatie om bijvoorbeeld een request waarde op een juiste manier te testen voor user input, of in een database class aan te kunnen geven wat voor type parameter moet worden ingegeven.
Bij een class constante heb ik dus alleen de vraag wat nu een praktische manier is om met vele tientallen constantes om te gaan. Niet elke constante is elke aanvraag nodig, maar als je alle constantes in 1 class zet dan laad je dus wel erg veel overhead in (zoals blijkt uit de test in de eerder gegeven link). Is het dus verstandig om elke 'groep' van constantes zijn eigen class te geven?
Verder, singletons gebruik ik inderdaad niet en static classes vind ik inderdaad ook een niet handige manier. De enige echt static class die ik al had (met HTML template functies) ben ik nu ook aan het omschrijven omdat het gewoon een crime is om er uiteindelijk mee te werken.
Wat ik me even niet voor de geest kan halen is hoe je aan tientallen constanten binnen 1 class kunt komen?
Ik kan helemaal niet zoveel constanten bedenken, PI het getal e (constante van Euhler) e.d. zijn echte constanten, en die zijn niet eens class gebonden.
Ten tweede gaat het niet om dat soort absolute constantes, maar om bijvoorbeeld waardes die aan geven wat voor entiteit er wordt opgehaald (denk aan een user, een country, een picture). Dit zijn geen zaken die snel kunnen veranderen of zaken die per configuratie hoeven te worden bepaald.
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
abstract class DaysOfWeek
{
const Sunday = 0;
const Monday = 1;
// etc.
}
var $today = DaysOfWeek::Sunday;
{
const Sunday = 0;
const Monday = 1;
// etc.
}
var $today = DaysOfWeek::Sunday;
n.b. de abstract zorgt ervoor dat je de class niet kunt instantiëren.
Misschien kun je daar nog iets mee?
Dit is in elk geval een serieuze optie waar ik eens naar ga kijken. Dank!