Übung: Funktionen

3 Minuten

In dieser Übung gestalten Sie Ihren Code wiederverwendbar. Diesen Code hat ein anderer Programmierer aus Ihrem Team geschrieben. Sie müssen nun Funktionen daraus erstellen.

Erstellen von Funktionen

Beginnen Sie mit dem Gerüstbau für ein neues F#-Projekt, wählen dann einen Codeausschnitt, und wandeln Sie diesen in eine Funktion mit Parametern um.

Erstellen Sie ein neues F#-Projekt, indem Sie dotnet new ausführen.

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

Nachdem Sie nun ein neues Projekt erstellt haben, sehen wir uns den Code an.

Hier ist der Code Ihres Kollegen:

let no = card % 13
if no = 1 then "Ace"
elif no = 0 then "King"
elif no = 12 then "Queen"
elif no = 11 then "Jack"
else string no

Ersetzen Sie den Standardcode in der Datei "Program.fs " durch den folgenden Code:
```
let cardFace card = 
   let no = card % 13
   if no = 1 then "Ace"
   elif no = 0 then "King"
   elif no = 12 then "Queen"
   elif no = 11 then "Jack"
   else string no
```
Die erste Zeile des Codes (let cardFace card) macht ihn zu einer Funktion. Nun ist dieser eine Funktion namens cardface(), die den Parameter card annimmt.
Fügen Sie den folgenden Code unter der Funktion cardface() hinzu.
```
printfn "%s" (cardFace 11)
```
Führen Sie das Projekt aus, indem dotnet run Sie in der Konsole aufrufen.
```
dotnet run
```
Jetzt wird die folgende Ausgabe angezeigt:
```
Jack
```

Herzlichen Glückwunsch! Sie haben einen Codeausschnitt ausgewählt, den Sie wiederverwenden möchten und deshalb in eine Funktion umgewandelt haben.

Hinzufügen von Typen

Sie haben den Code Ihres Kollegen in eine Funktion umgewandelt. Weil Sie diesen Code noch lesbarer gestalten möchten, fügen Sie ihm Typdefinitionen hinzu.

Ändern Sie Ihre vorhandene Funktion cardface() so, dass sie wie folgt aussieht:

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

Führen Sie jetzt das Projekt dotnet run aus.
```
dotnet run
```
Jetzt wird die folgende Ausgabe angezeigt:
```
Jack
```
Der Code funktioniert weiterhin und ist nun aussagekräftiger, da Sie dem Eingabeparameter einen Typ hinzugefügt haben.
Ändern Sie die cardface()-Funktion so, dass sie wie folgt aussieht:
```
let cardFace (card:int) :string = 
    let no = card % 13
    if no = 14 || no = 1 then "Ace"
    elif no = 13 then "King"
    elif no = 12 then "Queen"
    elif no = 11 then "Jack"
    else string no
```
An diesem Punkt haben Sie der Funktion den Rückgabetyp :string hinzugefügt. Das bedeutet, dass die Funktion eine Zeichenfolge zurückgibt.
Führen Sie das Projekt mit dotnet run aus.
```
dotnet run
```
Es sollte wieder die folgende Ausgabe angezeigt werden.
```
Jack
```

Herzlichen Glückwunsch! Ihrem Code wurden jetzt Typen hinzugefügt.

Feedback

War diese Seite hilfreich?