1 opdracht per regel
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):
Code (php)
1
2
3
2
3
<?php
return !empty($_SERVER['HTTP_ACCEPT_ENCODING']) ? explode(',', str_replace([' ', ';'], ['', ','], $_SERVER['HTTP_ACCEPT_ENCODING'])) : [];
?>
return !empty($_SERVER['HTTP_ACCEPT_ENCODING']) ? explode(',', str_replace([' ', ';'], ['', ','], $_SERVER['HTTP_ACCEPT_ENCODING'])) : [];
?>
Maar je kan ook 1 opdracht per regel doen:
Code (php)
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?
Verplaatst naar "Algemene PHP scripting en meer", het topic heeft geen raakvlak met OOP.[/modedit]
Gewijzigd op 20/03/2014 14:40:30 door Wouter J
- principes gaan over de gedachtegang, niet over de code er uit ziet, staan over welke code standaard je gebruikt.
Of er zo'n coding standard bestaat? Er zal vast wel een bedrijf ergens op de wereld die code standaard hebben...
Heel veel dingen zijn natuurlijk gewoon persoonlijk. Ik kan me niet voorstellen dat er een wereldwijde afspraak is hoe je iets moet opbouwen. Je zou hier hooguit in een SCRUM team afspraken over kunnen maken omdat dan iedereen met je code overweg moet kunnen.
In sommige gevallen doe ik het als voorbeeld 1, en als het echt te lang wordt (als in; in de editor past het niet meer op 1 regel, wordt onoverzichtelijk) doe ik het als voorbeeld 2. Maar net hoe het uit komt.
Gewijzigd op 20/03/2014 14:36:01 door Michael -
Toevoeging op 20/03/2014 14:45:33:
Is voorbeeld 2 trouwens slimmmer dan voorbeeld 1?
Voorbeeld 2 is beter leesbaar, maar je kopieert wel een paar keer variabelen. Wat is de beste optie?
Een woordenboek is vrij resoluut: dit woord schrijven we altijd zó en dat woord komt in onze taal niet voor. Een woordenboek hebben we vaak ook helemaal niet nodig, want onze woordenschat en de correcte spelling zijn al grotendeels vastgelegd in PHP zelf.
Een stijlboek is genuanceerder: we schrijven iets liever zus dan zo. En dan komt het aan op smaak, leesbaarheid, algemene of juist zeldzame toepassingen, enzovoort.
Maar om de vraag van Ozzie te beantwoorden. Ja, ik gebruik liever één expressie per regel. Dat houdt code goed leesbaar. En het werkt makkelijker als je wat wilt verplaatsen of herschrijven.
Als je heel streng bent voor jezelf, en voor je eigen code, moet je de structuur liefst in één oogopslag zien, zonder blind te varen op de automatische highlighting van samenhangende haakjes en accolades in je editor.
Ik was eigenlijk altijd ervoor om zoveel mogelijk op 1 regel te proppen. Maar één expressie per regel leest inderdaad een stuk makkelijker, en maakt het voor jezelf ook makkelijker om de code te schrijven.
Doe je echt altijd maar 1 expressie per regel?
Je zou dus ook echt dit doen:
Code (php)
En dus niet dit?
Correct?
Code (php)
1
2
3
2
3
<?php
$y = c(b(a($x)));
?>
$y = c(b(a($x)));
?>
Dat is bij nader inzien helemaal niet zo handig, vooral wanneer de functies aanzienlijk complexer zijn met een argumenten, objecten, enzovoort.
Dan toch maar liever zo:
Code (php)
1
2
3
4
5
2
3
4
5
<?php
$y = a($x);
$y = b($y);
$y = c($y);
?>
$y = a($x);
$y = b($y);
$y = c($y);
?>
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.
Even opnieuw voor Ward, want m'n voorbeeld was wat krom.
Zou je dit doen:
Of zou je dit doen:
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.
Gewijzigd op 20/03/2014 15:30:50 door Ozzie PHP
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.
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
<?php
function foo() {
$foo = $this->foo;
$foo = str_replace([' ', ';'], ['', ','], $foo);
$foo = explode(',', $foo);
return $foo;
}
?>
function foo() {
$foo = $this->foo;
$foo = str_replace([' ', ';'], ['', ','], $foo);
$foo = explode(',', $foo);
return $foo;
}
?>
Zou je het doen zoals hierboven, of zo:
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
<?php
function foo() {
$foo = $this->foo;
$foo = str_replace([' ', ';'], ['', ','], $foo);
return explode(',', $foo);
}
?>
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.
Voor een voorbeeldje zie: http://www.phphulp.nl/php/script/php-algemeen/fn-lazy-loading-currying-etc/1989/
Merk overigens het verschil op: In PHP plaats ik het vaak op meerdere regels, aangezien het anders onleesbaar is. Haskell plaats ik wel op 1 regel:
Code (php)
1
length $ takeWhile (<= 200) $ map (^2) [1..]
Gewijzigd op 20/03/2014 16:10:54 door Wouter J
En gedichten zijn niet zo makkelijk in een stijlgids te vatten.
Meestal helemaal niet zelfs — sinterklaasgedichten en poeziealbums uitgezonderd.
Gewijzigd op 20/03/2014 16:21:55 door Ward van der Put
Bij Albastine zeggen ze: Dichten kunnen we wel maar rijmen ......
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.
Ger van Steenderen op 20/03/2014 18:41:14:
Die query's schrijf je waarschijnlijk niet in PHP, nietwaar?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.
Ik heb weleens query's van een paar honderd tekens, die ga ik toch echt over meerdere regels verspreiden.
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.