Doppelte Schleife verlassen

[Popov]

Ich persönlich nutze dafür immer ein Boolean:

Delphi-Quellcode:

var
  a, b: Integer;
  c: Boolean;
begin
  c := False;

  for a := 0 to 10 do
  begin
    for b := 0 to 10 do
    begin
      ShowMessage('b = ' + IntToStr(b));
      if b = 1 then
      begin
        c := True;
        Break;
      end;
    end;

    if c then Break;

    ShowMessage('a = ' + IntToStr(a));
  end;

  ShowMessage('Und weiter im Programm');
end;

Wenn es etwas unkonventionell sein darf, dann kann man das auch mit Except lösen:

Delphi-Quellcode:

var
  a, b: Integer;
begin
  try
    for a := 0 to 10 do
    begin
      for b := 0 to 10 do
      begin
        ShowMessage('b = ' + IntToStr(b));
        if b = 1 then Abort;
      end;
      ShowMessage('a = ' + IntToStr(a));
    end;
    ShowMessage('Schleifen sind durch');
  except
    ShowMessage('Hallo aus Except');
  end;
  ShowMessage('Und weiter im Programm');
end;

[Der schöne Günther]

Zitat von Linus Benedict Torvalds:

If you need more than 3 levels of indentation, you're screwed anyway, and should fix your program.

Ich lasse das mal hier

[Dejan Vu]

Wie von Uwe Raabe schon erwähnt:

Delphi-Quellcode:

 
..
  Function ProcessAction : Boolean;
  var
    varCurrActClass : TLastActionClass;
    i : integer;

  begin     
    for i := 0 to FLastActionList.Count -1 do begin
      varCurrActClass := FLastActionList.Items[i];
      if (...) then begin
        FLastActionList.Remove(varCurrActClass);
        FLastActionList.TrimExcess;
        exit(true);
      end;
      
      if (...) then begin
        FLastActionList.Remove(varCurrActClass);
        FLastActionList.TrimExcess;
        exit(true);
      end;
    end;
    exit(false);
  end;

begin
  while ProcessAction() do;
end;

Bisserl refactoring wg. DRY wäre noch möglich. Und der Funktion solltest Du noch die passende Bezeichnung verpassen.

Goto wird nie benötigt und wer ein Flag mitschleppen muss, weil innere Schleifen verlassen, sollte refaktorisieren. Ausnahme: Höchst zeitkritische Abläufe, denn dann ist alles erlaubt. Aber ansonsten geht imho Clean Code vor Performance.

[Martin W]

Zitat von Dejan Vu:

Aber ansonsten geht imho Clean Code vor Performance.

Ja, daran muss ich mich auch häufiger selbst erinnnern...

Danke für das Beispiel!

[Sir Rufo]

Wenn ich das richtig sehe, dann müsste es so auch DRY werden.

Delphi-Quellcode:

function ProcessAction : Boolean;
var
  varCurrActClass : TLastActionClass;
  i : integer;
begin 
  try
    for i := 0 to FLastActionList.Count -1 do 
    begin
      varCurrActClass := FLastActionList.Items[i];

      if
        {Bedingung1} (...)
        {oder} or
        {Bedingung2} (...)
      then 
        begin
          FLastActionList.Remove(varCurrActClass);
          FLastActionList.TrimExcess;
          exit(true);
        end;
      
    end;
    exit(false);
  finally
    {Wenn es noch etwas zu tun gibt, wird quasi immer ausgeführt}
  end;
end;

begin
  while ProcessAction( ) do;
end;

Aber wenn ich es mir so richtig anschaue, dann müsste sich das komplett so abtüten lassen:

Delphi-Quellcode:

procedure ProcessAction;
var
  varCurrActClass : TLastActionClass;
  i : integer;
begin 
    for i := FLastActionList.Count -1 downto 0 do 
    begin
      varCurrActClass := FLastActionList.Items[i];

      if
        {Bedingung1} (...)
        {oder} or
        {Bedingung2} (...)
      then 
        begin
          FLastActionList.Delete( i );
        end;
      
    end;
  FLastActionList.TrimExcess;
end;

[Martin W]

Zitat von Sir Rufo:

Aber wenn ich es mir so richtig anschaue, dann müsste sich das komplett so abtüten lassen:

Delphi-Quellcode:

procedure ProcessAction;
var
  varCurrActClass : TLastActionClass;
  i : integer;
begin 
    for i := FLastActionList.Count -1 downto 0 do 
    begin
      varCurrActClass := FLastActionList.Items[i];

      if
        {Bedingung1} (...)
        {oder} or
        {Bedingung2} (...)
      then 
        begin
          FLastActionList.Delete( i );
        end;
      
    end;
  FLastActionList.TrimExcess;
end;

Das mit dem downto ist eine feine Sache, so kann man wunderbar das OutOfRange verhindern ohne das in eine while Schleife zu packen Edit: Works amazing

Delphi-Quellcode:

      if
        {Bedingung1} (...)
        {oder} or
        {Bedingung2} (...)
      then

Eine Möglichkeit, ja aber die if Abfragen sind etwas größer, daher hatte ich das aufgeteilt um den Code Übersichtlich zu halten.

[Sir Rufo]

Zitat von Martin W:

Delphi-Quellcode:

      if
        {Bedingung1} (...)
        {oder} or
        {Bedingung2} (...)
      then

Eine Möglichkeit, ja aber die if Abfragen sind etwas größer, daher hatte ich das aufgeteilt um den Code Übersichtlich zu halten.

Es ist egal wie groß die sind, wenn zu groß, dann in Funktionen auslagern und dann benutzen. Sehr oft gibt es dann auch noch Überschneidungen, die man dann auch noch auslagern und wieder verwenden kann. Und schwups kann man auch die einzelnen Teilergebnisse prüfen, wenn die Abfrage mal nicht so hinhaut, wie man sich das gedacht hat.

Definitiv sollte man keinen Code doppelt schreiben, denn Änderungen müssen dann auch doppelt gepflegt werden und das ist schon wieder der Anfang vom Chaos