Ćwiczenie — używanie zmiennych do przechowywania danych

3 min

W tym ćwiczeniu dowiesz się, jak tworzyć programy wyjściowe kodu do konsoli programu . Tworzysz początek programu kalkulatora, a także analizujesz program, który zawiera błędy i dowiesz się, jak naprawić błędy.

Tworzenie projektu

Zacznijmy od utworzenia projektu. Projekt można utworzyć z poziomu wiersza polecenia przy użyciu dotnet pliku wykonywalnego.

Uruchom w konsoli polecenie dotnet new.
```
dotnet new console --language F# -o Variables
cd Variables
```
To polecenie tworzy nowy projekt języka F# w katalogu Zmienne.
Zastąp kod w pliku Program.fs następującym kodem:
```
[<EntryPoint>]
let main argv =
    printfn "Welcome to the calculator program"
    // read input from the console and assign to `sum`
    let sum = 0
    printfn "The sum is %i" sum
    0
```
printfn Pierwsze stwierdzenie z zadowoleniem przyjmuje użytkownika programu. W drugim wierszu znajduje się komentarz, który zaczyna się od // wyświetlania kodu, który zostanie zaimplementowany w następnej lekcji ćwiczenia. Następnie masz plik let sum = 0. Na koniec utworzysz zmienną sum , która przechowuje wynik obliczenia.
Uruchom program, uruchamiając polecenie dotnet run.
```
dotnet run
```
Powinny zostać wyświetlone następujące dane wyjściowe:
```
Welcome to the calculator program
The sum is 0
```

Gratulacje! Udało Ci się utworzyć szkielet projektu, rozpocząć od większego projektu i uruchomić go.

Poprawianie błędu

Częścią nauki programowania w dowolnym języku jest uczenie się, jak rozpoznawać błędy kompilacji i naprawiać je. W tym ćwiczeniu należy utworzyć szkielet nowego projektu. Przed kontynuowaniem upewnij się, że jesteś jednym poziomem w strukturze katalogów.

Utwórz szkielet nowego projektu języka F#, uruchamiając polecenie dotnet new.
```
dotnet new console --language F# -o Errors
cd Errors
```
Zastąp kod w pliku Program.fs następującym kodem:
```
[<EntryPoint>]
let main argv =
    let aNumber = 0
    printfn "Here's a number %s" aNumber
    0 // return an integer exit code
```
Napiwek

Wstrzymywanie na sekundę i odczytywanie poprzedniego kodu. Czy uważasz, że kod zostanie skompilowany? Dlaczego tak lub dlaczego nie?
Uruchom projekt, uruchamiając polecenie dotnet run.
```
dotnet run
```
Zostanie wyświetlony komunikat o błędzie podobny do następującego tekstu:
```
/<path>/Errors/Program.fs(8,34): error FS0001: This expression was expected to have type    'string'    but here has type    'int' [/<path>/Errors/Errors.fsproj]

The build failed. Fix the build errors and run again.
```
Komunikat o błędzie to "oczekiwany ciąg, ale tutaj został wpisany int". Czy rozumiesz, jaki jest problem? Problem polega na użyciu formatera %s zamiast %i z powodu nadania printfn funkcji zmiennej aNumber typu int. Poprawmy kod.
Znajdź wiersz z kodem "printfn "Oto liczba %s" aNumber" i zmień go na:
```
printfn "Here's a number %i" aNumber
```
Zapisz plik i uruchom go ponownie za pomocą polecenia dotnet run. Powinny zostać wyświetlone następujące dane wyjściowe:
```
Here's a number 0
```

Gratulacje! Debugowano program, odczytując kod, rozumiejąc, co było nie tak i naprawiając go. Rozpoznawanie komunikatów o błędach i wiedza na temat poprawiania błędów są niezbędnymi umiejętnościami, które mają być deweloperami.

Opinia

Czy ta strona była pomocna?