Øvelse – brug løkker

2 minutter

I denne øvelse skal du bygge et sæt kort til et kortspil, der er under udvikling. Du skal bruge løkkekonstruktioner til at gentage over kortene og derefter udskrive kortet på skærmen. Dine kolleger har også arbejdet hårdt, og de har indarbejdet den kode, du oprettede i den første øvelse, i en funktion.

Stillads for et projekt

Start med at oprette et nyt F#-projekt i din konsol. Kør kommandoen dotnet new:

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

Opret en kortbeskrivelse

Dine kolleger har taget den kode, du skrev i den forrige øvelse, og gjort den til en funktion, så den kan genbruges. Sådan ser koden ud nu:

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

Sådan opretter du en kortbeskrivelse:

Erstat indholdet med følgende kode i Program.fs:
```
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
```
Funktionen kaldes cardDescription, og inputparameteren er card. Dine kollegaer gav dig et kodestykke, du kunne arbejde med. De vil gerne have, at du implementerer en lignende funktion, men en funktion bestemmer, hvad der passer til kortet. De gav dig dette kodestykke:
```
let suit (no:int) : string = 
    let suitNo:int = no / 13
    // add implementation here 
```
Nu kan du bruge den viden, du har fået om if...else til at bestemme, hvad der passer til et kort. Reglerne er: 0 er hjerter, 1 er spar, 2 er diamanter, og 3 er klubber.

Drikkepenge

Sæt din viden på pause, og tænk over, hvordan du anvender den, før du går videre.

Foretag følgende ændringer af koden:

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"

Koden i Program.fs bør nu se ud som i dette eksempel:

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

Tillykke, du er færdig med den del af kortspillet.

Udskriv dækket

Dine kolleger har igen hjulpet dig med at oprette et kortsæt. Du skal bare udskrive den. Her er koden for kortdækket:

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

Sådan udskriver du dækket:

Føj definitionen cards til metoden main():
```
 [<EntryPoint>]
 let main argv =
     let cards = [ 1; 10; 2; 34 ]
     // implement program
     0 // return an integer exit code
```
Bunken indeholder kun fire kort. I en mere realistisk implementering ville koden indeholde alle 52 kort, men denne liste vil være tilstrækkelig til et eksempel.

Dine kolleger har igen skrevet kode til dig. Du skal bare udfylde, hvad der mangler. Her er et kodestykke:
```
// add for loop
  printfn "%s of %s" (cardDescription(card)) (suit(card))
```
Koden består af en udkommenteret linje. Din opgave er at tilføje kode for at implementere en for...in løkke.

Føj følgende kode til metoden main() for at implementere for...in-løkken:

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

Metoden main() bør nu se ud som denne kode:

[<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

Kør projektet ved at kalde dotnet run:
```
dotnet run
```
Du bør kunne se følgende output:
```
Ace of Hearts 
10 of Hearts
2 of Hearts
8 of Diamonds 
```

Tillykke. Du har arbejdet med kode, som du og dine kolleger implementerede og udviklede til et mere realistisk program.

Program.fs- ser nu ud som denne kode:

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

Var denne side nyttig?