Erfassen Sie Ihre Fortschritte
Trailhead-Startseite
Trailhead-Startseite

Steuern des Datenflusses

Lernziele

Nachdem Sie diese Lektion abgeschlossen haben, sind Sie in der Lage, die folgenden Aufgaben auszuführen:

  • Auflisten der Zwecke von Vergleichsoperatoren
  • Erläutern des Unterschieds zwischen "switch"- und "if-else"-Anweisungen

In unserem Alltag müssen wir immer wieder Entscheidungen treffen. Was soll ich anziehen? Was soll ich essen? Soll ich nach links oder nach rechts gehen? Das Gleiche gilt beim Schreiben von Code. Denken Sie an unseren Pseudocode für Teatime in Einheit 1, insbesondere Schritt 2. 

Boil water in a Tea Kettle
Fill Kettle with Water
Switch Kettle On
Wait for Water to Boil

Hmm... alles scheint ziemlich korrekt zu sein, oder? Um Wasser zu kochen, fülle ich den Wasserkocher mit Wasser, schalte den Wasserkocher ein und warte, bis das Wasser kocht. Doch was ist, wenn der Wasserkocher bereits Wasser enthält? Oder wenn der Wasserkocher bereits voll ist? Wie lange soll das Wasser kochen?

Ausdrücke und Ausdrucksoperatoren

Bevor wir Entscheidungen treffen, stellen wir oft Vergleiche an. Ist etwas größer als etwas anderes? Sind die beiden Dinge gleich? Entwickler vergleichen oft Werte, bevor sie Entscheidungen in ihren Anwendungen treffen. Im Code vergleichen wir zwei Ausdrücke, indem wir einen Ausdrucksoperator zwischen ihnen platzieren. 

Ein Ausdruck ist ein Codeausschnitt, dessen Auswertung zu einem Einzelwert führt. Für unsere Zwecke in diesem Modul kann ein Ausdruck ein Literalwert (wie 12), eine Variable (wie numberOfTeaCups) oder eine mathematische Operation (wie 7 x 4) sein.

Ausdrucksoperatoren vergleichen zwei Werte oder bilden die Gleichheit zwischen ihnen ab. Eine Vergleichsanweisung besteht aus zwei Ausdrücken, die durch einen Ausdrucksoperator getrennt sind, und erzeugt einen booleschen Wert – entweder wahr oder falsch. 

Vergleichsoperatoren

Operator
Beschreibung
Syntax
Ergebnis
<
Kleiner als
1 < 2
TRUE
<=
Kleiner oder gleich
1 <= 2
3 <= 3
TRUE
==
Gleich
10 == 10
TRUE
!=
<>
Nicht gleich
10 != 0
10 <> 11
TRUE
>
Größer als
11 > 10
TRUE
>=
Größer oder gleich
40 >=10
40 >= 40
TRUE

Warum hat der Operator Gleich zwei Gleichheitszeichen? Beachten Sie, dass wir in dieser Anweisung ein einzelnes Gleichheitszeichen verwendet haben:

Integer i = 2;

Ein einzelnes Gleichheitszeichen (=) ist ein Zuweisungsoperator. Es dient zum Zuweisen von Werten. Zwei Gleichheitszeichen (==) sind ein Vergleichsoperator. Sie dienen zum Vergleichen zweier Werte, um festzustellen, ob sie gleich (TRUE) oder nicht gleich (FALSE) sind.

Operatoren sind besonders hilfreich, wenn Sie einen bekannten Wert mit einer Variablen vergleichen oder die Werte zweier verschiedener Variablen vergleichen möchten. 

Integer numberOfTeaCups = 2;
numberOfTeaCups == 3;  //false
numberOfTeaCups == 2; //true

Wir haben Beispiele der Variablen "integer" und "string" gesehen. Wir können auch eine boolesche Variable erstellen, die das Ergebnis eines Vergleichs enthält. Sehen Sie sich das hier an:

Integer numberOfTeaCups = 2;
Boolean result = numberOfTeaCups > 3; // 2 > 3 = false

Zeile 1 legt die Variable numberOfTeaCups auf 2 fest.

In Zeile 2 wird eine boolesche Variable mit dem Namen result erstellt, der Wert der Variablen numberOfTeaCups mit der Zahl 3 verglichen und das Ergebnis des Vergleichs (FALSE) der Variablen result zugewiesen. 

Vergleiche sind zwar hilfreich, um festzustellen, in welcher Beziehung eine Sache zu einer anderen steht. Aber wo sie wirklich glänzen, ist bei bedingten Anweisungen, um zu helfen, Entscheidungen zu treffen.

Bedingte Anweisungen

Entwickler verwenden Ausdrücke innerhalb von bedingten Anweisungen, um Entscheidungsstrukturen zu erstellen. Diese geben eine oder mehrere Bedingungen an, die vom Programm ausgewertet oder getestet werden sollen. Das war eine Menge an Informationen! Sehen wir uns das im Einzelnen an.

Eine bedingte Anweisung richtet zwei oder mehrere Optionen ein. Wenn Sie schon einmal im Prozessgenerator Kriterien definiert haben, haben Sie eine bedingte Anweisung verwendet. "If state equals California, then display records in the list view" ist beispielsweise eine bedingte Anweisung. "State equals California" ist die Bedingung und "Display records in the list view" ist die Aktion, die das Programm nur ausführt, wenn die Bedingung wahr ist. Bei diesem Beispiel sind die beiden Optionen "Datensätze anzeigen" (explizit) und "Keine Datensätze anzeigen" (implizit).

If-Else-Anweisungen
Eine häufig verwendete bedingte Anweisung in Apex ist die if-else-Anweisung. Diese sieht so aus:

if (condition is true){
    //do this
}else{
    //do this
}

Zeile 1 definiert die (in Klammern geschriebene) Bedingung.
Zeile 2 enthält den Code, der ausgeführt werden soll, wenn die Bedingung in Zeile 1 wahr ist.
In Zeile 3 wird die zweite Option eingeführt, die Option "else".
Zeile 4 enthält den Code, der ausgeführt werden soll, wenn die Bedingung in Zeile 1 falsch ist.

In Apex umgeben wir bedingte Anweisungen mit geschweiften Klammern: { }. Wenn eine geschweifte Klammer geöffnet wird, { muss es eine weitere geschlossene geschweifte Klammer geben}, die auf diesen Codeblock folgt.

Lassen Sie uns eine bedingte Anweisung in unserem Pseudocode für Teatime verwenden, um den Wasserstand im Wasserkocher zu überprüfen und anhand des Wasserstands zu entscheiden, was als Nächstes zu tun ist.

  1. Klicken Sie in der Developer Console auf Debug | Open Execute Anonymous Window.
  2. Kopieren Sie diesen Code und fügen Sie ihn in das Fenster "Enter Apex Code" ein.
  3. String waterLevel = 'full'; /*This variable keeps track of the water level status: full or empty*/
    if(waterLevel == 'empty'){
        System.debug('Fill the tea kettle');
        waterLevel = 'full'; /*Once the tea kettle is filled the variable is changed to full*/
    }else{
        System.debug('The tea kettle is full');
    }
  4. Aktivieren Sie das Kontrollkästchen Open Log und klicken Sie dann auf Execute.
  5. Das Ausführungsprotokoll wird mit dem Ergebnis der Ausführung des Codes geöffnet. Aktivieren Sie unten im Fenster das Kontrollkästchen Debug Only.

In Zeile 1 haben wir die Variable waterLevel mit full initialisiert. Im Allgemeinen werden die Variablenwerte im Code von Benutzern eingegeben oder von anderen Daten abgeleitet, die nicht im Code selbst angegeben sind. Bei unserem Teatime-Beispiel würden wir physikalische Daten von Sensoren im Wasserkocher erhalten, um den Wasserstand zu bestimmen. Wenn solche Daten nicht verfügbar sind, legen Entwickler (temporäre) Werte direkt im Code fest, damit sie ihn ausführen und testen können. Das Festlegen von Werten im Code wird als Hartcodieren bezeichnet. Zu Testzwecken haben wir den Wert der Variablen waterLevel mit full hartcodiert. Da dieser Wert bereits festgelegt wurde, wird die erste "if"-Anweisung (Zeile 2) nie ausgeführt, da waterLevel nie mit empty beginnt. 

Der Code prüft, ob die Variable waterLevel gleich empty ist. Da wir waterLevel mit full hartcodiert haben, ist die Bedingung der "if"-Anweisung "false". Wenn die "if"-Bedingung "false" ist, wird der "else"-Codeblock ausgeführt. 

Unser Code handhabt derzeit zwei Bedingungen: Wasserstand full und Wasserstand empty. Das sind aber nicht die einzigen Möglichkeiten, oder? Der Wasserkocher kann teilweise gefüllt sein. Wie handhaben wir mehr als zwei Möglichkeiten? 

"if"-Anweisungen des Typs "if-else"
Um mehr als zwei Möglichkeiten zu handhaben, verwenden wir eine "if"-Anweisung des Typs "if-else". Eine "if"-Anweisung des Typs "if-else" fügt vor der letzten "else"-Bedingung eine weitere "if"-Bedingung hinzu. Es folgt ein Beispiel aus der Praxis.

  1. Klicken Sie in der Developer Console auf Debug | Open Execute Anonymous Window.
  2. Kopieren Sie diesen Code und fügen Sie ihn in das Fenster "Enter Apex Code" ein.
  3. String waterLevel = 'half';
    if(waterLevel == 'empty'){
        System.debug('Fill the tea kettle');
        waterLevel = 'full';
    }else if(waterLevel == 'half'){
        System.debug('Fill the tea kettle');
        waterLevel = 'full';
    }else{ /*This statement only runs if line 2 and line 5 result in false.*/
        System.debug('The tea kettle is full');
    }
  4. Aktivieren Sie das Kontrollkästchen Open Log und klicken Sie dann auf Execute.
  5. Das Ausführungsprotokoll wird mit dem Ergebnis der Ausführung des Codes geöffnet. Aktivieren Sie unten im Fenster das Kontrollkästchen Debug Only.

Ändern Sie beim Testen des Codes den Wert der Variable waterLevel in Zeile 1. Die Ausgabe im Debug-Protokoll spiegelt die Änderung wider. Probieren Sie alle drei Werte aus: half, full und empty.

Ordnen Sie bedingte Anweisungen so an, dass die erste Bedingung die häufigste ist. Bei dieser Anordnung reduziert sich die Menge an Code, der bei jeder Ausführung des Codeblocks ausgeführt wird. Bei unserem Teatime-Beispiel ist der Wasserkocher höchstwahrscheinlich leer, weshalb wir diesen Zustand an die erste Stelle setzen. Es ist unwahrscheinlich, dass der Wasserkocher voll ist. Deshalb prüfen wir zuletzt, ob dieser Zustand vorliegt. 

"switch"-Anweisungen

Eine effizientere Alternative einer if-else-Anweisung ist eine "switch"-Anweisung. Eine "switch"-Anweisung gibt eine Reihe von Werten an und testet einen Ausdruck, um festzustellen, ob er mit einem dieser Werte übereinstimmt. Das Ganze sieht wie folgt aus:

switch on expression{
    when value1{
        //code block 1
    }
    when value2{
        //code block 2
    }
    when else{ //if none of the previous values apply
        //code block 3
    }
}

In einer "switch"-Anweisung können hinter dem reservierten Wort when ein oder mehrere Werte stehen. 

switch on expression{
    when value1{ //single value
        //code block 1
    }
    when value2, value 3{ //multiple values
        //code block 2
    }
}

Lassen Sie uns "switch"-Anweisungen auf unseren Teatime-Pseudocode anwenden.

  1. Klicken Sie in der Developer Console auf Debug | Open Execute Anonymous Window.
  2. Kopieren Sie diesen Code und fügen Sie ihn in das Fenster "Enter Apex Code" ein.
  3. String waterLevel = 'empty';
    //option 1 using a single value
    switch on waterLevel{
        when 'empty'{
            System.debug('Fill the tea kettle');
        }
        when 'half'{
            System.debug('Fill the tea kettle');
        }
        when 'full'{
            System.debug('The tea kettle is full');
        }
        when else{
            System.debug('Error!');
        }
    }
    //option 2 using multiple values
    switch on waterLevel{
        when 'empty', 'half'{ //when waterLevel is either empty or half
            System.debug('Fill the tea kettle');
        }
        when 'full'{
            System.debug('The tea kettle is full');
        }
        when else{
            System.debug('Error!');
        }
    }
    
  4. Aktivieren Sie das Kontrollkästchen Open Log und klicken Sie dann auf Execute.
  5. Das Ausführungsprotokoll wird mit dem Ergebnis der Ausführung des Codes geöffnet. Aktivieren Sie unten im Fenster das Kontrollkästchen Debug Only.

Logische Operatoren

Sie haben gesehen, wie zwei oder mehr Bedingungen zu handhaben sind. Nun, was tun Sie, wenn eine einzelne Bedingung von mehreren Werten erfüllt werden kann? 

Beispiel für OR:
if (this OR that){
    //do this
}else{
    //otherwise do this
}

 Beispiel für AND: 
if (this AND that){
    //do this
}else{
    //otherwise do this
}

Die logischen Operatoren AND und OR erlauben Ihnen, Code zu schreiben, der mehr als einen Wert überprüft, um festzustellen, ob eine Bedingung wahr oder falsch ist. Der AND-Operator verlangt, dass alle Werte wahr sind, damit die Bedingung erfüllt ist. Der OR-Operator verlangt, dass mindestens einer der Werte wahr ist, damit die Bedingung erfüllt ist.

Logische Operatoren

Logischer Operator
Syntax
Beschreibung
&& (AND)
X && Y

System.debug(true && true); // true

System.debug(false &&  true); //false

System.debug(true && false); // false

System.debug(false && false); //false
X und Y sind boolesche Werte. Wenn sowohl X als auch Y wahr ist, dann ist der Ausdruck wahr. Andernfalls ist der Ausdruck falsch.
|| (OR)
X || Y

System.debug(true || true); //true

System.debug(false || true); //true

System.debug(true || false); //true

System.debug(false || false); //false
X und Y sind boolesche Werte. Wenn sowohl X als auch Y falsch ist, dann ist der Ausdruck falsch. Andernfalls ist der Ausdruck wahr.

Lassen Sie uns logische Operatoren ausprobieren. Hier ist unser Code, als er als "if"-Anweisung des Typs "if-else" geschrieben wurde.

String waterLevel = 'half';
if(waterLevel == 'empty'){
    System.debug('Fill the tea kettle');
    waterLevel = 'full';
}else if(waterLevel == 'half'){
    System.debug('Fill the tea kettle');
    waterLevel = 'full';
}else{ //This statement only runs if line 3 and line 6 result in false.
    System.debug('The tea kettle is full');
}

Sehen Sie sich die Zeilen 3-4 und 6-7 an. Sie sind identisch. Dies wird redundanter Code genannt. Die Vermeidung von Redundanz ist eine bewährte Vorgehensweise, da sie den Code leichter zu lesen, zu verstehen, zu debuggen und zu warten macht. Unser Code führt die gleichen Aktionen durch, egal ob waterLevel entweder empty oder half ist. Wir können diesen Code vereinfachen, indem wir empty und half in einer Bedingung kombinieren. Wir verwenden den Operator OR so, dass die Bedingung erfüllt ist, wenn einer der Werte (empty oder half) wahr ist.

  1. Klicken Sie in der Developer Console auf Debug | Open Execute Anonymous Window.
  2. Kopieren Sie diesen Code und fügen Sie ihn in das Fenster "Enter Apex Code" ein.
  3. String waterLevel = 'half';
    if(waterLevel == 'empty' || waterLevel == 'half'){
        System.debug('Fill the tea kettle');
        waterLevel = 'full';
    }else{ //This statement only runs if line 3 false.
        System.debug('The tea kettle is full');
    }
  4. Aktivieren Sie das Kontrollkästchen Open Log und klicken Sie dann auf Execute.
  5. Das Ausführungsprotokoll wird mit dem Ergebnis der Ausführung des Codes geöffnet. Aktivieren Sie unten im Fenster das Kontrollkästchen Debug Only.

Und siehe da: Wir haben Redundanz aus unserem Code beseitigt. Die Verwendung logischer Operatoren (&& und |||) ist ein effektiver Weg, redundanten Code zu entfernen oder zu reduzieren und die Lesbarkeit zu verbessern.

Halten Sie Ihren Code übersichtlich

Bei der Programmierung gibt es oft mehr als eine Möglichkeit, ein Ziel zu erreichen. Sie können beispielsweise "switch- oder "if-else"-Anweisungen verwenden und zum gleichen Ergebnis kommen. Der wichtigste zu bedenkende Punkt bei der Auswahl eines Anweisungstyps ist, wie sich diese auf die Lesbarkeit Ihres Codes auswirkt. Bei der weiteren Arbeit mit Code erfahren Sie mehr darüber, wie Sie Ihren Code übersichtlich halten können. Konzentrieren Sie sich im Moment darauf, Ihren Code leicht lesbar und verständlich zu gestalten. 

Ressourcen