Hunt, D.; Thomas, D. (2003): Der Pragmatische Programmierer

2018-10-08T17:36:39Z

Hhoegl:

{{Quelle:Buch
|key=Hunt, Thomas (2003)
|authors=Andrew Hunt, David Thomas
|editors=
|title=Der Pragmatische Programmierer
|subtitle=
|volume=
|number=
|series=
|edition=
|publisher=Fachbuchverlag Leipzig im Carl Hanser Verlag
|address=
|isbn=3446223096, 978-3446223097
|year=2003
|month=
|day=
|url=
|shelfmark=
|language=Deutsch
|quality=5
|annotations=
|bibtex-authors=
|bibtex-editors=
|bibtex-title=
|bibtex-subtitle=
|bibtex-volume=
|bibtex-number=
|bibtex-series=
|bibtex-edition=
|bibtex-publisher=
|bibtex-address=
|bibtex-url=
|bibtex-shelfmark=
|bibtex-annotations=
}}
[[Kategorie:Quelle:Programmierprinzip]]

Don't repeat yourself

2018-10-08T17:35:52Z

Hhoegl:

{{Qualität
|correctness = 4
|extent = 3
|numberOfReferences = 3
|qualityOfReferences = 4
|conformance = 5
}}

==Definition==
Das [[Programmierprinzipien#Don.27t_repeat_yourself.2C_DRY.5B1.5D|Programmierprinzip]] [[Don't repeat yourself]] (DRY, Wiederhole dich nicht)
besagt, dass Code nicht dupliziert und anschließend nur marginal modifiziert werden sollte.<ref>{{Quelle|Hund, Thomas (2003)}}</ref>

==Begründung==
Der Grund ist folgender: Wenn eine Folge von Anweisungen mehrfach in sehr ähnlicher Form verwendet wird, liegt diesen Anweisungen ein allgemeineres Prinzip zu Grunde, das explizit ins zugehörige Programm eingearbeitet werden sollte.

Code ohne Duplikate und Quasis-Duplikate von Anweisungen wird häufig als '''DRY''' bezeichnet.
Mit '''“to DRY code”''' wird der Vorgang bezeichnet, Anweisungs-Duplikate aus dem entsprechenden Code zu entfernen.<ref>Quelle fehlt</ref>

Code der DRY ist bietet folgende Vorteile:
:⇒ Wartbarkeit (da Änderungen nicht an mehreren, fast identischen Anweisungen vorgenommen werden müssen)
:⇒ Robustheit (bei einer Änderung, die an mehreren Stellen vorgenommen werden muss, kommt es häufig zu Inkonsitenzen)
:⇒ Lesbarkeit (da weniger Code existiert)

== Beispiele ==
===C#-Code, der nicht DRY ist (Autor: Anonym)===

Folgendes Beispiel stammt aus einem C#-Tool, das Daten für unterschiedliche
Gruppen von Personen verarbeitet. Als das Tool entwickelt wurde, gab
es genau zwei Gruppen.

<source lang="csharp">
// Filtere hier nach Gruppe 1 oder 2
if (this.selectedGroup == 1)
persons = persons.Where(p => p.IsActive && p.Group == 1);

else if (this.selectedGroup == 2)
persons = persons.Where(p => p.IsActive && p.Group == 2);
</source>

Wie man sieht, kann der Code problemlos für 3, 4 oder auch 27 Gruppen erweitert werden.

Wenn man diesen Code allerdings DRY macht, wird er nicht nur kürzer, sondern funktioniert
auch noch ohne Änderungen, wenn irgendwann einmal die Anzahl der Gruppen erhöht wird.

<source lang="csharp">
persons = persons.Where(p => p.IsActive && p.Group == this.selectedGroup);
</source>

===JavaScript-Code, der nicht DRY ist (Autor: Anonym)===

<source lang="javascript">
v_counter1.text = ++v_score_player1;
v_counter1.text = ++v_score_player1;
v_counter1.text = ++v_score_player1;
</source>

Glücklicher weise soll der Score nur um 3 und nicht um 50 Punkte erhöht werden.
DRY wäre folgender Code:

<source lang="javascript">
v_score_player1 += 3;
v_counter1.text = v_score_player1;
</source>

===JavaScript-Code, der nicht DRY ist (Autoren: Anyom)===

Folgender Code stammt aus einen einfachen JavaScript-Spiel mit 15 Spielsteinen („Coins“).
Für jeden einzelnen Stein wurde der zugehörige Code separat ausformuliert:

<source lang="javascript">
var btnSrc1 = new Image();
var btn1;

var btnSrc2 = new Image();
var btn2;

var btnSrc3 = new Image();
var btn3;
...

function Main()
{
...
btnSrc1.src = 'button1.png';
btnSrc1.name = 'coin1';
btnSrc1.onload = loadGfx;

btnSrc2.src = 'button2.png';
btnSrc2.name = 'coin2';
btnSrc2.onload = loadGfx;

btnSrc3.src = 'button3.png';
btnSrc3.name = 'coin3';
btnSrc3.onload = loadGfx;
...
}

function loadGfx(e)
{
...
if(e.target.name = 'coin1'){btn1 = new Bitmap(btnSrc1);}
if(e.target.name = 'coin2'){btn2 = new Bitmap(btnSrc2);}
if(e.target.name = 'coin3'){btn3 = new Bitmap(btnSrc3);}
...
}

// etc. pp.
</source>

Ein Array, ein zusätzliches Attribut <code>btn</code> für die <code>btnSrc</code>-Objekte und die Verwendung einer Schleife machen diesen Code DRY, d.h. kompakter, lesbarer und änderungsfreundlicher. Zum Beispiel kann die Anzahl der Spielsteine jederzeit problemlos geändert werden,
indem der Wert von <code>NR_OF_COINS</code> geändert wird.

<source lang="javascript">
var bs_array = [], btnSrc;

for (var i = 0; i < NR_OF_COINS)
{ btnSrc = new Image();

btnSrc.src = 'button'+i+'.png';
btnSrc.name = 'coin'+i;
btnSrc.onload = loadGfx;

bs_array[i] = btnSrc;
}

function loadGfx()
{ e.target.btn = new Bitmap(e.target.src); }
</source>

Anmerkung: Hier sind noch weitere Verbesserungen denkbar, wie z.B. eine bessere Wahl der Objekt- und Attributnamen. Dies hat aber nichts mehr mit dem Prinzip “Don't repeat yourself” zu tun.

===Der Klassiker===

Der Non-DRY-Klassiker dürfte wohl folgender sein:

<source lang="javascript">
if (<Bedingung>)
return <Ein langer Ausdruck>;
else
return -<Derselbe lange Ausdruck>;
</source>

Um diesen Code DRY zu bekommen, führt man entweder eine Hilfsvariable ein:

<source lang="javascript">
var a = <Ein langer Ausdruck>;
if (<Bedingung>)
return a;
else
return -a;
</source>

Oder – eleganter – man verwendet die If-Then-Else-Funktion <code>... ? ... : ...</code>
an Stelle der If-Then-Else-Anweisung:

<source lang="javascript">
return (<Bedingung> ? 1 : -1) * <Ein langer Ausdruck>;
</source>

Von diesem Klassiker gibt es zahlreiche Varianten, wie z.B. folgende Anweisung,
bei der klar wird, dass der Autor (oder die Autorin) Boolesche Ausdrücke
für etwas hält, was nur zum Testen, aber nicht zum Rechnen verwendet werden kann:

<source lang="javascript">
if (<Boolscher Ausdruck>)
return true;
else
return false;
</source>

Hier schreibt man natürlich:

<source lang="javascript">
return <Boolscher Ausdruck>;
</source>

Noch ein Beispiel aus der Praxis. Im zuvor erwähnten C#-Tool findet sich folgender Code:

<source lang="csharp">
var deactivate =
(t.State == "gesperrt" || t.State == "inaktiv") ? true : false;

if (deactivate)
DataModel.Team.Deactivate(id);
</source>

Hier ist nicht nur die Abbildung von <code>true</code> auf <code>true</code> und von <code>false</code> auf <code>false</code>
überflüssig, sondern auch noch die Einführung einer Hilfsvariablen. Folgender Code ist kürzer und damit einfacher zu verstehen:
<source lang="csharp">
if (t.State == "gesperrt" || t.State == "inaktiv")
DataModel.Team.Deactivate(id);
</source>

==Quellen==

<references/>
<ol start="3">
<li>{{Quelle|Kowarschick, W.: Multimedia-Programmierung}}</li>
</ol>

==Siehe auch==

#{{Vgl|Wikipedia (EN): DRY}}

[[Kategorie:Programmierprinzip]]
[[Kategorie:HowTo]]
[[en:Programing principles]]

GlossarWiki - Benutzerbeiträge [de-formal]

Hunt, D.; Thomas, D. (2003): Der Pragmatische Programmierer

Don't repeat yourself