Übung: Verwenden von Schleifen

2 Minuten

In dieser Übung erstellen Sie einen Kartenstapel für ein Kartenspiel, das sich in der Entwicklung befindet. Sie verwenden Schleifenkonstrukte, um die Karten zu durchlaufen und dann eine Karte auf dem Bildschirm auszugeben. Ihre Kollegen haben aus dem Code, den Sie in der ersten Übung geschrieben haben, zwischenzeitlich eine Funktion erstellt.

Erstellen eines Gerüsts für ein Projekt

Beginnen Sie mit dem Erstellen eines Gerüsts für ein neues F#-Projekt in der Konsole. Führen Sie den Befehl dotnet new aus:

dotnet new console --language F# -o Loops
cd Loops

Erstellen einer Kartenbeschreibung

Ihre Kollegen haben aus Ihrem Code aus der vorherigen Übung eine Funktion erstellt, damit er wiederverwendbar ist. So sieht Ihr Code jetzt aus:

let cardDescription (card: int) : string =
    let cardNo: int = card % 13
    if cardNo = 1 then "Ace"
    elif cardNo = 11 then "Jack"
    elif cardNo = 12 then "Queen"
    elif cardNo = 0 then "King"
    else string cardNo

So erstellen Sie eine Kartenbeschreibung:

Ersetzen Sie den Inhalt von Program.fs durch den folgenden Code:
```
open System

let cardDescription (card: int) : string =
    let cardNo: int = card % 13
    if cardNo = 1 then "Ace"
    elif cardNo = 11 then "Jack"
    elif cardNo = 12 then "Queen"
    elif cardNo = 0 then "King"
    else string cardNo

[<EntryPoint>]
let main argv =
    // implement the rest
    0 // return an integer exit code
```
Die Funktion heißt cardDescription, und der Eingabeparameter ist card. Ihre Kollegen haben Ihnen einen Codeausschnitt zur Verfügung gestellt. Sie möchten, dass Sie eine ähnliche Funktion implementieren. Diese Funktion soll die Farbe der Karte bestimmen. Sie haben diesen Codeausschnitt erhalten:
```
let suit (no:int) : string = 
    let suitNo:int = no / 13
    // add implementation here 
```
Wenden Sie das Wissen an, das Sie sich zu if...else angeeignet haben, um die Farbe einer Karte zu bestimmen. Die Regeln sind: 0 ist Herz, 1 ist Pik, 2 ist Karo und 3 ist Kreuz.

Tipp

Überlegen Sie sich kurz, wie Sie Ihr Wissen anwenden können, bevor Sie fortfahren.

Nehmen Sie die folgenden Änderungen am Code vor:

let suit (no:int) : string = 
    let suitNo:int = no / 13
    if suitNo = 0 then "Hearts"
    elif suitNo = 1 then "Spades"
    elif suitNo = 2 then "Diamonds"
    else "Clubs"

Der Code in Program.fs sollte nun wie das folgende Beispiel aussehen:

open System

let suit (no:int) : string = 
    let suitNo:int = no / 13
    if suitNo = 0 then "Hearts"
    elif suitNo = 1 then "Spades"
    elif suitNo = 2 then "Diamonds"
    else "Clubs" 

let cardDescription (card: int) : string =
    let cardNo: int = card % 13
    if cardNo = 1 then "Ace"
    elif cardNo = 11 then "Jack"
    elif cardNo = 12 then "Queen"
    elif cardNo = 0 then "King"
    else string cardNo

[<EntryPoint>]
let main argv =
    // implement program
    0 // return an integer exit code

Herzlichen Glückwunsch, Sie haben diesen Teil des Kartenspiels abgeschlossen.

Ausgeben des Kartenstapels

Ihre Kollegen haben Ihnen auch bei der Zusammenstellung eines Kartenstapels geholfen. Sie müssen ihn nur noch ausgeben. Hier sehen Sie den Code für den Kartenstapel:

let cards = [ 1; 10; 2; 34 ]

So geben Sie den Kartenstapel aus:

Fügen Sie der Methode cards die Definition main() hinzu:
```
 [<EntryPoint>]
 let main argv =
     let cards = [ 1; 10; 2; 34 ]
     // implement program
     0 // return an integer exit code
```
Der Kartenstapel enthält nur vier Karten. In einer realistischeren Implementierung würde der Code alle 52 Karten enthalten, aber diese Liste reicht für ein Beispiel aus.

Auch in diesem Fall haben Ihre Kollegen bereits Code für Sie geschrieben. Sie müssen nur die fehlenden Elemente ergänzen. Hier sehen Sie einen Codeausschnitt:
```
// add for loop
  printfn "%s of %s" (cardDescription(card)) (suit(card))
```
Der Code besteht aus einer auskommentierten Zeile. Sie müssen Code hinzufügen, um eine for...in-Schleife zu implementieren.

Fügen Sie der Methode main() den folgenden Code hinzu, um die for...in-Schleife zu implementieren:

for card in cards do
  printfn "%s of %s" (cardDescription(card)) (suit(card))

Die Methode main() sollte jetzt wie der folgende Code aussehen:

[<EntryPoint>]
let main argv =
    let cards = [ 1; 10; 2; 34 ]
    for card in cards do
      printfn "%s of %s" (cardDescription(card)) (suit(card))
    0 // return an integer exit code

Führen Sie das Projekt aus, indem Sie dotnet run aufrufen:
```
dotnet run
```
Die folgende Ausgabe wird angezeigt:
```
Ace of Hearts 
10 of Hearts
2 of Hearts
8 of Diamonds 
```

Herzlichen Glückwunsch. Sie haben den Code, den Sie und Ihre Kollegen implementiert haben, zu einem realistischeren Programm weiterentwickelt.

Program.fs sieht nun wie der folgende Code aus:

open System

let suit (no:int) : string = 
    let suitNo:int = no / 13
    if suitNo = 0 then "Hearts"
    elif suitNo = 1 then "Spades"
    elif suitNo = 2 then "Diamonds"
    else "Clubs" 

let cardDescription (card: int) : string =
    let cardNo: int = card % 13
    if cardNo = 1 then "Ace"
    elif cardNo = 11 then "Jack"
    elif cardNo = 12 then "Queen"
    elif cardNo = 0 then "King"
    else string cardNo

[<EntryPoint>]
let main argv =

    let cards = [ 1; 10; 2; 34 ]

    for card in cards do
      printfn "%s of %s" (cardDescription(card)) (suit(card))
    0 // return an integer exit code

Feedback

War diese Seite hilfreich?