Wskazówki: pierwszy program w języku F#

Artykuł
06/10/2015

Visual Studio 2010 zawiera nowy język programowania F#.F# jest językiem wieloparadygmatowym, obsługującym programowanie funkcyjne oprócz tradycyjnego programowania zorientowanego obiektowo i koncepcji .NET.Poniższe przykłady wprowadzają niektóre funkcje i składnię.W przykładach przedstawiono sposób deklarowania prostych zmiennych, zapisywania i testowania funkcji, tworzenia krotek i list, a także definiowania i używania klas.

[!UWAGA]

Na komputerze w poniższych instrukcjach mogą być wyświetlane inne nazwy i lokalizacje niektórych elementów interfejsu użytkownika programu Visual Studio. Te elementy są określane przez numer wersji Visual Studio oraz twoje ustawienia. Aby uzyskać więcej informacji, zobacz Dostosowywanie ustawień środowiska deweloperskiego w Visual Studio.

Aby utworzyć nową aplikację konsoli

W menu Plik, wskaż Nowy i kliknij przycisk Projekt.
Jeśli nie widzisz Visual F# w okienku Kategorie szablonów, kliknij Inne języki, a następnie kliknij przycisk Visual F#.W okienku Szablony na środku wyświetlana jest lista szablonów języka F#.
Zobacz na górną część okienka Szablony, aby upewnić się, że .NET Framework 4 pojawia się w polu Platforma docelowa.
Kliknij Aplikacja F# na liście szablonów.
Wpisz nazwę projektu w polu Nazwa.
Kliknij OK.

W Eksploratorze rozwiązań pojawi się nowy projekt.

Aby użyć słowa kluczowego let do zadeklarowania i używania identyfikatorów

Skopiuj i wklej następujący kod do Program.fs.Każdy identyfikator anInt, aString i anIntSquared jest wiązany z wartością.
```
let anInt = 5
let aString = "Hello" 
// Perform a simple calculation and bind anIntSquared to the result. 
let anIntSquared = anInt * anInt
```
[!UWAGA]

Jeśli nie widzisz kodu w widoku klasycznym, upewnij się, że Filtr języka w nagłówku poniżej tytułu tematu jest ustawiony, tak aby obejmował F#.

Aby wyświetlić wyniki w oknie trybu interaktywnego F#

Wybierz wyrażenia let w poprzedniej procedurze.
Kliknij prawym przyciskiem myszy zaznaczony obszar, a następnie kliknij Wyślij do środowiska interaktywnego.Alternatywnie, naciśnij klawisze ALT+ENTER.
Pojawi się okno Tryb interaktywny F#, a wyniki interpretacji wyrażeń let są wyświetlane, jak pokazano w poniższych wierszach.Typy są wywnioskowane na podstawie określonych wartości.

val anInt : int = 5

val aString : string = "Hello"

val anIntSquared : int = 25

Aby wyświetlić wyniki w oknie wiersza polecenia

Dodaj następujące wiersze do Program.fs.

System.Console.WriteLine(anInt)
System.Console.WriteLine(aString)
System.Console.WriteLine(anIntSquared)

Naciśnij klawisze CTRL+F5, aby uruchomić kod.Pojawi się okno wiersza polecenia zawierające następujące wartości.

5

Hello

25

Można zweryfikować wywnioskowane typy zatrzymując wskaźnik myszy nad nazwami identyfikatorów anInt, aString i anIntSquared w poprzednich instrukcjach WriteLine.

Aby zdefiniować i uruchomić funkcję

Użyj wyrażenia let do zdefiniowania funkcji podnoszącej do kwadratu, jak pokazano w poniższym kodzie.Funkcja ma jeden parametr n i zwraca kwadrat argumentu wysyłany do n.

let square n = n * n
// Call the function to calculate the square of anInt, which has the value 5. 
let result = square anInt
// Display the result.
System.Console.WriteLine(result)

Naciśnij klawisze CTRL+F5, aby uruchomić kod.Wyświetlany jest wynik 25.
Funkcja rekurencyjna wymaga wyrażenia let rec.W poniższym przykładzie zdefiniowano funkcję, która oblicza silnię parametru n.
```
let rec factorial n = 
    if n = 0 
    then 1 
    else n * factorial (n - 1)
System.Console.WriteLine(factorial anInt)
```
Naciśnij klawisze CTRL+F5, aby uruchomić funkcję.Wyświetlany wynik 120 jest silnią liczby 5.

Aby utworzyć kolekcje: listy i krotki

Jednym ze sposobów agregacji wartości jest używanie krotki, jak pokazano w poniższym kodzie.

let turnChoices = ("right", "left")
System.Console.WriteLine(turnChoices)
// Output: (right, left) 

let intAndSquare = (anInt, square anInt)
System.Console.WriteLine(intAndSquare)
// Output: (5,25)

Innym sposobem agregacji wartości jest używanie listy, jak pokazano w poniższym kodzie.
```
// List of best friends. 
let bffs = [ "Susan"; "Kerry"; "Linda"; "Maria" ] 
```
Dodaj nowego najlepszego przyjaciela do listy, używając operatora "cons" (::).Zauważ, że operacja nie zmienia wartości bffs.Wartość bffs jest niezmienialna, dlatego nie można jej zmienić.
```
// Bind newBffs to a new list that has "Katie" as its first element.
let newBffs = "Katie" :: bffs
```
Użyj printfn do wyświetlenia list.Funkcja printfn pokazuje pojedyncze elementy, które są zawarte w wartościach strukturalnych.
```
printfn "%A" bffs
// Output: ["Susan"; "Kerry"; "Linda"; "Maria"]
printfn "%A" newBffs
// Output: ["Katie"; "Susan"; "Kerry"; "Linda"; "Maria"]
```
Wyniki można wyświetlić, naciskając klawisze CTRL+F5 lub zaznaczając sekcję kodu, a następnie naciskając klawisze ALT+ENTER.

Aby utworzyć i używać klasy

W poniższym kodzie tworzona jest klasa Person, która ma dwie właściwości Name i Age.Name jest właściwością tylko do odczytu.Jej wartość jest niezmienialna, tak jak większość wartości w programowaniu funkcyjnym.Można utworzyć zmienialne wartości w języku F#, jeśli są potrzebne, lecz muszą być jawnie zdefiniowane jako zmienialne.W poniższej definicji klasy, wartość Age jest przechowywana w zmienialnej zmiennej lokalnej internalAge.Wartość internalAge może być zmieniana.

// The declaration creates a constructor that takes two values, name and age. 
type Person(name:string, age:int) =
    // A Person object's age can be changed. The mutable keyword in the 
    // declaration makes that possible. 
    let mutable internalAge = age

    // Declare a second constructor that takes only one argument, a name. 
    // This constructor calls the constructor that requires two arguments, 
    // sending 0 as the value for age. 
    new(name:string) = Person(name, 0)

    // A read-only property. 
    member this.Name = name
    // A read/write property. 
    member this.Age
        with get() = internalAge
        and set(value) = internalAge <- value

    // Instance methods. 
    // Increment the person's age. 
    member this.HasABirthday () = internalAge <- internalAge + 1

    // Check current age against some threshold. 
    member this.IsOfAge targetAge = internalAge >= targetAge

    // Display the person's name and age. 
    override this.ToString () = 
        "Name:  " + name + "\n" + "Age:   " + (string)internalAge

Aby przetestować klasę, należy zadeklarować dwa obiekty Person, wprowadzić niektóre zmiany i wyświetlić wyniki, jak pokazano w poniższym kodzie.

// The following let expressions are not part of the Person class. Make sure 
// they begin at the left margin. 
let person1 = Person("John", 43)
let person2 = Person("Mary")

// Send a new value for Mary's mutable property, Age.
person2.Age <- 15
// Add a year to John's age.
person1.HasABirthday()

// Display results.
System.Console.WriteLine(person1.ToString())
System.Console.WriteLine(person2.ToString())
// Is Mary old enough to vote?
System.Console.WriteLine(person2.IsOfAge(18))

Wyświetlane są następujące wiersze.

Name: John

Age: 44

Name: Mary

Age: 15

False

Aby wyświetlić inne przykłady z samouczka języka F#

W menu Plik, wskaż Nowy i kliknij przycisk Projekt.
Jeśli nie widzisz Visual F# w okienku Kategorie szablonów, kliknij Inne języki, a następnie kliknij przycisk Visual F#.W okienku Szablony na środku wyświetlana jest lista szablonów języka F#.
Zobacz na górną część okienka Szablony, aby upewnić się, że .NET Framework 4 pojawia się w polu Platforma docelowa.
Kliknij Samouczek języka F# na liście szablonów.
Kliknij OK.
Samouczek pojawi się w Eksploratorze rozwiązań.

Następne kroki

Aby uzyskać więcej informacji na temat programowania funkcyjnego i dodatkowych przykładów, zobacz Funkcje jako wartości pierwszej klasy (F#).Aby uzyskać więcej informacji na temat krotek, list, wyrażeń let, definicji funkcji, klas, członków i wielu innych tematów, zobacz Materiały referencyjne dotyczące języka F#.

Zobacz też

Koncepcje

Funkcje jako wartości pierwszej klasy (F#)

Inne zasoby

Visual F#

Materiały referencyjne dotyczące języka F#

Udostępnij za pośrednictwem