programmeerstijl, ff peilen...
Optie 1:
Code (php)
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
<?php
$foo = FooCreator::create();
$bar = BarCreator::create();
$buz = BuzCreator::create();
$baz = BazCreator::create($buz);
$foobar = FooBarCreator::create($foo, $bar);
$foobarbaz = FooBarBazCreator::create($foobar, $baz);
?>
$foo = FooCreator::create();
$bar = BarCreator::create();
$buz = BuzCreator::create();
$baz = BazCreator::create($buz);
$foobar = FooBarCreator::create($foo, $bar);
$foobarbaz = FooBarBazCreator::create($foobar, $baz);
?>
Optie 2:
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
<?php
$foobarbaz = FooBarBazCreator::create(
FooBarCreator::create(FooCreator::create(), BarCreator::create()),
BazCreator::create(BuzCreator::create())
);
?>
$foobarbaz = FooBarBazCreator::create(
FooBarCreator::create(FooCreator::create(), BarCreator::create()),
BazCreator::create(BuzCreator::create())
);
?>
Nogmaals, het gaat niet om de inhoud van de code. Het gaat erom wat je het meest aanspreekt. Wat zou je zelf kiezen? De versie met of zonder extra variabelen... en waarom?
in php kan je doen
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
$foo = new Person();
$bar->setName($foo->name);
?>
$foo = new Person();
$bar->setName($foo->name);
?>
Maar in een meer striktere taal is al voorgedefinieerd wat je moet meegeven. Bijvoorbeeld een object, String, Integer o.i.d. dus daar kan je niet zelf kiezen wat mooier is een extra variabele maken van bijv. een object en dat meegeven of een object gelijk als parameter meegeven.
Kortom, Ik zou als je het nodig acht een variabele aanmaken en als je denkt dat je in een situatie dit niet nodig hebt gelijk meegeven als parameter. ( als ik je vraag goed heb begrepen is dit hoe ik erover denk en anders moet je me even verduidelijken als ik je vraag verkeerd heb begrepen uit je dummy code ) :p
Die initiële variabelen in voorbeeld 1 heb je nadat $foobarbaz is aangemaakt niet meer nodig. Je zou ze dus kunnen weglaten zoals in voorbeeld 2. Maar dan kun je dus dit soort constructies (let weer niet op de code) krijgen:
Code (php)
1
2
3
2
3
<?php
Responder::respond(dispatcher::getResponse($this->createServices($this->getRequest())));
?>
Responder::respond(dispatcher::getResponse($this->createServices($this->getRequest())));
?>
In plaats van:
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
$request = $this->getRequest();
$services = $this->createServices($request);
$response = dispatcher::getResponse($services);
Responder::response($response);
?>
$request = $this->getRequest();
$services = $this->createServices($request);
$response = dispatcher::getResponse($services);
Responder::response($response);
?>
Het eerste code-voorbeeld bevat aardig wat "nested" code, waardoor het lastiger te lezen is. Het 2e voorbeeld is (vind ik) makkelijker te lezen, maar bevat weer onnodige variabelen. Dat is dus een beetje wat ik me afvraag. Kies je voor leesbaarheid en onnodige variabelen? Of niet?
Correct :)
>> Stel je hebt het maar 1x nodig dan kan je het eerste voorbeeld gebruiken is niks mis mee.
Ik begrijp dat er niks mis mee is. Het is korter en je bespaart variabelen. Dus dat is allemaal positief. Alleen het leest wat lastiger. En ik vroeg me dus af of dat een reden kan zijn om toch extra variabelen te gebruiken. Maar uit jouw reactie leid ik af dat je dat beter niet kan doen.
Ozzie PHP op 30/05/2014 02:21:00:
Ik begrijp dat er niks mis mee is. Het is korter en je bespaart variabelen. Dus dat is allemaal positief. Alleen het leest wat lastiger. En ik vroeg me dus af of dat een reden kan zijn om toch extra variabelen te gebruiken.
Voor beginners doe ik dat, bijvoorbeeld in mijn boeken, precies om die reden inderdaad wel, bijvoorbeeld:
Zou ik hier verder programmeren met $email_address[1], dan zou ik moeten uitleggen dat dit slechts het gedeelte van het e-mailadres is dat de hostnaam bevat. Door echter de dingen bij de naam te noemen, bijvoorbeeld $hostname, voorkom je die extra uitleg en krijg je code die, voor beginners vooral, beter leesbaar is.
Zou jij zelf wel kiezen voor dit:
Code (php)
1
2
3
2
3
<?php
Responder::respond(dispatcher::getResponse($this->createServices($this->getRequest())));
?>
Responder::respond(dispatcher::getResponse($this->createServices($this->getRequest())));
?>
in plaat van dit?
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
$request = $this->getRequest();
$services = $this->createServices($request);
$response = dispatcher::getResponse($services);
Responder::response($response);
?>
$request = $this->getRequest();
$services = $this->createServices($request);
$response = dispatcher::getResponse($services);
Responder::response($response);
?>
Kies voor de leesbare variant.
Maar met andere php functies doe ik het weer niet, zoals bijv. bij optie 3 ipv optie 4.
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
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
<?php
# optie 1
$foobarbaz = FooBarBazCreator::create(FooBarCreator::create(FooCreator::create(),BarCreator::create()),BazCreator::create(BuzCreator::create()));
# optie 2
$foobarbaz = FooBarBazCreator::create(
FooBarCreator::create(
FooCreator::create(),
BarCreator::create()
),
BazCreator::create(
BuzCreator::create()
)
);
# optie 3
$x = mysql_real_escape_string(date("Y-m-d", strtotime($_POST['date'])));
# optie 4
$y = mysql_real_escape_string(
date(
"Y-m-d",
strtotime($_POST['date'])
)
);
?>
# optie 1
$foobarbaz = FooBarBazCreator::create(FooBarCreator::create(FooCreator::create(),BarCreator::create()),BazCreator::create(BuzCreator::create()));
# optie 2
$foobarbaz = FooBarBazCreator::create(
FooBarCreator::create(
FooCreator::create(),
BarCreator::create()
),
BazCreator::create(
BuzCreator::create()
)
);
# optie 3
$x = mysql_real_escape_string(date("Y-m-d", strtotime($_POST['date'])));
# optie 4
$y = mysql_real_escape_string(
date(
"Y-m-d",
strtotime($_POST['date'])
)
);
?>
Gewijzigd op 30/05/2014 12:40:27 door gerhard l
>> Het zijn maar drie extra verwijzingen naar een waarde die er bij komen. De waardes zelf worden niet gekopieerd.
Hoe bedoel je dat de waardes niet worden gekopieerd? Omdat ze objecten teruggeven bedoel je? Oké... maar dan nog maak je 3 variabelen aan die verder niet worden gebruikt. Beter leesbaar, ja. Efficiënt... dat wat minder. Maar jij vindt dus leesbaarheid belangrijker?
@Gerhard:
Consequent zijn is het lastigste wat er is. Met inspringen maak je het inderdaad leesbaarder, maar inderdaad... code die op 1 regel past (zoals bij jouw optie 3) zou ik zelf ook niet graag op 6 regels zetten. Bij optie 2 wordt het er wel weer duidelijker op. Maar hoe maak je die keuze?
Quote:
Maar jij vindt dus leesbaarheid belangrijker?
Wat kost RAM tegenwoordig? Een stuk minder dan een programmeur die uren bezig is om onleesbare code te doorgronden.
Quote:
Hoe bedoel je dat de waardes niet worden gekopieerd?
http://oswaldatwork.thetaoofamp.com/2009/09/how-php-handles-variable-data/
Erg relevant, aangezien het bij beide over hetzelfde gaat: Wel of niet chainen van functie aanroepen?
In ieder geval zal mijn antwoord precies hetzelfde zijn als in dat topic...
Ten slotte, je kan ook consistent in the inconsistent zijn. Consistent betekend niet perse dat je het *altijd* op 1 manier mag doen, zolang je consistent bent in het gebruik van 2 manieren is dat ook consistentie.
>> Wat kost RAM tegenwoordig? Een stuk minder dan een programmeur die uren bezig is om onleesbare code te doorgronden.
Daar heb je ook een punt. Is het echter niet "fout" of een verkeerd programmeer-principe om variabelen aan te maken die je enkel gebruikt om ergens aan door te geven om een betere leesbaarheid te bewerkstelligen? Dit klinkt voor jou misschien als een rare vraag... maar ik heb geen programmeer-achtergrond en ik weet dus ook niet hoe dat zit. Ik heb hier op het forum ook wel horen zeggen dat je geen "extra" variabelen moet aanmaken als dat niet nodig is, maar dat je alles direct moet doorgeven.
>> http://oswaldatwork.thetaoofamp.com/2009/09/how-php-handles-variable-data
In feite zijn het dus "pointers". Dat zal inderdaad niet veel geheugen in beslag nemen... maar dan kom ik dus weer terug op mijn bovenstaande vraag (die ik zelf niet kan beantwoorden) of het niet een verkeerd programmeer-principe is.
@Wouter:
>> Ten slotte, je kan ook consistent in the inconsistent zijn. Consistent betekend niet perse dat je het *altijd* op 1 manier mag doen, zolang je consistent bent in het gebruik van 2 manieren is dat ook consistentie.
Hmmm, zo heb ik er nog niet over nagedacht. En hoe zou je dan moeten kiezen welke manier je gebruikt? Welke criteria zou je bijvoorbeeld kunnen hanteren om een keuze te maken tussen deze opties?
Code (php)
1
2
3
2
3
<?php
Responder::respond(dispatcher::getResponse($this->createServices($this->getRequest())));
?>
Responder::respond(dispatcher::getResponse($this->createServices($this->getRequest())));
?>
of
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
$request = $this->getRequest();
$services = $this->createServices($request);
$response = dispatcher::getResponse($services);
Responder::response($response);
?>
$request = $this->getRequest();
$services = $this->createServices($request);
$response = dispatcher::getResponse($services);
Responder::response($response);
?>
Hoe kan ik een keuze maken, gebaseerd op vaststaande criteria, die altijd tot hetzelfde resultaat leidt?
Oké... en zou jij dan als die limiet wordt overschreden extra variabelen gaan aanmaken:
Code (php)
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
<?php
$foo = FooCreator::create();
$bar = BarCreator::create();
$buz = BuzCreator::create();
$baz = BazCreator::create($buz);
$foobar = FooBarCreator::create($foo, $bar);
$foobarbaz = FooBarBazCreator::create($foobar, $baz);
?>
$foo = FooCreator::create();
$bar = BarCreator::create();
$buz = BuzCreator::create();
$baz = BazCreator::create($buz);
$foobar = FooBarCreator::create($foo, $bar);
$foobarbaz = FooBarBazCreator::create($foobar, $baz);
?>
Of ga je het duidelijker "uitschrijven"?
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
<?php
$foobarbaz = FooBarBazCreator::create(
FooBarCreator::create(FooCreator::create(), BarCreator::create()),
BazCreator::create(BuzCreator::create())
);
?>
$foobarbaz = FooBarBazCreator::create(
FooBarCreator::create(FooCreator::create(), BarCreator::create()),
BazCreator::create(BuzCreator::create())
);
?>
Quote:
Is het echter niet "fout" of een verkeerd programmeer-principe om variabelen aan te maken die je enkel gebruikt om ergens aan door te geven om een betere leesbaarheid te bewerkstelligen?
Als je in C programmeerd voor een microprocessor die maar een beperkt aantal KiB's beschikbaar heeft? Soms. Hangt van de requirements af.
http://arduino.cc/en/Main/ArduinoBoardMega2560:
The ATmega2560 has 256 KB of flash memory for storing code (of which 8 KB is used for the bootloader), 8 KB of SRAM and 4 KB of EEPROM (which can be read and written with the EEPROM library).
Wanneer je in PHP programmeerd dat op een server draait met meerdere GiB's aan RAM? Nee.
Variabelen aanmaken is erg goedkoop. Als je ooit op een punt komt dat alles zo goed geoptimaliseerd is dat het aantal variabelen een bottleneck is geworden wordt het tijd een totale rewrite in een andere taal.
Gewijzigd op 30/05/2014 14:52:53 door Dos Moonen
Geen gechain, intern meerdere classes doen. Tenzij het heel duidelijk is (in jouw geval van al die ::create() niet echt meer.
Ik code in Aptana en druk met een 'vreemd' (= andermans) document altijd eerst op CTRL+K, wat dus de tekst in een format gooit. Lekker leeg.
Liever 3000 regels leesbare code met veel ruimte dan 300 waar niet doorheen te komen is.