Literály

Článek
05/29/2024

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	us	`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 přirozené číslo se signedm	n	`123n`
unativeint	nativní ukazatel jako přirozené číslo bez znaménka	un	`0x00002D3Fun`
int64	Podepsané 64bitové celé číslo	L	`86L`
uint64	64bitové přirozené číslo bez znaménka	UL	`86UL`
single, float32	32bitové číslo s plovoucí desetinou čárkou	F nebo f	`4.14F`nebo `4.14f` nebo `infinityf-infinityf`
		Lf	`0x00000000lf`
Float; Dvojité	64bitové číslo s plovoucí desetinou čárkou	Žádná	`4.14`nebo `2.3E+32` nebo `2.3e+32` nebo `infinity-infinity`
		LF	`0x0000000000000000LF`
bigint	celé číslo není omezeno na 64bitovou reprezentaci	I	`9999999999999999999999999999I`
decimal	desetinné číslo reprezentované jako pevné nebo logické číslo	M nebo m	`0.7833M` nebo `0.7833m`
Char	znak Unicode	Žádná	`'a'` nebo `'\u0061'`
String	Řetězec Unicode	Žádná	`"text\n"` nebo `@"c:\filename"` nebo `"""<book title="Paradise Lost">"""` nebo `"string1" + "string2"` Viz také řetězce.
byte	Znak ASCII	T	`'a'B`
byte[]	Řetězec ASCII	T	`"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 Literal .

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 kompilace.

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

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

Toto rozlišení například záleží při volání externí funkce, protože DllImport je atribut, který potřebuje znát hodnotu myDLL během kompilace. [<Literal>] Bez deklarace 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

Poznámky

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

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

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

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

Celá čísla v jiných základech

32bitové celá čísla se dají zadat také v šestnáctkovém, osmičkovém nebo binárním souboru pomocí předpony 0x0o 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 plovoucí desetinou čárkou

float Číselné typy s single plovoucí desetinou čá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 vráceny při dělení nulou s plovoucí desetinou čárkou nebo číslem, které je příliš malé, aby bylo reprezentováno daným typem. Pří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