Verwenden von Schleifen zum Durchlaufen von Anweisungen

Abgeschlossen

Sie sind an einen Punkt in Ihrem Programm gelangt, an dem Sie eine Gruppe von Anweisungen mehrfach ausführen müssen. Möglicherweise arbeiten Sie mit einer Struktur von Typ Liste, die Sie durchlaufen möchten. Oder Sie müssen ganz allgemein einen Vorgang wiederholen, bis eine bestimmte Bedingung erfüllt ist. In diesen Szenarien können Sie Schleifen verwenden.

Schleifen

Eine Schleife durchläuft einen Wertebereich. Für jeden Wert führt der Code eine Aktion aus, z. B. das Ausgeben von Ergebnissen auf einem Bildschirm oder das Verwenden des Werts in einem Vorgang. In F# gibt es drei Schleifenarten:

• for...in: Das for...in -Konstrukt geht davon aus, dass eine aufzählbare Sammlung vorliegt, die durchlaufen werden kann. Es durchläuft jeden Wert in einer Sammlung.
• for...to: Die for...to-Schleife beginnt und endet bei den Werten, die für die Iteration festgelegt wurden. Sie wird durchlaufen, bis sie den Wert einer Schleifenvariablen erreicht.
• while...do: Die while...do-Schleife ist nicht so stark auf eine enumerierbare Auflistung wie die ersten beiden Konstrukte ausgerichtet. Stattdessen wird die Schleife ausgeführt, bis eine Bedingung erfüllt ist.

Verwenden einer for...in-Schleife für jeden Wert in einer Sammlung

Das for...in-Konstrukt funktioniert auf Grundlage einer aufzählbaren Sammlung. Es implementiert System.Collections.IEnumerable und enthält Listen, Sequenzen, Arrays und andere Typen. Dies ist die Syntax für eine for...in-Schleife:

for <pattern> in <enumerable-expression> do
  <body-expression>

Es ist wichtig, einige Schlüsselwörter zu kennen:

• Muster: Das Muster kann das aktuelle Element oder ein Tupel sein. Ein Beispiel ist das Durchlaufen einer Sequenz. Der folgende Code ist ein Beispiel dafür, wenn das Muster den aktuellen Wert i hat. Die for-Schleife durchläuft die Liste list und gibt dann jeden Wert in der Sammlung aus:

  let list = [1; 2; 3; 4; 5]
  for i in list do
     printf "%d " i
  

• Aufzählbarer Ausdruck: Der aufzählbare Ausdruck ist das, was Sie durchlaufen. Dabei kann es sich um eine Liste oder eine Sequenz handeln.

• Körperausdruck: Der Körperausdruck ist, wo Sie die Aufgabe ausführen, die Sie beabsichtigen, wie drucken oder eine Berechnung durchführen.

Verwenden einer for...to-Schleife bis zu einer Schleifenvariablen

Das for...to-Konstrukt unterscheidet sich geringfügig von einer for...in-Schleife. Die for...to-Schleifenvariable stellt eine Grenze dar, an der die Iteration beendet werden soll. Die entsprechende Syntax sieht so aus:

for <identifier = start> [ to | downto ] <finish> do
    <body-expression>

Sie müssen sich mit den Syntaxkomponenten vertraut machen:

• identifier = start: Diese Syntax ist eine Zuweisung. Hier entscheiden Sie in der Regel, welche Variable Sie im Rahmen der Iteration nachverfolgen möchten und mit welchem Wert diese beginnen soll.
• [to | downto]: Sie haben die Wahl zwischen zwei verschiedenen Schlüsselwörtern. to bedeutet, dass die Schleife bis zu dieser Zahl durchlaufen wird. Wenn Sie downto verwenden, verringert sich der Wert Ihres Bezeichners, bis er diese Zahl erreicht.

Hier sehen Sie ein Beispiel für die Verwendung einer for...to-Schleife:

for i = 1 to 10 do
  printfn "%i " i  // prints 1 2 3 4 5 6 7 8 9 10

Die Schleife gibt alle Werte zwischen 1 und 10 (einschließlich 10) aus. Im folgenden Beispiel wird das for...downto-Konstrukt verwendet. Dieses Konstrukt funktioniert ähnlich wie for...to, jedoch genau umgekehrt. Der folgende Code zeigt, wie Sie die Werte von 10 bis 1, einschließlich 1, ausgeben können:

for i = 10 downto 1 do
  printfn "%i" i  // prints 10 9 8 7 6 5 4 3 2 1

Verwenden einer while...do-Schleife bis zur Erfüllung einer Bedingung

Das while...do-Konstrukt unterscheidet sich von den Konstrukten for...in und for...to. while...do durchläuft keine Sammlung. Verwenden Sie stattdessen eine while...do-Schleife, wenn Ihre Logik durchlaufen werden muss, bis eine Bedingung erfüllt ist. Ein Beispiel ist das Akzeptieren von Befehlszeilenargumenten, bis ein Benutzer quit eingibt.

Dieser Code veranschaulicht die Syntax eines while...do-Konstrukts:

while <test-expression> do
  <body-expression>

Ein Ratespiel ist ein gutes Beispiel für die Verwendung eines while...do-Konstrukts:

open System

let mutable quit = false
let no = 11
while not quit do
   printf "Guess a number: "
   let guess = Console.ReadLine() 
   let guessNo = int guess
   if guessNo = no then
      quit <- true
      printfn "You guessed correctly %i is the secret number" no
   else
      printfn "%i is incorrect" guessNo

Der Code führt eine Reihe von Anweisungen aus, bis die Variable quit den Wert true aufweist. Wenn ein Benutzer richtig geraten hat, wird der Wert für quit auf true festgelegt, und die Schleife wird beendet.