Was nervt euch so, während der Programmierung oder so allgemein

[rollstuhlfahrer]

was mich bei einem Projekt genervt hat, ist, dass Delphi/Pascal zwar die Fähigkeit von goto bietet, man diese aber nicht nutzen soll. da kommen dann Strukturen wie folgende raus:

Delphi-Quellcode:

  // Anti-GOTO-Struktur
  if ScanRows then
  begin
    if ScanCols then
    begin
      if ScanFields then
      begin
        Result := true;
      end
      else
      begin
        Result := false;
      end;
    end
    else
    begin
      Result := false;
    end;
  end
  else
  begin
    Result := false;
  end;

Mit einem einfachen goto wäre das viel einfacher gegangen. Und auch viel leserlicher und schöner:

Delphi-Quellcode:

  
procedure MitGoto();
// ...
begin
  //GOTO-Struktur
  if not ScanRows then
  begin
    Result := false;
    goto ende;
  end;

  if not ScanCols then
  begin
    Result := false;
    goto ende;
  end;

  if ScanFields then
  begin
    Result := false;
    goto ende;
  end;

  :ende
end;

Bernhard

PS: Nach mehrfachem Umbau sieht der Ablauf völlig anders aus und man braucht auch kein Goto mehr.

[himitsu]

Result := ScanRows and ScanCols and ScanFields; .
was aber nicht bedeutet, daß ich was gegen GOTO hätte (nutze es ja manchmal selber)

[Mithrandir]

Dennoch ist der Vorschlag von himi der Bessere, auch wenn man nix gegen GOTO hat...

[Schorschi5566]

Ist aber falsch.

Result := ScanRows and ScanCols and not ScanFields;
Ach nee, die goto-Procedure ist nur anders.

[himitsu]

Nein, der Anti-GOTO-Struktur nach ist meines richtig.

Delphi-Quellcode:

// Anti-GOTO-Struktur
if ScanRows then
begin
  if ScanCols then
  begin
    if ScanFields then
      Result := true;

aber du hast, dem MitGoto nach, auch nicht unrecht,
denn wie ich grad seh, stimmen Anti-GOTO und MitGoto nicht überein.

[rollstuhlfahrer]

Zitat von himitsu:

denn wie ich grad seh, stimmen Anti-GOTO und MitGoto nicht überein.

Fällt mir auch auf: es fehlt ein Result := true; Bernhard

[Helmi]

Hallo,

jetzt muss ich auch mal meinen Senf dazugeben:
Was mich momentan nervt ist, dass ich mir die unterschiedlichen Syntaxe nicht merken kann.

Zu Hause programmier ich Delphi, da geht ne Zuweisung mittels ":=" und eine Abfrage mittels "=",
in der Arbeit programmier ich CNC-Programme, da ist eine Zuweisung ein "=" und eine Abfrage "=="

Ständig überseh ich das zweifache Gleichzeichen

[sh17]

Wie wäre es mit:
(ist doch auch elegant,geht aber nur, wenn danach schluß ist)

Delphi-Quellcode:

  
procedure MitTryFinally();
// ...
begin
  try
    if not ScanRows then
    begin
      Result := false;
      exit;
    end;

    if not ScanCols then
    begin
      Result := false;
      exit;
    end;

    if ScanFields then
    begin
      Result := false;
      exit;
    end;
  finally
    //:ende
  end;
end;

Zitat von rollstuhlfahrer:

was mich bei einem Projekt genervt hat, ist, dass Delphi/Pascal zwar die Fähigkeit von goto bietet, man diese aber nicht nutzen soll. da kommen dann Strukturen wie folgende raus:
Mit einem einfachen goto wäre das viel einfacher gegangen. Und auch viel leserlicher und schöner:

Delphi-Quellcode:

  
procedure MitGoto();
// ...
begin
  //GOTO-Struktur
  if not ScanRows then
  begin
    Result := false;
    goto ende;
  end;

  if not ScanCols then
  begin
    Result := false;
    goto ende;
  end;

  if ScanFields then
  begin
    Result := false;
    goto ende;
  end;

  :ende
end;

Bernhard

[Namenloser]

Generell sollte man goto schon vermeiden, denn meistens lassen sich solche Konstrukte anders besser lösen. Ich habe letztens allerdings zum ersten mal seit Jahren mal wieder ein goto verwendet (ich bin nicht mal sicher, ob ich es unter Delphi überhaupt schon jemals benutzt habe - es sei denn man zählt exit und break dazu, die beiden Varianten nutze ich recht häufig):

Delphi-Quellcode:

label
  loopend;
begin
  Result := nil;
  for i := 0 to FWorld.Source.LevelCount-1 do
  begin
    Level := FWorld.Source[i];
    for x := 0 to Level.EdgeLength - 1 do
      for y := 0 to Level.EdgeLength - 1 do
        if Assigned(Level[x,y].Content) and (Level[x,y].Content.Typ=AType)
           and Level[x,y].CanRemoveBlock then
        begin
          Result := Level[x,y].Content;
          goto loopend;
        end;
  end;
  loopend:
  { Weiterer Code }

(loopend ist vllt nicht gerade der aussagekräftigste Name für ein label, zugegeben, aber mir fiel in dem Moment nix besseres ein)
Das war wirklich einer der wenigen Anwendungsfälle, wo ein goto imo die beste, übersichtlichste Lösung darstellte. Ohne hätte man hier in jeder Schleife Result prüfen und ggf. die Schleife mit break abbrechen müssen. Höchstens hätte man eine Unterfunktion erstellen und das goto durch exit ersetzen können. Aber letzlich wäre das auch nix anderes als ein verkapptes goto gewesen und hätte zusätzlich noch Overhead durch das ganze function-begin-end-Geplänkel erzeugt und den Code auseinandergerissen.