getInstance setInstance?
Nu vraag ik me af... iedere keer dat je getInstance gebruikt, ga je controleren of er al een instance is. Is het dan niet slimmer om die instance in het begin van je applicatie eenmalig te setten (via setInstance), en dat vervolgens getInstance altijd de instance teruggeeft, zonder controle? Is dat gebruikelijk?
In mijn registry wil ik gebruik maken van een instance, maar dit betekent dat ie altijd als ik iets uit de Registry haal de controle uitvoert. Dus nu vraag ik me af of het een goed idee is om de instance van te voren al te setten.
Graag jullie reacties!
Als je het eerst zou gaan setten dan weet je de flow en dan is een singleton al iets minder nuttig. Op het feit na dat je altijd maar 1 instantie kan hebben mocht je niet netjes programmeren. Als je hem al hebt geset en in je registry meteen stopt dan is de singleton nutteloos i.m.o.
Het is juist handig om overal in je code ClassName::getInstance(); te roepen en dan het object te hebben of te maken indien het de eerste keer aanroepen is.
Is het dan handiger om in de Registry helemaal niet met een instance te werken, maar uitsluitend met statiche functies en statische properties? Dus een statische set en get funtie en een statische property om alles in op te slaan?
Code (php)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
<?php
Registery::set('database.user', 'root');
Registery::set('database.host', 'localhost');
// enz.
$pdo = new PDO('mysql:host='.Registery::get('database.host').';dbname='.Registery::get('database.table'),
Registery::get('database.user'),
Registery::get('database.pass')
);
?>
Registery::set('database.user', 'root');
Registery::set('database.host', 'localhost');
// enz.
$pdo = new PDO('mysql:host='.Registery::get('database.host').';dbname='.Registery::get('database.table'),
Registery::get('database.user'),
Registery::get('database.pass')
);
?>
$configuration = Registry::get['configuration'];
en dan bijv. de database username:
$configuration->database->username;
Maar de Registry zelf zal ik dan in ieder geval helemaal statisch gaan maken.
Dus wat je er in stopt doet er eigenlijk niet toe. Zijn het ints dan enkel dat. Komt er een instantie van een klasse in voor dan zit dat er in.
Zelf zou ik het makkelijk houden met 2 static functies:
Registry::get('identifier');
Registry::set('identifier', $var);
Je zou het dan bijvoorbeeld in een array kunnen stoppen op key, value basis.
Dit gezien je in PHP toch alles in een array mag stoppen.
Zodoende hoef je jezelf geen zorgen te maken hoe dingen worden opgeslagen en geen rare vertaalslagen te maken.
De Registry hoeft namelijk in mijn ogen niet te weten wat erin kan worden gestopt. Het moet enkel een plek zijn die dingen opslaat om opgehaald te worden.
Gewijzigd op 21/02/2012 14:05:33 door Remco nvt
Code (php)
1
2
3
4
5
2
3
4
5
<?php
Registery::set('identifier', $var);
?>
Registery::set('identifier', $var);
?>
Als je trouwens een array property gebruikt om de waardes in op te slaan, en alle functies zijn statisch, dan kun je die property niet via de construct functie initiëren. Doe je dat dan maar direct? Dus zo?
Zal het even aanpassen
Die zou ik inderdaad al zo opgeven Ozzie
Gewijzigd op 21/02/2012 14:07:11 door Remco nvt
Ik heb mijn Registry class heel simpel:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Oké zo?
Ik heb even gezocht en ik bedoelde meer deze presentatie: OO desig patterns for PHP waarin op slide 12 een mooi voorbeeld staat van de Registery, die bijna hetzelfde is als die van jou.
Wouter J op 21/02/2012 14:41:48:
Dat is inderdaad hoe ik het ook zou doen, al zou ik alle properties en methods van een class 1 tab naar rechts opschuiven.
Dat doe ik normaal ook, maar dat gaat niet zo fijn in zo'n textarea :)
Overigens zie ik dat in dat voorbeeld (slide 12) ze de set functie dusdanig hebben gemaakt dat je bestaande waardes niet kunt overschrijven. Ik denk dat ik dat ook maar ga inbouwen om te voorkomen dat ik per ongeluk iets overschrijf. Nadeel is wel dat als ik bewust iets wil overschrijven dat dit niet gaat, maar ik denk dat dat in de praktijk niet vaak voorkomt.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
<?php
class Registery
{
private static $values;
public static function set( $key, $value, $overwrite = false )
{
if( isset(self::$values[$key]) && !$overwrite )
throw new LogicException(sprintf('The key (%s) already exists', $key));
self::$values[$key] = $value;
}
public static function get( $key )
{
if( isset(self::$values[$key]) )
throw new InvalidArgumentException(sprintf('The key (%s) does not exists', $key));
return self::$values[$key];
}
}
try
{
Registery::set('db.user', 'root');
Registery::set('db.user', 'ozziePHP'); // throw exception
}
catch( LogicException $e )
{
echo $e->getMessage();
}
try
{
Registery::set('db.user', 'root');
Registery::set('db.user', 'ozziePHP', true); // success
}
catch( LogicException $e )
{
echo $e->getMessage();
}
?>
class Registery
{
private static $values;
public static function set( $key, $value, $overwrite = false )
{
if( isset(self::$values[$key]) && !$overwrite )
throw new LogicException(sprintf('The key (%s) already exists', $key));
self::$values[$key] = $value;
}
public static function get( $key )
{
if( isset(self::$values[$key]) )
throw new InvalidArgumentException(sprintf('The key (%s) does not exists', $key));
return self::$values[$key];
}
}
try
{
Registery::set('db.user', 'root');
Registery::set('db.user', 'ozziePHP'); // throw exception
}
catch( LogicException $e )
{
echo $e->getMessage();
}
try
{
Registery::set('db.user', 'root');
Registery::set('db.user', 'ozziePHP', true); // success
}
catch( LogicException $e )
{
echo $e->getMessage();
}
?>
Gewijzigd op 21/02/2012 17:06:02 door Wouter J