Door
Ozzie PHP
op 11-02-2014 01:39
gewijzigd op 11-02-2014 01:41
1.149 views
Ola,
Ik wil graag even een OOP principe begrijpen.
Tot op heden als ik paden wilde opslaan, dan maakte ik een Paths class. In een config bestandje zette ik dan de paden:
foo => /path/naar/foo
bar => /path/naar/bar
Deze paden sloeg ik op in de Paths class, en als ik dan een Path nodig had dan deed ik dit:
<?php
echo $paths->get('images');
?>
Echter, nu vraag ik me af of ik het eigenlijk niet anders zou moeten doen. Zou ik niet voor iedere directory een eigen object aan moeten maken, en al deze objecten moeten opslaan in een directory container, en dat je dan dit doet?
<?php
$image_dir = $dir_container->get('images');
echo $image_dir->getPath();
?>
Is dit laatste beter OOP vraag ik me af? En ik vraag me ook af... stel dat je 500 paden hebt, dan betekent dat dus ook 500 objecten. Vertraagt dat de bedoel niet enorm?
Heb geen idee waarom je 500 objecten zou willen. Je maakt 1 object dat die paden regelt. Het object hoeft niets te weten welk pad geladen moet worden.
Het voordeel is dat je niet steeds jezelf zit te repeteren. En kan onafhankelijk gebruikt worden.
Je kunt een antwoord (niet hét antwoord) vinden door een andere vraag te stellen: wanneer is een pad slechts een eigenschap van een ander object en wanneer is een pad een zelfstandig object?
Het voorbeeld $paths->get('images') zou één pad naar een directory /images/ kunnen zijn waarin alle afbeeldingen zijn opgeslagen. Dan is dit pad één eigenschap van een configuratie. Hetzelfde pad is meteen ook een gedeelde en gemeenschappelijke eigenschap van alle afbeeldingen. Eigenschappen dus van andere objecten, geen zelfstandig object.
Bij objectgeoriënteerd programmeren is het object altijd een middel, nooit een doel. Een pad wordt pas een object als je dat object ergens voor nodig hebt, bijvoorbeeld om de rechten op een directory te wijzigen.
Als je het heel ver abstraheert, is elke bit een object en wordt een byte een datacontainer van 8 bits. Een x-aantal stappen verder heb je dan op een gegeven moment het pad als datacontainer van andere objecten (bijvoorbeeld directory's). Je kunt bijvoorbeeld een filesystem zo programmeren, maar altijd als middel, nooit als doel.
Ik zal nogmaals proberen uit te leggen wat ik bedoel, want ik word van de bovenstaande antwoorden nog niet veel wijzer. Waarschijnlijk omdat jullie niet begrijpen wat ik bedoel.
Tot nu toe als ik ergens een path nodig had, bijvoorbeeld het path naar de directory waar images zijn opgeslagen, dan gebruikte ik een $paths object. Hierin had ik alle benodigde paden via een config-bestandje ingeladen. Had ik een pad nodig dan deed ik dit: echo $paths->get('images') . '/plaatje.jpg'.
Nu zat ik hier over na te denken, en toen bedacht ik me dat je eigenlijk 2 soorten paden hebt, namelijk paden van directories en paden van bestanden. Is $paths dan niet te algemeen vroeg ik me af. En toen ging ik nog verder denken, en toen vroeg ik me af of ik niet in plaats van paden te gebruiken, objecten moet maken van de files en directories, en via die objecten het path moet opvragen.
Dan krijg je dus zoiets:
<?php
$directories = $this->container->get('directory_collection');
$image_directory = $directories->get('images');
echo $image_directory->getPath() . '/plaatje.jpg'
?>
Een totaal andere benadering dus. In het eerste voorbeeld heb ik 1 container met daarin alle paden. In het tweede voorbeeld maak ik geen paden, maar directory objecten. Deze objecten stop ik in een container. Uit de container haal ik vervolgs het directory object en daar haal ik dan het path uit.
Bij voorbeeld 1 en 2. Aangezien één directory verschillende paden kan hebben, bijvoorbeeld via symlinks of een router, zou ik de "route" in beide gevallen een path noemen, geen directory.
Er leiden meerdere wegen (paden) naar Rome (directory)...
