[oop] parameter naam
Een kort vraagje... niet heel spannend, maar eigenlijk meer uit nieuwsgierigheid hoe jullie dit doen.
Stel we hebben een class waarin alle paden zijn opgeslagen en we willen het pad hebben dat naar de images leidt. Dan doen we zoiets als dit:
Code (php)
1
2
3
4
2
3
4
<?php
$paths = $this->getPaths();
$image_path = $paths->get('images'); // geeft terug: /pad/naar/images/
?>
$paths = $this->getPaths();
$image_path = $paths->get('images'); // geeft terug: /pad/naar/images/
?>
Nu vraag ik me af hoe jullie de parameter in de get functie noemen. Ik noem die $key, omdat je een key gebruikt om het juiste pad op te halen. De get functie ziet er dus zoiets uit:
Ik zat me gisteren even af te vragen of ik $key wellicht moet vervangen door $path. Dan krijg je dus dit:
In het 1e voorbeeld geef je duidelijk aan dat je een key moet ingeven. In het 2e voorbeeld is het duidelijker dat het om een path gaat, maar is het minder duidelijk dat je een key moet ingeven.
Het is waarschijnlijk een kwestie van smaak, maar ik ben toch benieuwd waar jullie voorkeur naar uit gaat.
Alvast bedankt voor de reacties.
$this->paths($folder);
Is dat zoals in de foreach? 0, 1, 2 ...
Dan zou ik geneigd zijn dit te doen.
function getPath($key)
Of eventueel $index.
Die functie get() vind ik nogal weinig-zeggend.
$key is de key van het pad. Dus in je class heb je een class property $paths die een array bevat:
Code (php)
1
2
3
2
3
config => /pad/naar/configbestanden/
images => /pad/naar/images/
library => /pad/naar/library/
images => /pad/naar/images/
library => /pad/naar/library/
Ik begrijp dat je de functie get niet veelzeggend vindt... maar in de context is het wel duidelijk. Je krijgt dan namelijk zoiets als:
Code (php)
1
2
3
4
2
3
4
<?php
$paths = $this->getPaths();
$library_path = $paths->get('library');
?>
$paths = $this->getPaths();
$library_path = $paths->get('library');
?>
Maar de vraag is dus of je in de get functie als parameter $key gebruikt, of $path. Ik vind $index ook een goede, maar dat komt qua betekenis volgens mij exact overeen met $key.
Ik kan me voorstellen dat jouw $this->getPaths() object specifiek gericht is op paden, maar dan zou hij toch de basic functionality van de mapping moeten overerven van een ander object (bijvoorbeeld StringMapping, Mapping, of zelfs iets als MappingDecorator als je gebruik maakt van een decorator pattern). In dat geval is de methode waarschijnlijk toch al in de parent gedefinieert waar ik een benaming die los staat van de path-context zou verwachten.
Het kan natuurlijk zijn dat je de get($key) methode override, maar in dat geval zou ik gewoon precies dezelfde naamgeving aanhouden als in de parent class.
Verschil tussen $key en $id is voor mij dat $id specifiek voor getallen is, maar dat is eigenlijk nergens op gebaseerd. Als ik er nog eens over nadenkt is $key eigenlijk best een domme naamgeving gezien waar het voor gebruikt wordt. Het is niet iets dat toegang verschaft tot een gegeven object (zoals ik van een sleutel zou verwachten), het is iets dat uit een verzameling objecten er eentje aanwijst.
$id als identifier zou op zich wel kunnen denk ik. In een database gebruik je dat ook, dus dan is meteen de vraag waarom je dat in je code dan weer niet zou doen. Alhoewel ik gewend ben om $key te gebruiken, maar ik vind $id ook wel wat hebben.
Meer reacties zijn welkom.
Nee: Noem het dan geen PathContainer, maar container. Laat de context los, en gebruik $key.
Ja: PathContainer extends Container?
Ja: get($key) wordt in Container gedefinieert neem ik aan. In Container zou ik dus $key gebruiken.
Override je de get($key) methode in PathContainer? Dan zou ik in PathContainer dezelfde naamgeving gebruiken als in Container: $key.
Nee: vreemd, waarom niet?
----
$key, in de context van associated array of container of iets, is voor iedereen duidelijk. $id doet mij persoonlijk teveel aan een getalletje denken, zoals in databases de standaard is.
key betekent sleutel. Eigenlijk vreemde naam voor wat het doet. Maarja, iedereen gebruikt het, en het is ondertussen voor iedereen wel duidelijk dat de functie ervan niet echt dezelfde is als die van een "echte" sleutel. In databases worden die dingen ook keys genoemd (primary keys, forreign keys, etc). Key is (naar mijn idee) de standaard naam voor dit soort dingen. Waar ik me over verbaas is waarom key/sleutel de standaard is geworden. Maarja, dat is nu toch te laat.
Ik noem het zelf ook $key, maar $id zou ook kunnen. Maar wat is precies het verschil tussen een key en een id?
Ik moet een path ophalen (of misschien wel een url of een route). Hoe bepaal je dan het juiste path. Door iets mee te geven aan de get() functie waaraan je dat path kunt herkennen. Als je het zo uitlegt dan is $id (van identifier) een correcte benaming. De $id identificeert het path. Waarom ik zelf vaak $key gebruik in zulke situaties is omdat ik een verband leg met een array element dat bestaat uit een sleutel en een waarde. Maar is dat niet teveel een technische benadering en is $id wellicht gerichter, namelijk datgene wat identificeert wat je wilt hebben?
Wat denk jij?
get($pathName)
getPathByName($pathName) // voor als er ook nog andere manieren zijn om een bepaald path op te vragen
getPath($name)
getPath($pathName)
Zelfde voor Idetifier/id of key ipv "name". Al geeft name naar mijn idee een iets betere beschrijving. Identifier is algemener: hoeft niet human readable te zijn, name is dat meestal wel. Maar name geeft minder sterk weer dat het een unieke waarde is.
Maar nogmaals:
1. volgens mij wil je de naamgeving baseren op een te specifieke context
2. verschillen tussen name/identifier/key/etc. zijn klein, het ligt nogal persoonlijk, en hele kleine veranderingen in de context kunnen per persoon heel andere voorkeuren geven.
Ik blijf erbij, maak een Container, met get($key). Vul de Container van buitenaf met je paden en bijbehorende keys. Als je pad-specifieke functionaliteit in je container nodig hebt, maak dan een PathContainer (extends Container).
Ik hoop dat je hier voorlopig genoeg aan hebt, ik kwam jouw vraag toevallig tegen en kon niet laten mijn eigen mening te laten horen. Ik weet niet wanneer ik hier weer een kijkje neem.
Mijn paden zitten inderdaad in een (algemene) container, dus wat dat betreft zou die $key wel kunnen. Ik heb toevallig ook aan $name gedacht... maar er zijn ook momenten waarop $name een andere betekenis kan hebben (denk aan de naam van een gebruiker). In die zin denk ik dat $id universeler is... en qua betekenis net iets sterker/meer to the point dan $key. Snap je wat ik bedoel?