Záznamy (F#)

Článek
02/28/2013

Záznamy představují jednoduché agregáty pojmenované hodnoty volitelně s členy.

[ attributes ]
type [accessibility-modifier] typename = { 
    [ mutable ] label1 : type1;
    [ mutable ] label2 : type2;
    ...
    }
    member-list

Poznámky

V syntaxi předchozí typename je název záznam typu label1 a label2 jsou názvy hodnot uvedených jako popisky, a type1 a type2 typy těchto hodnot.member-listje volitelný seznam členů typu.

Následuje několik příkladů.

type Point = { x : float; y: float; z: float; }
type Customer = { First : string; Last: string; SSN: uint32; AccountNumber : uint32; }

Při každém štítku je na samostatném řádku, středník, je nepovinné.

Můžete nastavit hodnoty ve výrazech, které jsou známé jako výrazy záznam.Kompilátor odvodí typ z návěsky (pokud jsou dostatečně odlišné od jiných typů záznamů štítky).Složené závorky ({}), uzavřete výraz záznamu.Následující kód ukazuje záznam výraz, který inicializuje záznam s plovoucí prvky s popisky x, y a z.

let mypoint = { x = 1.0; y = 1.0; z = -1.0; }

Pokud může být jiný typ, který má stejné popisky také nepoužívejte zkráceném tvaru.

type Point = { x : float; y: float; z: float; }
type Point3D = { x: float; y: float; z: float }
// Ambiguity: Point or Point3D?
let mypoint3D = { x = 1.0; y = 1.0; z = 0.0; }

Popisky nedávno deklarovaný typ přednost ty dříve deklarovaný typ v předchozím příkladu tak mypoint3D je odvodit se Point3D.Můžete explicitně určit typ záznamu, jako v následujícím kódu.

let myPoint1 = { Point.x = 1.0; y = 1.0; z = 0.0; }

Pro typy záznamů pouze pro typy tříd definovat metody.

Vytváření záznamů pomocí výrazů záznamu

Záznamy můžete inicializovat pomocí popisků, které jsou definovány v záznamu.Tento výraz je označována jako záznam výraz.Uzavřete výraz záznamu a použít středník jako oddělovač použijte závorky.

Následující příklad ukazuje, jak vytvořit záznam.

type MyRecord = {
    X: int;
    Y: int;
    Z: int 
    }

let myRecord1 = { X = 1; Y = 2; Z = 3; }

Středníky po poslední pole v záznamu výrazu a definice typu jsou volitelné, bez ohledu na to, zda jsou pole vše v jednom řádku.

Při vytváření záznamu, je nutné zadat hodnoty pro každé pole.Nelze odkazovat na hodnoty ostatních polí ve výrazu inicializace pro libovolné pole.

Následující kód typu myRecord2 je odvodit ze názvy polí.Volitelně můžete zadat název typu explicitně.

let myRecord2 = { MyRecord.X = 1; MyRecord.Y = 2; MyRecord.Z = 3 }

Jiný formulář záznam konstrukce může být užitečné, když musíte zkopírovat existující záznam a případně změnit některé hodnoty pole.Následující kód ilustruje to.

let myRecord3 = { myRecord2 with Y = 100; Z = 2 }

Tento formulář výraz záznam se nazývá zkopírovat a aktualizovat záznam výraz.

Záznamy jsou neměnné ve výchozím nastavení. změněné záznamy však můžete snadno vytvořit pomocí výrazu kopii a aktualizace.Můžete také explicitně zadat proměnlivých polí.

type Car = {
    Make : string
    Model : string
    mutable Odometer : int
    }
let myCar = { Make = "Fabrikam"; Model = "Coupe"; Odometer = 108112 }
myCar.Odometer <- myCar.Odometer + 21

Nepoužívejte atribut DefaultValue pole záznamu.Lepším řešením je výchozí instance záznamy s poli, které jsou inicializovány definovat výchozí hodnoty použít kopii a aktualizovat záznam výraz pole, které se liší od výchozí hodnoty nastavení.

// Rather than use [<DefaultValue>], define a default record.
type MyRecord =
    { 
        field1 : int 
        field2 : int
    }

let defaultRecord1 = { field1 = 0; field2 = 0 }
let defaultRecord2 = { field1 = 1; field2 = 25 }

// Use the with keyword to populate only a few chosen fields
// and leave the rest with default values.
let rr3 = { defaultRecord1 with field2 = 42 }

Porovnávání se záznamy

Záznamy lze použít odpovídající vzorek.Můžete určit některá pole explicitně a stanovit další pole, která bude přiřazena při shoda proměnné.Následující příklad kódu ukazuje to.

type Point3D = { x: float; y: float; z: float }
let evaluatePoint (point: Point3D) =
    match point with
    | { x = 0.0; y = 0.0; z = 0.0 } -> printfn "Point is at the origin."
    | { x = xVal; y = 0.0; z = 0.0 } -> printfn "Point is on the x-axis. Value is %f." xVal
    | { x = 0.0; y = yVal; z = 0.0 } -> printfn "Point is on the y-axis. Value is %f." yVal
    | { x = 0.0; y = 0.0; z = zVal } -> printfn "Point is on the z-axis. Value is %f." zVal
    | { x = xVal; y = yVal; z = zVal } -> printfn "Point is at (%f, %f, %f)." xVal yVal zVal

evaluatePoint { x = 0.0; y = 0.0; z = 0.0 }
evaluatePoint { x = 100.0; y = 0.0; z = 0.0 }
evaluatePoint { x = 10.0; y = 0.0; z = -1.0 }

Výstup tohoto kódu je následující.

Point is at the origin.
Point is on the x-axis. Value is 100.000000.
Point is at (10.000000, 0.000000, -1.000000).

Rozdíly mezi záznamy a třídy

Pole záznamu se liší od třídy, jsou automaticky vystavena jako vlastnosti a jsou použité při vytváření a kopírování záznamů.Záznamu konstrukce se liší od třídy konstrukce.V záznamu typu nelze definovat konstruktor.Místo toho se použije syntaxe konstrukce popsané v tomto tématu.Třídy nemají žádný přímý vztah mezi parametry konstruktoru, pole a vlastnosti.

Podobně jako unie struktury a typy záznamů mají strukturální rovnosti sémantiku.Třídy mít odkaz sémantiku rovnosti.Následující příklad kódu to ukazuje.

type RecordTest = { X: int; Y: int }
let record1 = { X = 1; Y = 2 }
let record2 = { X = 1; Y = 2 }
if (record1 = record2) then
    printfn "The records are equal."
else
    printfn "The records are unequal."

Zápisu stejný kód s třídami dvě třídy objektů by nerovné, protože by dvě hodnoty představují dva objekty na haldy a pouze adresy by ve srovnání (Pokud je typ třídy potlačí System.Object.Equals metoda).