Door
Ozzie PHP
op 20-03-2014 14:27
gewijzigd op 20-03-2014 14:40
3.956 views
Hey guys,
Bestaat er binnen het programmeren eigenlijk zoiets als een "1 opdracht per regel" principe?
Wat ik bedoel is dit. Je kan iets in 1 regel schrijven (wat ik zelf wel eens doe):
<?php
return !empty($_SERVER['HTTP_ACCEPT_ENCODING']) ? explode(',', str_replace([' ', ';'], ['', ','], $_SERVER['HTTP_ACCEPT_ENCODING'])) : [];
?>
Maar je kan ook 1 opdracht per regel doen:
<?php
if (empty($_SERVER['HTTP_ACCEPT_ENCODING'])) return [];
$_SERVER['HTTP_ACCEPT_ENCODING'] = str_replace([' ', ';'], ['', ','], $_SERVER['HTTP_ACCEPT_ENCODING']);
$_SERVER['HTTP_ACCEPT_ENCODING'] = explode(',', $_SERVER['HTTP_ACCEPT_ENCODING']);
return $_SERVER['HTTP_ACCEPT_ENCODING'];
?>
Als je 1 opdracht per regel doet, is het beter leesbaar... en nu vroeg ik me dus af of er een soort "regel/principe" bestaat waarbij je slechts 1 opdracht per regel uitvoert. Iemand die dat weet?
Even opnieuw voor Ward, want m'n voorbeeld was wat krom.
Zou je dit doen:
<?php
$foo = explode('/', $foo);
return $foo;
?>
Of zou je dit doen:
<?php
return explode('/', $foo);
?>
Ik neem dan aan dat je voor de 1e optie kiest? Correct?
>> Je kunt het ook nog anders zeggen. Algoritmen en natuurwetten kun je vaak in één vergelijking uitschrijven. Hetzelfde geldt voor veel economische wetten. Maar dat wil niet zeggen dat dat ook de beste manier is om ze te programmeren. Dan kun je vaak beter de stappen van het algoritme uitschrijven, zoals je dat bij algebra ooit geleerd hebt.
Je voorbeeld is duidelijk. Per regel is het inderdaad veel duidelijker.
Ik zou de eerste aanbevelen en de tweede gebruiken :-)
Maar dat is geen goed voorbeeld. Op de return wordt het resultaat toegewezen aan een variabele elders buiten de methode. Dan heeft het niet zoveel zin vlak voor de return nog $foo te wijzigen, al helemaal niet omdat $foo ook nog eens op een enkele reis richting destructor wordt gestuurd bij het verlaten van de methode.
Ik begrijp ongeveer wat je bedoelt... maar als er meerdere stappen zijn die $foo wijzigen, dus zeg maar zoiets:
<?php
function foo() {
$foo = $this->foo;
$foo = str_replace([' ', ';'], ['', ','], $foo);
$foo = explode(',', $foo);
return $foo;
}
?>
Zou je het doen zoals hierboven, of zo:
<?php
function foo() {
$foo = $this->foo;
$foo = str_replace([' ', ';'], ['', ','], $foo);
return explode(',', $foo);
}
?>
Natuurlijk zitten we hier nu heel erg op detail-niveau te praten, maar ik ben wel benieuwd waarom jij voor het een of het ander zou kiezen. Dan kan ik dat namelijk zelf ook gaan toepassen.
Dan zou ik inderdaad de eerste vorm kiezen. Je wilt de operaties die je op $foo loslaat duidelijk op een rij hebben. Letterlijk en figuurlijk. En je wilt de volgorde misschien aanpassen, er nog iets tussen zetten, enzovoort.
Vanuit haskell ben ik gewent om zoveel mogelijk te chainen, dus dat gebruik ik ook. Overigens gebruik ik dan wel de korte haskell-like functie namen en niet die belachelijke lange PHP functienamen.
[offtopic]
Bij Albastine zeggen ze: Dichten kunnen we wel maar rijmen ......
[/offtopic]
Maar wat verstaan jullie eigenlijk onder één regel?
Ik heb weleens query's van een paar honderd tekens, die ga ik toch echt over meerdere regels verspreiden.
Maar wat verstaan jullie eigenlijk onder één regel?
Ik heb weleens query's van een paar honderd tekens, die ga ik toch echt over meerdere regels verspreiden.
Die query's schrijf je waarschijnlijk niet in PHP, nietwaar?
En dan gelden de regels van PHP niet langer, maar die van de string die je aan een andere parser / engine / interpreter / whatsitsname moet doorgeven.
