Literály

Článek
01/31/2025

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`
bajt	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.14F` nebo `4.14f` nebo `infinityf` nebo `-infinityf`
		Lf	`0x00000000lf`
plout; dvojitý	64bitové číslo s pohyblivou desetinnou čárkou	žádný	`4.14` nebo `2.3E+32` nebo `2.3e+32` nebo `infinity` nebo `-infinity`
		LF	`0x0000000000000000LF`
bigint	celé číslo není omezeno na 64bitovou reprezentaci	Já	`9999999999999999999999999999I`
desetinné čí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.
bajt	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 x i y níže neměnné hodnoty, ale x se vyhodnocuje za běhu, zatímco y je konstanta kompilace.

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

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

Sdílet prostřednictvím