⇐ Zurück zu S08: OOP Begriffsklärung
Weiter mit S10: case ⇒
 

Step 09 - if

Spendenaufruf des DRK Ortsvereins Spielberg e.V.

16. April 2023

 

Hallo liebe Besucherin, hallo lieber Besucher!

In einem ganz anderen Kontext möchte ich hier nun bewerben:
Der Verein, für den ich auch einstehe, benötigt Spenden.
Ich habe vergangenes Jahr über fünf Monate versucht für delphi-lernen.de Spenden zu sammeln - es blieb leider bei 20 Euro von zwei Spendewilligen.
Nun hoffe ich, da es nicht um mich geht, dass sich mehr entschließen und für eine gute Sache zu spenden:

Alle Informationen - auch für die Überweisung den Verwendungszweck beachten!

Der neuste Stand, mindestens einmal im Monat hier zu sehen!

Nicht, was wir geben, sondern was wir teilen, macht uns reich. (Mother Teresa)

 

 

Programmsteuerung 1: Bedingungsabfrage mit "if"

Die If-Abfrage wird verwendet, um Programmcode nur dann auszuführen, wenn angegebene Bedingungen erfüllt sind.
 
if
Grundsätzlicher Aufbau
  if [Bedingung(en) vom Typ Boolean] then
  begin
    // Ausführen, wenn Bedingung erfüllt ist
    // Hier sind weitere Anweisungen durch begin und end getrennt.
  end; // Ende der IF-Abfrage
Wenn man nur eine Anweisung ausführen will, dann kann man auch begin und end weglassen:
  if [Bedingung(en) vom Typ Boolean] then
    // Befehl, der ausgeführt werden soll.
 
if .. else
Grundsätzlicher Aufbau - wenn es auch eine "Ansonsten"- bzw. else-Bedingung gibt
Hierbei gibt es die Möglichkeit, Anweisungen nur dann ausführen zu lassen, wenn die Bedingung(en) des if-Teiles nicht erfüllt sind:
  if [Bedingung(en) vom Typ Boolean] then
  begin
        // Ausführen, wenn Bedingung erfüllt ist!

        // Hier sind weitere Anweisungen durch begin und end getrennt.
  end   // Ende der IF-Abfrage - Wichtig: hier jetzt kein Semikolon!
  else  // ansonsten
  begin
        // Ausführen, wenn Bedingung nicht erfüllt ist!

  end;  // ende des else-Abschnittes
Auch hier kann bei einer einzigen Anweisung ein paar Zeilen gespart werden.
  if [Bedingung(en) vom Typ Boolean] then
    // Befehl, der ausgeführt werden soll,
            // wenn Bedingung erfüllt ist (ohne Semikolon!)
  else
    // Befehl, der ausgeführt werden soll,
            // wenn Bedingung nicht erfüllt ist.
 
if ... else if ... else
Wenn es nicht nur einen "Fall" gibt...
Wenn es mehrere Bedingungen zu überprüfen gibt, dann lässt sich das grob wie folgt schreiben:
  if [Bedingung(en) vom Typ Boolean] then
  begin
    ...
  end
  else if [Bedingung(en) vom Typ Boolean] then
  begin
    ...
  end
  //...hier lässt sich das nahezu unendlich wiederholen...
  else
  begin
    ...
  end;
Auch hier nochmal in "Kurz":
  if [Bedingung(en)1 vom Typ Boolean] then
    // Befehl, der ausgeführt werden soll,
            // wenn Bedingung(en)1 erfüllt ist (wieder ohne Semikolon!)
  else if [Bedingung(en)2 vom Typ Boolean] then
    // Befehl, der ausgeführt werden soll,
            //  wenn Bedingung(en)2 erfüllt ist (wieder ohne Semikolon!)
  //...
  else
    // Befehl, der ausgeführt werden soll, wenn keine Bedingung erfüllt ist.
 
Verschachtelung
Es kann noch tiefer in die Logik gehen ;)
Verschachtelungen können z.B. helfen, wenn die Bedingung in der ersten if zu komplex wird und man einen Überblick wiederbekommen möchte.
    if [Bedingung(en) vom Typ Boolean] then         // 1. Ebene
    begin
        if [Bedingung(en) vom Typ Boolean] then     // 2. Ebene
        begin
            if [Bedingung(en) vom Typ Boolean] then // 3. Ebene
                ...; // auch einzeilige Bedingungs-Abfragen möglich
            ...;// das ist außerhalb der 3. und innerhalb der 2. Ebene!
            // Auch die Verschachtelung kann nahezu unendlich gehen...
            // ... was allerdings langfristig auf Kosten
            //     der Übersichtlichkeit und sog. Wartbarkeit geht :-/
        end  // von 2. Ebene
        else // auch einzeilige else-Teile sind möglich
        begin
            ...;
        end;
    end // von 1. Ebene
    else
    begin
        ...;
    end; // von 1. Ebene
Hierbei lasse ich die "Kurzform" weg, da hier schnell die übersicht doch verloren geht, sobald es mehrere else-Teile gibt oder ein else-Teil weg fällt. Die Kurzform sollte maximal in der obersten Ebene genutzt werden, aber sonst nicht. Noch besser ist es, in solchen Fällen ganz von der Kurzform Abstand zu nehmen, um den Kolleginnen und Kollegen keinen Kopfsalat zu bereiten.
 

Was sind nun diese Bedingungen vom Typ Boolean?

Wir meinen hier mit bedingungen Wahrheitsaussagen. Der Variablentyp dafür ist Boolean.
Mögliche Werte für Boolean sind: true und false - mehr nicht.
Also all das mit dem 1 und 0, was so das Klischee bei Informatikern ist, behandeln wir jetzt ;)
Wir können mittels Vergleichen eine solche Wahrheitsaussage erzeugen:
Einfache Vergleiche gibt es folgende:
Operator Beschreibung Beispiel
= Vergleich auf Gleichheit
i = 10
> Größer als
i > 10
>= Größer gleich
i >= 10
< Kleiner als
i < 10
<= Kleiner gleich
i <= 10
<> Ungleich
i <> 10
 
Eine einfache Bedingung kann somit ein Vergleich mit den Operatoren sein, wie der folgende Code-Ausschnitt kurz zeigen soll:
var
  i : Integer;
begin
    // ein Wert aus einem Eingabefeld lesen und in Integer umwandeln
    i := StrToInt( edEingabefeld.Text);
    if i = 1 then
        ShowMessage('Ihre Eingabe war Eins')
    else if i < 10 then
        ShowMessage('Ihre Eingabe war kleiner 10')
    else if i <= 20 then
        ShowMessage('Ihre Eingabe war zwischen 10 und 20 oder exakt 10 oder 20')
    else if i <> 21 then
        ShowMessage('Ihre Eingabe war nicht 21')
    else
        ShowMessage('Ihre Eingabe war 21');
end;
Versuche es gerne selbst aus - alle Sources befinden sich ansonsten auf GitHub als komplette Projekte. Viel Spaß ;)
 

OK, und wie können wir nun mehrere "Bedingungen" nutzen?

Nichts leichter als das - wir verknüpfen sie einfach ;)
Es gibt dabei folgende Verknüpfungsmöglichkeiten:
 
UND-Verknüpfung: AND
Gesamtausdruck wird nur dann "wahr", wenn alle Teile "wahr sind"
    
    if (i >= 1990) and (i < 2000) then
    
 
ODER-Verknüpfung: OR
Gesamtausdruck wird dann "wahr", sobald einer der Teile "wahr" ist
    
    if (i = 3) OR (i=10) then
    
 
Exklusiv-ODER-Verknüpfung: XOR
Gesamtausdruck wird dann "wahr", wenn einer der Teile "wahr" ist, aber nicht, wenn beide wahr sind. Dies ist in der Tat etwas spezielles und kann z.B. bei einer einfachen Verschlüsselung genutzt werden.
    
    if (a = 3) XOR (b = 10) then
    
Wichtig: Verknüpft man in Delphi Wahrheiten miteinander, müssen diese in Klammern gesetzt werden! Ansonsten sollte man keine Klammern benutzen
-> Sprechender Quelltext :-)
 
Im folgenden sollen diese Wahrheitsverknüpfungen kurz tabellarisch nochmal zusammengefasst werden. Diese Aufstellung in Tabellen kann hier gut weiterhelfen. Folgende Tabelle zeigt kurz, wie die Tabellen gelesen werden können.
A verknüpft mit B B ist wahr B ist falsch
A ist wahr (Ergebnis von A=Richtig und B=Richtig) (Ergebnis von A=Richtig und B=Falsch)
A ist falsch (Ergebnis von A=Falsch und B=Richtig) (Ergebnis von A=Falsch und B=Falsch)
 
Folgende Tabelle zeigt die UND-Verknüpfung:
(a = 3) AND (b = 10) b:=10; b:=1;
a:=3; WAHR FALSCH
a:=1; FALSCH FALSCH
 
Folgende Tabelle zeigt die ODER-Verknüpfung:
(a = 3) OR (b = 10) b:=10; b:=1;
a:=3; WAHR WAHR
a:=1; WAHR FALSCH
 
Folgende Tabelle zeigt die Exklusiv-ODER-Verknüpfung - Die Bedingung in der if-Anweisung wird dann wahr, wenn entweder a=3 oder b=10 ist, aber nicht, wenn beides Richtig oder beides falsch ist:
(a = 3) XOR (b = 10) b:=10; b:=1;
a:=3; FALSCH WAHR
a:=1; WAHR FALSCH
 

Wahrheitswert umkehren

Manchmal kommt es vor, dass man einen größeren Ausdruck hat, von dem man jetzt aber genau das Gegenteil möchte. Klar, wir wissen im Grunde jetzt schon, dass wir hierfür "else" benutzen können, aber wenn wir nur eine Bedingungsabfrage brauchen, dann können wir die Negation mit NOT wie folgt nutzen:
if not s = 'ping' then
// ist das selbe wie
if s <> 'ping' then
Zum Abschluss der "Programmsteuerung 1" hier noch mehr Beispiele, die direkt per Copy&Paste in ein neues Projekt eingefügt werden kann - naja, am Besten den Teil ab var bis zum Ende. Aufpassen, dass nicht ein "end;" zu viel übrig bleibt ;)
procedure TForm1.Button1Click(Sender: TObject);
var
  b     : Boolean;
  i,k,m : Integer;
begin
  // Benutzerabfrage:

  if Application.MessageBox('Wollen Sie wirklich weitermachen?',
                            'Frage',
                            MB_YESNO+MB_ICONQUESTION)=ID_YES then
    ShowMessage('Gute Wahl!')
  else if Application.MessageBox('Haben Sie Fragen?',
                                'Frage',
                                MB_YESNO+MB_ICONQUESTION)=ID_YES then
    ShowMessage('...dann mailen Sie mir gerne Ihre Fragen ;-)')
  else
    ShowMessage('Wo liegt denn das Problem?');

{
    Hinweis:  
    
        Mehr zu Application.MessageBox findet man in der Hilfe von Delphi
}

  // ein einfaches Beispiel:
  i := 15;
  k := 10;
  b := (i=15) XOR (k=15);
  
  if b then
    k := i div 3;
    
  b := ((i+k) = 20) AND ((i-k) > k);
  
  if not b then
    ShowMessage('Die Bedingung mit der UND-Verknüpfung ist "false"')
  else
    ShowMessage('Die Bedingung mit der UND-Verknüpfung ist "true"');
  

  // ein bisschen trickreicher! -> kleine Aufgabe:
  // "rechen" den Script in Gedanken durch!
  // kommen wir an die Meldung "Ziel"?
  i := 5;
  k := 18;
  m := k mod i;
  
  if m=3 then
  begin
    i := k*m - i;
    
    if i=49 then
    begin
      k := i div m;
      m := (i mod 10) * 3-k;
      
      if (k=16) XOR (m=k div 2) then
        ShowMessage('Ziel')
      else
        ShowMessage('Nope');
    end
    else
      ShowMessage('Ziel nicht erreicht');
  end
  else
    ShowMessage('So geht es nicht zum Ziel');
end;
 
Und zum Schluss nochmal kurz der Hinweis zu GitHub :)
Viel Spaß ;)