For-Schleife :Stilfrage

[Ego]

In Delphi ist ja folgende Schleife möglich:

zaehler := 17;
for zaehler := 0 to zaehler do
begin
end;

weil der Compiler das Schleifenende im voraus bestimmt.
Aber ist das guter Programmierstil? Benutzt ihr das?
Oder ist der 'Klassiker' mit zwei Variablen besser (im Sinne von Sicherheit und Lesbarkeit):

ende := 17;
for zaehler := 0 to ende do
begin
end;

[Lemmy]

Guten Morgen,

eine Variable hat eine Funktion. Genau dafür wird der Name ausgesucht, so dass man am Namen der Variable schon erkennen kann was deren Aufgabe ist und nicht erst durch verstehen des Quellcodes. Das soll nämlich genau anders herum laufen: Durch aussagekräftige Variablennamen kann man den Quelltext wie prosa lesen. Gute Variablennamen sind damit quasi als Abfallprodukt so was wie Dokumentation der Sourcen.

Ich denke, das sollte deine Frage beantworten.

Grüße

[Ego]

Schnelle Antwort, aber leider keine auf meine Frage. Ich wollte nichts über die Auswahl von Variablennamen wissen, sondern über die Schleifenkonstruktion: Mit einer oder mit zwei Variablen? Egal wie sie heißen

[stahli]

Es spricht nichts entgegen, das so zu machen.
Würde ich mir nicht viele Gedanken drum machen. Ist einfach Geschmacksache.

[Sir Rufo]

Zitat:

Zitat von Ego (Beitrag 1189609)

Schnelle Antwort, aber leider keine auf meine Frage. Ich wollte nichts über die Auswahl von Variablennamen wissen, sondern über die Schleifenkonstruktion: Mit einer oder mit zwei Variablen? Egal wie sie heißen

Es ist die eine Antwort (fast wie 42), die deine Frage überflüssig werden lässt, weil es die Situation nicht gibt.

Auch wenn wir im ZA des Recyclings leben, für Variablen trifft das nicht zu. Und wenn deine proc/func zuviele Variablen benötigt, dann macht diese idR auch zu viel.

[Popov]

Zitat:

Zitat von Lemmy (Beitrag 1189608)

...so dass man am Namen der Variable schon erkennen kann was deren Aufgabe ist und nicht erst durch verstehen des Quellcodes. ... Durch aussagekräftige Variablennamen kann man den Quelltext wie prosa lesen.

Aus diesem Grund nutze ich bei For Then immer das i.

Ein hoch auf die aussagekräftigen Namen :kiss:

//Edit:

Aber um auf deine Frage zu kommen:

Delphi-Quellcode:

zaehler := 17;
for zaehler := 0 to zaehler do
begin
end;

Auch wenn das geht, es würde mich persönlich irritieren.

[Bummi]

Technisch gesehen ist es wurscht.
Wenn man auf die Nachvollziehbarkeit und Selbstdokumentation des Codes wert legt ist es ein NoGo.

[Ego]

Wenn Stahli (danke an dich) meine Frage versteht, kann ich sie doch nicht ganz so mißverständlich gestellt haben??!

[Ego]

Und noch zwei, die die Frage verstanden haben. Danke Popov und Bummi, sehe ich auch so.

[Sir Rufo]

Zitat:

Zitat von Ego (Beitrag 1189616)

Und noch zwei, die die Frage verstanden haben. Danke Popov und Bummi, sehe ich auch so.

Nun deine Ausgangsfrage zielte doch auf den Stil ab "Stilfrage", und somit ist die Frage von Lemmy absolut korrekt beantwortet und Bummi hat ja auch nur deine Erkenntnis bestätigt, dass es funktioniert, unter dem Aspekt "Stil" aber in "NoGo" ist (btw. auch Popov ist davon irritiert).

Nachdem du aber diese Antworten so interpretierst wie du das möchtest und nicht in Anlehnung an deine Frage, stellt sich nun die Frage nach der eigentlichen Frage :mrgreen:

Verstanden hat die Situation und Frage hier wohl ein jeder ;)

[DeddyH]

The answer is 42. What was the question? :lol:

[zeras]

Wenn man die Interna von Delphi nicht kennt, dann würde man denken, dass diese Schleife nicht sauber ausgeführt werden kann, denn zaehler wird zwar auf 17 gesetzt, aber dann mit 0 überschrieben. Wenn ich das in einem Projekt gesehen hätte, dann hätte ich das gleich "rausgeschmissen" und den "to" Zweig mit einer Konstanten oder Variablen geschrieben.
Für mich ist das nicht sauber programmiert.

Zitat:

Delphi-Quellcode:

zaehler := 17;
for zaehler := 0 to zaehler do
begin
end;

[himitsu]

Zitat:

Delphi-Quellcode:

zaehler := 17;
for zaehler := 0 to zaehler do

Für die Lesbarkeit empfinde ich sowas als Grauenhaft.
Wenn man der Ende-Variable einen "anderen" entsprechenden Namen gibt, dann mag das OK sein.
Wofür man sowas nutzen, aber bei dann eher bei "größeren" Auswertungen, also wenn man da noch viel rechnet, dann dieses Zwischenspeichern und nur die kurze Variable in die Schleifenauswertung rein.

Vorallem hat man da, beim Debuggen, ein Zwischenergebnis zum Prüfen.

[edit]
@zeras: Genau das ist das Problem mit dem Codeverständnis.

Genauso sollte man besser keine Schleifenvariablen nach der Schleife auswerten, was dennoch Viele machen, da es oftmals grade noch so gut geht.

[Sir Rufo]

Zitat:

Zitat von himitsu (Beitrag 1189621)

Vorallem hat man da, beim Debuggen, ein Zwischenergebnis, zum Prüfen. (sind die Kommas eigentlich richtig gesetzt? :gruebel:)

Das Komma hinter Zwischenergebnis ist zuviel :)

[himitsu]

Ich behaupte einfach, daß s früher (vor den letzen 20 Regeländerungen) mal richtig war. :stupid: (mir war schon so, daß da irgendwas nicht stimmen kann)

Was man auch noch beachten sollte, daß Delphi gerne mal die interne Behandlung der Schleifen anpaßt.
- Zählbereich verschieben
- und/oder sogar rückwärtszählen

Wenn man in der Schleife das i eh nicht auswertet, dann kann für

Delphi-Quellcode:

for i := 1 to 10 do

locker mal

Delphi-Quellcode:

for i := 0 to 10 do

oder

Delphi-Quellcode:

for i := 9 downto 0 do

gnommen werden.
Bei Erstetem braucht nur noch +1 gerechnet werden, wenn der Wert doch verwendet wird. Vorallem wenn man einen String charweise durchläuft, wo überall sowieso -1 gerechnet würde, da der Stringindex bei 1 benginnt, wo sich dann -1 und +1 wieder aufheben.

[Popov]

Es gab eine Zeit da war ich stolz drauf alles in eine einzige Zeile und ohne Semikolon zu packen:

Delphi-Quellcode:

try while i <> 2 do begin if Random(100) = 50 then i := Random(50) else if Random(100) = 30 then i := Random(30) else i := i * 2 end except i := -1 end

[hoika]

Hallo,

Um auf die Kernfrage zurückzukommen.
Ja, es ist schlechter Stil,
weil die Variable sowohl als Zählvariable als
auch als Endbedingung verwendet wird.

Eine Variable sollte nur für einem Zweck verwendet werden.


Heiko

[sx2008]

Bei der For-Schleife ist es wichtig zu wissen, dass der Von- und der Bis-Wert nur einmal ausgewertet werden.

Delphi-Quellcode:

// die Funktionen Von() und Bis() werden nur einmal aufgerufen
for i := Von() to Bis() do
begin
end;

In der Programmiersprache C/C++ ist das anderst aber wir sprechen hier von Pascal/Delphi.

Deshalb ist es überflüssig für den Anfangswert und/oder den Endewert eine Zwischenvariable zu verwenden.
Zu Debuggingzwecken oder zur besseren Lesbarkeit des Codes kann man natürlich eine Zwischenvariable verwenden.
Was aber überhaupt nicht geht (und auch keinen Sinn macht) ist die Laufvariable der For-Schleife als Bis-Wert zu missbrauchen!!

Delphi-Quellcode:

// FALSCH!!!
zaehler := 17;
for zaehler := 0 to zaehler do

// RICHTIG!
for zaehler := 0 to 17 do

[Bummi]

@sx2008 geht insofern am Thema vorbei dass man bisweilen durchaus Schleifen mit

Delphi-Quellcode:

For i := 0 to yetCalculated do

[sx2008]

Zitat:

Zitat von Bummi (Beitrag 1189653)

@sx2008 geht insofern am Thema vorbei dass man bisweilen durchaus Schleifen mit

Delphi-Quellcode:

For i := 0 to yetCalculated do

Ich hab nichts anderes behauptet.
Der Grund den Schleifenzähler als Bis-Wert zu missbrauchen kann eigentlich nur so entstehen.
1.) Der Programmierer hat die Befürchtung, dass der Bis-Wert mehr als einmal berechnet wird.
==> er denkt er braucht eine Zwischenvariable
2.) Der Programmierer ist schreibfaul und verwendet einfach die Laufvariable der For-Schleife
Dabei entsteht dieser Code

Delphi-Quellcode:

// FALSCH!!!
zaehler := FunktionDieVielZeitBraucht();
for zaehler := 0 to zaehler do

Da aber schon die Annahme bei 1.) falsch war, ist diese Vorgehensweise überflüssig.

[Lemmy]

Zitat:

Zitat von Ego (Beitrag 1189609)

Schnelle Antwort, aber leider keine auf meine Frage. Ich wollte nichts über die Auswahl von Variablennamen wissen, sondern über die Schleifenkonstruktion: Mit einer oder mit zwei Variablen? Egal wie sie heißen

selten so gelacht. Mehr schreib ich nicht - ist eh für die Katz...

@Popov: i als Schleifenindex verwende ich auch noch hin und wieder - aber bei Software die langfristig gewartet werden muss (und nicht nur von mir) vermeide ich so zeugs selbst bei den einfachsten Schleifen...

[Furtbichler]

Ich werde auch mal eine Antwort geben, die am Thema vorbei geht:

Delphi-Quellcode:

For i:=0 to 10

ist schlechter Stil, weil hier magische Konstanten verwendet werden. 0 mag ja noch angehen (untere Grenze), aber 10 ist... was?

Wenn es sich um eine Konstante handelt, dann sollte sie als Konstante deklariert werden (und nicht einer Variablen zugewiesen werden, Herr Fragesteller).
Handelt es sich um eine Veränderliche, weil z.B. eine Liste durchsucht wird, steht dort natürlich nicht 10, sondern z.B. Elementanzahl-1 o.ä.

Handelt es sich um Bereichsgrenzen (eines Arrays), dann sollte das auch so implementiert werden (Low, High). Schließlich kann man mit einer Programmiersprache nicht nur programmieren, sondern auch erklären.

[p80286]

Zitat:

Zitat von Lemmy (Beitrag 1189680)

@Popov: i als Schleifenindex verwende ich auch noch hin und wieder - aber bei Software die langfristig gewartet werden muss (und nicht nur von mir) vermeide ich so zeugs selbst bei den einfachsten Schleifen...

Das hätte ich gerne näher erklärt. Wenn ich mich richtig erinnere wird i (j,k..) als Schleifenindex bei Fortran z.B. "mitgeliefert".
Für mich ist das ein bedingter Reflex I = Schleife.
Etwas Anderes ist es bei SatzIndex oder ähnlichem.

Gruß
K-H

[Popov]

Das mit I ist so eine Sache, denn

Delphi-Quellcode:

for to

akzeptiert meines Wissens sowieso nur lokale Variablen, somit hält sich die Unübersichtlichkeit in Grenzen. Es ist nur ein Schleifenindex, mehr nicht. Bei komplexen Verschachteltelungen lasse ich mit mir reden, aber guck dir mal den Quelltext der Units an. Lauter Is.

Zitat:

Zitat von Furtbichler (Beitrag 1189689)

Ich werde auch mal eine Antwort geben, die am Thema vorbei geht:

Delphi-Quellcode:

For i:=0 to 10

ist schlechter Stil, weil hier magische Konstanten verwendet werden. 0 mag ja noch angehen (untere Grenze), aber 10 ist... was?

Einerseits möchte ich dir Recht geben, dann aber... Guck dir mal die Unit

Delphi-Quellcode:

ComCtrls

und dort z. B.

Delphi-Quellcode:

TCustomRichEdit.Print

. Zig 1440 Zahlen. Ich brauchte Stunden bis ich rausfand was sie zu bedeuten haben. Ok, Stunden vielleicht nicht, aber es hat schon paar Minuten gedauert.

[Furtbichler]

Zitat:

Zitat von Popov (Beitrag 1189726)

Einerseits möchte ich dir Recht geben, dann aber... Guck dir mal die Unit

Delphi-Quellcode:

ComCtrls

und dort z. B.

Delphi-Quellcode:

TCustomRichEdit.Print

. Zig 1440 Zahlen. Ich brauchte Stunden bis ich rausfand was sie zu bedeuten haben. Ok, Stunden vielleicht nicht, aber es hat schon paar Minuten gedauert.

Damit ist dann wohl bewiesen, das sich die VCL-Programmierer einen Dreck um sauberen Code scheren.

[QUOTE=Popov;1189726]Das mit I ist so eine Sache, denn

Delphi-Quellcode:

for to

akzeptiert meines Wissens sowieso nur lokale Variablen, somit hält sich die Unübersichtlichkeit in Grenzen. Es ist nur ein Schleifenindex, mehr nicht. Bei komplexen Verschachteltelungen lasse ich mit mir reden, aber guck dir mal den Quelltext der Units an. Lauter Is.
Wenn Du Clean Code konsequent durchziehst, würde eine Methode (der Name sagt ja alles) eh nur aus einer Schleife bestehen. Ich finde, i und j sind allgemein übliche und verständliche Zähl/Laufvariablen und können auch in Programmen, die in 10 Jahren noch verstanden werden sollen, verwendet werden. Wobei i und j ziemlich fies -weil mit bestimmten Fonts schwer zu unterscheiden- sind.

Der Index (daher das I) einer Liste hat ja eigentlich keinerlei Semantik (außer der des Index'). Oder nimmst du etwa Namen wie 'ArrayIndex' und verwechselst 'lange Bezeichnernamen' mit 'lesbarer Code'? ;-)

Du hast bestimmt ein Beispiel für einen guten Namen für eine Schleifenvariable...

[Popov]

Meinst du mich? Eigentlich stehe ich auf i, j dagegen nutze ich fast nie. k, dann m, aber kein n.

Wobei gerade letzte Woche habe ich etwas konstruiert das aus zum Teil drei Schleifen bestand. Das ist an für sich nicht das Problem, aber bei i, k und m verlor ich dann doch etwas den Überblick, da der Code etwas komplex war. Nach einer handvoll Fehler durch falsche Zuweisung entschloss ich mich richtige Namen zu benutzen. Nachdem ich fertig war und alles optimiert habe, entwor sich das Chaos und ich hab die Klassiker wieder eingesetzt.

[angos]

Hi,

du hast also i,k,j durch lesbare Namen ersetzt, dann die Fehler bereinigt und zum Schluß die neuen Namen wieder durch i,j,k ersetzt? Wenn ja: Warum? Das würde ich nämlich nicht verstehen.


Gruß

[Sir Rufo]

Weil das nachher auffällt und er dann erklären müsste, dass er das am Anfang nicht geblickt hat mit den i, k, n Variablen.

So hält er sich lästige Diskussionen vom Hals ;)

[Popov]

Nicht i,k,j, sondern i,k,m.

Die drei Gründe wieso ich sie durch Namen ersetzte waren: währen der Entwicklung, als ich noch nicht wusste wie alles aussehen soll, war der Code etwas umfangreicher. Der zweite Grund war, dass sich alles etwas verschachtelte. Es ist ja nicht so, dass ich den Überblick verloren habe, aber um Flüchtigkeitsfehler zu vermeiden waren schwer verwechselbare Namen sinnvoller. Als alles stand und funktionierte, wurde es optimiert und übersichtlicher (der einst langer Code schrumpfte auf paar Zeilen). Die Namen hatten jetzt keinen Sinn und machten ihrerseits dem Code durch die Namen unübersichtlich. Was übrig blieb war auch mit i, k und m leicht verständlich.

Und drittens, und das soll bitte nicht als der geringste Grund angesehen werden, weil ich bösartig bin. Ich verstehe es auch mit i, k und m, aber wenn die Firma meint mich feuern zu müssen, was kümmert mich ob der Nachfolger damit nicht klar kommt. Ich hoffe sogar, dass er damit nicht klar kommt, Stunden, Tage, Monate damit verbringt die Funktion zu entwirren. Die hohen Kosten belasten die Firma dann so sehr, dass sie Konkurs geht. Selber Schuld wenn sie mich feuern ;)

[DeddyH]

Wenn die das bisschen Refactoring nicht hinkriegen, wäre eine Firmenpleite ja nur eine "natürliche Auslese" :mrgreen:

[bernau]

Für Schleifenvariablen verwende ich auch nur reine Buchstaben. Statt i,k,m verwende ich a,b,c. Aber das ist ja nur Kosmetik. Diese drei Buchstaben sind bei mir "immer" Schleifenvariablen. wobei a immer die äussere Schleifenvariable ist, danach b, danach c. Wenn zwei- oder dreidimensionalen Arrays angesprochen werden verwende ich x,y,z. Wenn mehr als drei Schleifen verschachtelt sind, dann verwende ich längere Bezeichner. Kommt aber selten vor. Hat sich bei mir in den letzten 20 Jahren so entwickelt und bin gut damit gefahren.

Da ja meist die Schleifenvaiable als Parameter für irgendwelche Proceduren in der Schleife verwendet wird, erhöht sich "für mich" die Lesbarkeit mit Einzelbuchstaben.

[Jonas Shinaniganz]

Ich habe mal von einem CleanCoder gehört der nach einem Refactoring nicht alles wieder verwischt hat. Nein, er hat sogar für seine Objekte Container implementiert, welche dann

Zitat:

function GetCurrent: String; und function MoveNext: Boolean;

konnten. Es gab in seiner Prosa keine < 3 buchstabigen Bezeichner; und als er dann gestorben war lebte sein Programm in der Firma noch weiter. Tat es dann aber wegen dem Wartungsmenschen nach 2 Jahren nicht mehr. Traurige Geschichte.

[DanielJ]

Hallo,

wenn wir schon bei Stil sind, möchte ich mich auch mal gegen die einbuchstabigen Schleifenvariablen verwehren.
Der Grund ist einfach: Sucht mal in eurem Quelltext nach z.B. "i" - da findet man doch ziemlich viel!

Ich verwende deshalb, wenn ich nicht sowiso aussagekräftigere Bezeichner verwende ii,ij,ik...

LG,
Daniel

[sahimba]

Zitat:

Zitat von DanielJ (Beitrag 1189921)

Hallo,
Der Grund ist einfach: Sucht mal in eurem Quelltext nach z.B. "i" - da findet man doch ziemlich viel!

Ich hatte bisher keinen Anlass, in meinen Quelltexten nach einer Schleifenvariablen zu suchen und kann mir aucj keinen wirklichen Grund vorstellen, nach einer solchen suchen zu müssen. Bezeichner von Properties, Methoden, Typen, klar. Lokale Variablen, zumal eine welche lediglich als Zähler dient, schwerlich.

Cheers.

[Meflin]

Zitat:

Zitat von DanielJ (Beitrag 1189921)

Der Grund ist einfach: Sucht mal in eurem Quelltext nach z.B. "i" - da findet man doch ziemlich viel!

Und wann genau muss man den Code nochmal nach Schleifenvariablen durchsuchen :shock:?

Wenn wir schon beim Thema sind... in 99,75% der Fälle braucht man doch den Schleifenindex sowieso nicht wirklich, weil man _eigentlich_ eine for-each-Schleife macht ("tue etwas mit allen Listenelementen"). Und die sollte man dann, wenn die verwendte Sprache es hergibt, auch verwenden. Und schon ist das Problem erledigt.

[bernau]

Zitat:

Zitat von Meflin (Beitrag 1189932)

Wenn wir schon beim Thema sind... in 99,75% der Fälle braucht man doch den Schleifenindex sowieso nicht wirklich, weil man _eigentlich_ eine for-each-Schleife macht ("tue etwas mit allen Listenelementen"). Und die sollte man dann, wenn die verwendte Sprache es hergibt, auch verwenden. Und schon ist das Problem erledigt.

Seit wann gibt es forEach bei Delphi noch mal?

Wie kann man ein mehrdimensionales Array mit ForEach ansprechen.

Ansonsten hast du recht. Wenn man es verwenden kann, dann sollte man es. Tue mich aber noch sehr schwer damit.

[himitsu]

Man findet viele i's?

"Nach ganzen Wörtern suchen" :angle2:


@bernau:
mehrere ForEach's, genauso wie man sonst mehrere "normale" FORs nimmt. (außer man errechntet die verschiedenen Indize aus einem Index)

[Stevie]

Sofern man kein dynamisches Array hat kann man mit for-in sogar in einem Rutsch durch ein n-dimensionales Array. 8-)

Delphi-Quellcode:

var
  values: array[0..2, 0..3, 0..4] of Integer;
  i: Integer;
  count: Integer;
begin
  count := 0;
  for i in values do
    Inc(count);
end.

[Meflin]

Zitat:

Zitat von bernau (Beitrag 1189934)

Seit wann gibt es forEach bei Delphi noch mal?

Seit sage und schreibe 8 Jahren :P (Delphi 2005, glaube ich)