Literálok

Ez a cikk egy táblázatot tartalmaz, amely bemutatja, hogyan adhatja meg a literál típusát az F#-ban.

Literális típusok

Az alábbi táblázat az F#-ban szereplő literális típusokat mutatja be. A hexadecimális jelölés számjegyeit ábrázoló karakterek nem érzékenyek a kis- és nagybetűkre; a típust azonosító karakterek érzékenyek a kis- és nagybetűkre.

Névvel ellátott literálok

Az állandóknak szánt értékek a Literális attribútummal jelölhetők meg.

Ennek az attribútumnak az a hatása, hogy egy érték állandóként lesz lefordítva. Az alábbi példában az alábbi x és y is nem módosítható értékek, de a x futásidőben lesz kiértékelve, míg a y fordítási időállandó.

let x = "a" + "b" // evaluated at run-time

[<Literal>]
let y = "a" + "b" // evaluated at compile-time

Miért nem tudnak függvények literálokat kiszámítani?

A [<Literal>] attribútumnak fordításkor ismernie kell az értékeket. A függvényeket futásidőben értékelik, még akkor is, ha úgy tűnik, hogy állandó kimeneteket hoznak létre, így nem alkalmasak [<Literal>]. Ez a korlátozás biztosítja, hogy a literálok biztonságosan használhatók legyenek olyan helyzetekben, mint a mintaegyeztetés, az attribútumargumentumok és a külső függvényekkel való együttműködés.

Egy függvény eredményének konstanshoz való hozzárendelése például sikertelen lesz:

[<Literal>]
let yFunc() = "a" + "b" // error FS0267: this is not a valid constant expression

Ez a különbség akkor is számít, ha egy külső függvénythív meg. A DllImport például olyan attribútum, amely a fordítás során ismernie kell a myDLL értékét. A [<Literal>] deklaráció nélkül a kód fordítása sikertelen lenne:

[<Literal>]
let myDLL = "foo.dll"

[<DllImport(myDLL, CallingConvention = CallingConvention.Cdecl)>]
extern void HelloWorld()

A mintaegyező kifejezésekben a kisbetűs karakterekkel kezdődő azonosítók mindig a konstansok helyett a kötött változókként lesznek kezelve, ezért a literálok definiálásakor általában kezdőbetűket kell használni.

[<Literal>]
let SomeJson = """{"numbers":[1,2,3,4,5]}"""

[<Literal>]
let Literal1 = "a" + "b"

[<Literal>]
let FileLocation =   __SOURCE_DIRECTORY__ + "/" + __SOURCE_FILE__

[<Literal>]
let Literal2 = 1 ||| 64

[<Literal>]
let Literal3 = System.IO.FileAccess.Read ||| System.IO.FileAccess.Write

Példa az elnevezett literálok használatával való tömör mintaegyezésre

Az elnevezett literálok tömörebbé tehetik a mintaegyezést, ha elkerülik when záradékok vagy további logika szükségességét. Például:

[<Literal>]
let ErrorCode = 404

let handleResponse code =
    match code with
    | ErrorCode -> "Not Found"
    | _ -> "Other Response"

Megjegyzések

A névvel ellátott literálok a következőkhöz hasznosak:

• Mintaegyezés when típusú záradék nélkül.
• Az attribútum argumentumai.
• Statikus típusú szolgáltató argumentumai.

A Unicode-sztringek olyan explicit kódolásokat tartalmazhatnak, amelyeket \u használatával, majd egy 16 bites hexadecimális kóddal (0000 - FFFF) vagy UTF-32 kódolással adhat meg \U használatával, majd egy 32 bites hexadecimális kóddal, amely bármilyen Unicode-kódpontot jelöl (00000000 – 0010FFFF).

A ||| eltérő bitenkénti operátorok használata nem engedélyezett.

Egész számok más alapokban

Az aláírt 32 bites egész számok hexadecimális, oktális vagy bináris értékben is megadhatóak egy 0x, 0o vagy 0b előtag használatával.

let numbers = (0x9F, 0o77, 0b1010)
// Result: numbers : int * int * int = (159, 63, 10)

Aláhúzásjelek numerikus literálokban

Az aláhúzásjeljellel (_) elválaszthatja a számjegyeket.

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Speciális lebegőpontos végtelenértékek

Mind a float, mind a single lebegőpontos numerikus típusok speciális értékekkel rendelkeznek, amelyek pozitív és negatív végtelenséget jelképeznek.

Ezek az értékek közvetlenül használhatók, vagy visszatérnek, amikor lebegőpontos nullával vagy túl kicsi számmal osztunk el, amelyet az adott típus nem tud megjeleníteni. Például:

> 1.0/0.0;;
val it: float = infinity

> 1.0/(-0.0);;
val it: float = -infinity

> 1.0/0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
;;
val it: float = infinity