Literály

Tento článek obsahuje tabulku, která ukazuje, jak zadat typ literálu v jazyce F#.

Typy literálů

Následující tabulka ukazuje typy literálů v jazyce F#. Znaky, které představují číslice v šestnáctkovém zápisu, nerozlišují malá a velká písmena; znaky, které identifikují typ, rozlišují malá a velká písmena.

Typ	Popis	Přípona nebo předpona	Příklady
sbyte	Podepsané 8bitové celé číslo	y	86y 0b00000101y
byte	8bitové přirozené číslo bez znaménka	uy	86uy 0b00000101uy
int16	Podepsané 16bitové celé číslo	s	86s
uint16	16bitové přirozené číslo bez znaménka	nás	86us
Int int32	Podepsané 32bitové celé číslo	l nebo žádný	86 86l
uint uint32	32bitové přirozené číslo bez znaménka	u nebo ul	86u 86ul
nativeint	nativní ukazatel na celé číslo se znaménkem	n	123n
unativeint	nativní ukazatel jako přirozené číslo bez znaménka	OSN	0x00002D3Fun
int64	Podepsané 64bitové celé číslo	L	86L
uint64	64bitové přirozené číslo bez znaménka	UL	86UL
single, float32	32bitový číslo s plovoucí desetinnou čárkou	F nebo f	4.14Fnebo 4.14f nebo 2.3e+32f2.3e-32f nebo nebo infinityf-infinityf
		Lf	0x00000000lf
plout; dvojitý	64bitové číslo s pohyblivou desetinnou čárkou	žádný	4.14nebo 2.3E+32 nebo 2.3e+322.3e-32 nebo nebo infinity-infinity
		LF	0x0000000000000000LF
bigint	celé číslo není omezeno na 64bitovou reprezentaci	I	9999999999999999999999999999I
desítkové číslo	Zlomkové číslo reprezentované jako pevné nebo racionální číslo	M nebo m	0.7833M nebo 0.7833m
Uklízečka	Znak Unicode	žádný	'a' nebo '\u0061'
Řetězec	Řetězec Unicode	žádný	"text\n" nebo @"c:\filename" nebo """<book title="Paradise Lost">""" nebo "string1" + "string2" Viz také řetězce.
byte	Znak ASCII	B	'a'B
byte[]	Řetězec ASCII	B	"text"B
Řetězec nebo bajt[]	doslovný řetězec	Předpona @	@"\\server\share" (Unicode) @"\\server\share"B (ASCII)

Pojmenované literály

Hodnoty, které mají být konstanty, lze označit atributem Literál.

Tento atribut má vliv na to, že se hodnota zkompiluje jako konstanta. V následujícím příkladu jsou neměnné yx hodnoty, ale x vyhodnocují se za běhu, zatímco y je to konstanta kompilační doby.

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

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

Poznámka

Funkce nelze použít k výpočtu hodnot [<Literal>], protože literály musí být určeny v době kompilace a nemohou záviset na vyhodnocení za běhu.

Proč funkce nemohou vypočítat literály

Atribut [<Literal>] vyžaduje, aby hodnoty byly známé v době kompilace. Funkce, i když se zdá, že vytvářejí konstantní výstupy, se vyhodnocují za běhu, což je nevhodné pro [<Literal>]. Toto omezení zajišťuje bezpečné použití literálů ve scénářích, jako jsou porovnávání vzorů, argumenty atributů a interoperabilita s externími funkcemi.

Například pokus o přiřazení výsledku funkce k literálu selže:

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

Tento rozdíl je také důležitý při volání externí funkce . Například DllImport je atribut, který potřebuje znát hodnotu myDLL během kompilace. Bez deklarace [<Literal>] by se tento kód nepodařilo zkompilovat:

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

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

Ve vzorových shodných výrazech se identifikátory začínající malými písmeny vždy považují za proměnné, které se mají vázat, a ne jako literály, takže při definování literálů byste měli obecně používat počáteční velká písmena.

[<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říklad stručného porovnávání vzorů pomocí pojmenovaných literálů

Pojmenované literály můžou usnadnit porovnávání vzorů tím, že se vyhnete nutnosti when klauzulí nebo další logiky. Například:

[<Literal>]
let ErrorCode = 404

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

Poznámky

Pojmenované literály jsou užitečné pro:

• Porovnávání vzorů bez klauzule when
• Argumenty atributů
• Argumenty zprostředkovatele statického typu

Řetězce Unicode můžou obsahovat explicitní kódování, které můžete zadat pomocí \u následovaného 16bitovým šestnáctkovým kódem (0000 – FFFF) nebo kódováníM UTF-32, které můžete zadat pomocí \U následovaného 32bitovým šestnáctkovým kódem, který představuje jakýkoli bod kódu Unicode (00000000 – 0010FFFF).

Použití bitového operátoru jiného než ||| není povoleno.

Celá čísla v jiných základových soustavách

32bitové celá čísla se dají zadat také v šestnáctkovém, osmičkovém nebo binárním souboru pomocí 0x, 0o nebo 0b předpony.

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

Podtržítka v číselných literálech

Číslice můžete oddělit podtržítkem (_).

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Speciální hodnoty nekonečna s pohyblivou řádovou čárkou

Číselné typy float i single s plovoucí čárkou mají přidružené speciální hodnoty představující kladné a záporné nekonečno.

Hodnota F#	Typ F#	Odpovídající hodnota .NET
infinity nebo +infinity	float	PositiveInfinity
-infinity	float	NegativeInfinity
infinityf nebo +infinityf	single	PositiveInfinity
-infinityf	single	NegativeInfinity

Tyto hodnoty lze použít přímo, nebo jsou výsledkem při dělení plovoucí desetinnou nulou nebo číslem tak malým, že ho daný typ nemůže reprezentovat. Například:

> 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