Exercício – funções

3 minutos

Neste exercício, você tornará o código reutilizável. É um código que outro programador da sua equipe criou, mas seu trabalho é transformá-lo em funções.

Criar funções

Comece fazendo scaffolding de um novo projeto F# e, depois, transforme uma parte do código em uma função com parâmetros.

Crie um projeto F# executando dotnet new.

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

Agora que você tem um novo projeto, vamos dar uma olhada no código.

Este é o código do seu colega.

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

Substitua o código padrão no arquivo Program.fs pelo seguinte código:
```
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
```
A primeira linha desse código let cardFace card transforma ele em uma função. Agora ele é uma função chamada cardface() que usa o parâmetro card.
Adicione o código a seguir abaixo da função cardface().
```
printfn "%s" (cardFace 11)
```
Execute o projeto chamando dotnet run no console.
```
dotnet run
```
Agora, a seguinte saída será exibida:
```
Jack
```

Parabéns! Você pegou uma parte do código que queria deixar reutilizável e transformou-a em uma função.

Adicionar tipos

Você transformou o código do seu colega em uma função. Para deixar esse código mais legível, você decide adicionar definições de tipo a ele.

Modifique sua função cardface() existente para que ela tenha a seguinte aparência:

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

Agora execute o projeto dotnet run.
```
dotnet run
```
Agora, a seguinte saída será exibida:
```
Jack
```
O código funciona da mesma forma e você o tornou mais claro, adicionando um tipo ao parâmetro de entrada.

Altere sua função cardface() para que ela tenha a seguinte aparência:

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

Neste ponto, você adicionou um tipo de retorno à função :string, o que significa que a função retorna uma cadeia de caracteres.

Execute o projeto dotnet run.
```
dotnet run
```
Mais uma vez, você verá a seguinte saída:
```
Jack
```

Parabéns! Agora, o código contém tipos adicionados.

Comentários

Esta página foi útil?