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.

Típus	Leírás	Utótag vagy előtag	Példák
sbyte	aláírt 8 bites egész szám	y	86y 0b00000101y
bájt	aláíratlan 8 bites természetes szám	uy	86uy 0b00000101uy
int16	aláírt 16 bites egész szám	s	86s
uint16	aláíratlan 16 bites természetes szám	minket	86us
Int int32	aláírt 32 bites egész szám	l vagy nincs	86 86l
uint uint32	aláíratlan 32 bites természetes szám	u vagy ul	86u 86ul
natívint	natív mutató egy aláírt természetes számra	n	123n
unativeint	natív mutató aláíratlan természetes számként	ENSZ	0x00002D3Fun
int64	aláírt 64 bites egész szám	L	86L
uint64	aláíratlan 64 bites természetes szám	UL	86UL
egyszeres, float32	32 bites lebegőpontos szám	F vagy f	4.14Fvagy 4.14f vagy 2.3e+32f2.3e-32f vagy infinityf-infinityf
		Lf	0x00000000lf
lebegőpontos; duplapontos	64 bites lebegőpontos szám	egyik sem	4.14vagy 2.3E+32 vagy 2.3e+322.3e-32 vagy infinity-infinity
		LF	0x0000000000000000LF
bigint	egész szám, amely nem korlátozódik a 64 bites ábrázolásra	I	9999999999999999999999999999I
decimális	törtszám rögzített pontként vagy racionális számként	M vagy m	0.7833M vagy 0.7833m
Karakter	Unicode-karakter	egyik sem	'a' vagy '\u0061'
Karakterlánc	Unicode-sztring	egyik sem	"text\n" vagy @"c:\filename" vagy """<book title="Paradise Lost">""" vagy "string1" + "string2" Lásd még stringek.
bájt	ASCII-karakter	B	'a'B
byte[]	ASCII-sztring	B	"text"B
Sztring vagy bájt[]	verbatim karakterlánc	@ előtag	@"\\server\share" (Unicode) @"\\server\share"B (ASCII)

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 mind xy az alábbi értékek nem módosíthatók, de x futásidőben vannak kiértékelve, míg y a fordítási idő állandója.

let x = "a" + "b" // evaluated at runtime

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

Jegyzet

A függvények nem használhatók [<Literal>] értékek kiszámítására, mert a konstansokat fordítási időpontban kell meghatározni, és nem függhetnek a futtatókörnyezet kiértékelésétől.

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.

F# érték	F# típus	Megfelelő .NET-érték
infinity vagy +infinity	float	PositiveInfinity
-infinity	float	NegativeInfinity
infinityf vagy +infinityf	single	PositiveInfinity
-infinityf	single	NegativeInfinity

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