Názorný postup: První F# programu

Článek
03/04/2013

Ve vývojovém prostředí Visual Studio 2010 je obsažen nový programovací jazyk, F#.F# je multiparadigmatický jazyk, u kterého je k tradičnímu objektově orientovanému programování a konceptům technologie .NET přidáno funkcionální programování.Následující příklady představují některé jeho funkce a syntaxi.Příklady ukazují, jak deklarovat jednoduché proměnné, zapisovat a testovat funkce, jak vytvářet n-tice a seznamy a jak definovat a používat třídy.

[!POZNÁMKA]

Ve vašem počítači se pro některé z prvků uživatelského rozhraní sady Visual Studio mohou zobrazit jiné názvy a umístění, než jsou uvedeny v následujících pokynech. Tyto prvky jsou určeny verzí aplikace Visual Studio a použitým nastavením. Další informace naleznete v tématu Nastavení aplikace Visual Studio.

Vytvořte novou konzolovou aplikaci

V nabídce File (Soubor) přejděte na příkaz New (Nový) a klepněte na příkaz Project (Projekt).
Pokud se v panelu Kategorie šablon jazyk Visual F# nenachází, klikněte na uzel Jiné jazyky a poté klikněte na Visual F#.Podokno Šablony uprostřed zobrazuje seznam šablon jazyka F#.
Podívejte se na horní část podokna Šablony a ujistěte se, že je v poli Cílové rozhraní vybrána možnost .NET Framework 4.
V seznamu šablon klikněte na možnost Aplikace F#.
Do pole Název zadejte název projektu.
Klikněte na tlačítko OK.

V podokně Řešení - průzkumník se zobrazí nový projekt.

Použití klíčového slova let při deklaraci a používání identifikátorů

Následující kód zkopírujte a vložte do souboru Program.fs.Každý identifikátor, anInt, aString, a anIntSquared, je svázán s hodnotou.
```
let anInt = 5
let aString = "Hello"
// Perform a simple calculation and bind anIntSquared to the result.
let anIntSquared = anInt * anInt
```
[!POZNÁMKA]

Pokud nelze kód v klasickém zobrazení zobrazit, zkontrolujte, zda je Filtr jazyka v záhlaví pod názvem tématu nastaven pro zahrnutí jazyka F#.

Zobrazení výsledků v interaktivním okně jazyka F#

V předchozí proceduře vyberte výrazy let.
Na vybranou oblast klikněte pravým tlačítkem a poté klikněte na Odeslat do interaktivního okna.Případně stiskněte klávesy ALT+ENTER.
Zobrazí se okno F# Interactive a jsou zobrazeny výsledky interpretace výrazů let, jak ukazují následující řádky.Typy jsou odvozeny ze zadaných hodnot.

val anInt : int = 5

val aString : string = "Hello"

val anIntSquared : int = 25

Zobrazení výsledků v okně příkazového řádku

Do souboru Program.fs přidejte následující řádky.

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

Pro spuštění kódu stiskněte klávesy CTRL+F5.Zobrazí se okno příkazového řádku obsahující následující hodnoty.

5

Hello

25

Ponecháním ukazatele myši na názvech identifikátorů anInt, aString a anIntSquared v předchozích příkazech WriteLine můžete ověřit odvozené typy.

Definování a spuštění funkce

Pro definování funkce mocniny použijte výraz let, tak jak je znázorněno v následujícím kódu.Funkce má jeden parametr n a vrací umocněný argument předaný 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)

Pro spuštění kódu stiskněte klávesy CTRL+F5.Zobrazený výsledek je 25.
Rekurzivní funkce vyžaduje výraz let rec.Následující příklad definuje funkci, která vypočítá faktoriál parametru n.
```
let rec factorial n = 
    if n = 0 
    then 1 
    else n * factorial (n - 1)
System.Console.WriteLine(factorial anInt)
```
Pro spuštění funkce stiskněte CTRL+F5.Zobrazený výsledek je 120, faktoriál čísla 5.

Tvorba kolekcí: seznamy a n-tice

Jednou z možností, jak sloučit několik hodnot, je použití n-tice, tak, jak je to zobrazeno v následujícím kódu.

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

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

Dalším způsobem sloučení hodnot je použití seznamu, tak jak je znázorněno v následujícím kódu.
```
// List of best friends.
let bffs = [ "Susan"; "Kerry"; "Linda"; "Maria" ] 
```
Pomocí operátoru "cons" (::) je do seznamu přidán nový nejlepší přítel.Všimněte si, že operace nezmění hodnotu bffs.Hodnota bffs je neměnná a nelze ji změnit.
```
// Bind newBffs to a new list that has "Katie" as its first element.
let newBffs = "Katie" :: bffs
```
Pro zobrazení seznamů použijte funkci printfn.Funkce printfn zobrazí jednotlivé prvky, obsažené ve strukturovaných hodnotách.
```
printfn "%A" bffs
// Output: ["Susan"; "Kerry"; "Linda"; "Maria"]
printfn "%A" newBffs
// Output: ["Katie"; "Susan"; "Kerry"; "Linda"; "Maria"]
```
Výsledky můžete zobrazit stisknutím kombinace kláves CTRL+F5 nebo výběrem části kódu a stisknutím kláves ALT+ENTER.

Vytvoření a použití třídy

Následující kód vytvoří třídu Person, která má dvě vlastnosti, Name a Age.Vlastnost Name je určena jen pro čtení.Její hodnota je neměnná, jako u většiny hodnot ve funkcionálním programování.Pokud je třeba, je v jazyce F# možné vytvořit měnitelné hodnoty, ale musí být explicitně definovány jako měnitelné.V následující definici třídy je hodnota Age uložena v měnitelné místní proměnné internalAge.Hodnotu proměnné internalAge lze změnit.

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

Pro testování třídy deklarujte dva objekty Person, proveďte změny a zobrazte výsledky, tak jak je znázorněno v následujícím kódu.

// 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))

Zobrazí se následující řádky.

Name: John

Age: 44

Name: Mary

Age: 15

False

Zobrazení dalších příkladů kurzu jazyka F#

V nabídce File (Soubor) přejděte na příkaz New (Nový) a klepněte na příkaz Project (Projekt).
Pokud se v panelu Kategorie šablon jazyk Visual F# nenachází, klikněte na uzel Jiné jazyky a poté klikněte na Visual F#.Podokno Šablony uprostřed zobrazuje seznam šablon jazyka F#.
Podívejte se na horní část podokna Šablony a ujistěte se, že je v poli Cílové rozhraní vybrána možnost .NET Framework 4.
V seznamu šablon klikněte na Výukový kurz F#.
Klikněte na tlačítko OK.
Kurz se zobrazí v podokně Řešení - průzkumník.

Další kroky

Další informace o funkcionálním programování spolu s dalšími příklady naleznete v tématu Funkce jako prvotřídní hodnoty (F#).Další informace o n-ticích, seznamech, výrazech let, definicích funkcí, tříd, členů a mnoho dalších témat naleznete v tématu F# Language Reference.

Viz také

Koncepty

Funkce jako prvotřídní hodnoty (F#)

Další zdroje

Visual F#

F# Language Reference

Share via