referentie array/object
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
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
<?php
class A {
private $foo;
public function __construct($foo) {
$this->foo = $foo;
$b = new B($this->foo);
}
}
class B {
private $foo;
public function __construct($foo) {
$this->foo = $foo;
}
}
$array = array('foo' => 'foo', 'bar' => 'bar');
// SITUATIE 1:
$a = new A($array);
// SITUATIE 2:
$object = (object) $array;
$a = new A($object );
?>
class A {
private $foo;
public function __construct($foo) {
$this->foo = $foo;
$b = new B($this->foo);
}
}
class B {
private $foo;
public function __construct($foo) {
$this->foo = $foo;
}
}
$array = array('foo' => 'foo', 'bar' => 'bar');
// SITUATIE 1:
$a = new A($array);
// SITUATIE 2:
$object = (object) $array;
$a = new A($object );
?>
Klopt het dat in situatie 1 zowel class A als class B een eigen afzonderlijke "kopie" (property) opslaan van $array?
En klopt het dat er in situatie 2 slechts 1 versie van $array is (het object), en dat de class-properties in class A en B slechts pointers zijn naar $array (het object)?
Gewijzigd op 30/10/2013 20:24:50 door Ozzie PHP
Maareh... ik heb dus een array met informatie die ik door moet geven via een paar classes. Maar om te voorkomen dat ik dan meerdere kopieën krijg, kan ik dan beter die array in het begin even omzetten naar een object? Of is dat een rare gedachte?
De vraag is heel simpel... waarom zou je het niet doen? IK heb de array in dit geval maar 1x nodig (omdat die bewerkt moet worden). Waarom zou ik er dan meerdere kopieën van opslaan? Geef mij maar 1 goede reden?
Voorbeeldje:
Code (php)
En daarnaast kun je nu ook nooit meer first(array(1,2,3)) doen.
En als laatst is by-reference vanuit een functioneel oogpunt heeeel erg fout.
Ik snap wat je bedoelt. Nu gaat het in dit geval puur om een "doorgeefluik". De ene class geeft de array door aan een andere, en alleen de laatste class doet er uiteindelijk iets mee. Maar goed, ik snap wel wat je bedoelt. Het alternatief om te voorkomen dat ik onnodig veel kopieën maak, is dat ik de class property unset nadat ik deze heb doorgegeven aan de volgende class, maar dat is ook weer zoiets... ik weet niet wat dan beter is??
Ozzie PHP op 30/10/2013 20:36:07:
Maareh... ik heb dus een array met informatie die ik door moet geven via een paar classes.
... plus deze ...
Ozzie PHP op 30/10/2013 21:09:02:
Nu gaat het in dit geval puur om een "doorgeefluik". De ene class geeft de array door aan een andere, en alleen de laatste class doet er uiteindelijk iets mee.
... moet je misschien omdenken. Je verkast, als ik het zo lees, kennelijk nogal wat data tussen klassen die helemaal niets met die data kunnen, moeten of willen. Pas aan het einde van de rit heb je beet.
Gewijzigd op 30/10/2013 21:27:41 door Ward van der Put
Overigens is "kernel" wel een nogal aan inflatie onderhevige term. Je bent immers geen besturingssysteem aan het programmeren... Als je het ding nu een "front controller" of een "dispatcher" noemt, wordt de taakopvatting veel concreter: de juiste data naar de juiste service doorgeven.
Maar goed, nu je weet waar het om gaat... wat zal ik dan doen? Die array omzetten in een object zodat er niet telkens verschillende kopieën worden opgeslagen? (zie het voorbeeld in mijn allereerste post), of zal ik iedere keer nadat ik de array heb doorgegeven de class property unsetten? Dus zoiets:
$foo = new Foo($this->array);
unset($this->array);
Ozzie, waarom geef je waardes aan de kernel mee? Hier heeft de kernel niks mee te maken. De enige waarde die de kernel moet krijgen is de request informatie.
Maar concreet... Ik zou de array omzetten in meerdere kleine objecten die gericht worden verwerkt door specifieke services. Zo werken de meeste PHP-kernels omdat dit de meest efficiënte en vooral de best schaalbare en distribueerbare oplossing is. De kernel/controller/processor/dispatcher/whatsinaname blijft daarbij in controle, maar doet weinig meer dan taken delegeren.
Gewijzigd op 30/10/2013 22:10:51 door Ward van der Put
Maar dat is ook precies wat ik bedoel! Het gaat om de request informatie, alleen stop ik die data in 1 array.
$array = ['cookie' => $_COOKIE, enz.];
$kernel = new Kernel($array);
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
<?php
$controlFreak = array(
'cookie' => $_COOKIE,
'get' => $_GET,
'post' => $_POST,
'server' => $_SERVER
);
?>
$controlFreak = array(
'cookie' => $_COOKIE,
'get' => $_GET,
'post' => $_POST,
'server' => $_SERVER
);
?>
... en die array ook nog doorgeeft aan verschillende controllers, dan kun je beter een eigen versie van PHP programmeren.
Maar even meer concreet: je doet hier niets anders dan overladen. Je vult namelijk een array met omgevingsvariabelen die worden ingesteld, gereguleerd en gecontroleerd door (meestal) Apache en PHP.
Gewijzigd op 30/10/2013 22:25:19 door Ward van der Put
Wat bedoel je hiermee Ward? Je bedoelt dat jij in je code gewoon $_COOKIE, $_SERVER enz. gebruikt?
Ik snap (de ironie in) je opmerking even niet. Ik geef gewoon de globals mee, zodat ik daarmee een request service kan opbouwen, waardoor ik straks bijv. dit kan doen:
$container->get('request')->getCookie()->get('foo');
Wat is daar volgens jou mis mee? Wat heeft dat met controlfreak te maken??? Ik kan je echt even niet volgen nu.
@Ward: ik hoop dat je nog even een reactie geeft, want ik snap niet wat je bedoelde.
En daarnaast krijgt de kernel een request object, deze moet hij niet zelf aanmaken.