Literały

Artykuł
05/29/2024

W tym artykule przedstawiono tabelę przedstawiającą sposób określania typu literału w języku F#.

Typy literałów

W poniższej tabeli przedstawiono typy literałów w języku F#. Znaki reprezentujące cyfry w notacji szesnastkowej nie są uwzględniane wielkości liter; znaki identyfikujące typ są uwzględniane wielkości liter.

Type	Opis	Sufiks lub prefiks	Przykłady
sbyte	podpisana 8-bitowa liczba całkowita	t	`86y` `0b00000101y`
byte	niepodpisany 8-bitowy numer naturalny	Uy	`86uy` `0b00000101uy`
int16	podpisana 16-bitowa liczba całkowita	s	`86s`
uint16	niepodpisany 16-bitowy numer naturalny	us	`86us`
int int32	ze znakiem 32-bitowej liczby całkowitej	l lub brak	`86` `86l`
uint uint32	niepodpisany 32-bitowy numer naturalny	u lub ul	`86u` `86ul`
nativeint	natywny wskaźnik do podpisanego numeru naturalnego	n	`123n`
unativeint	natywny wskaźnik jako niepodpisany numer naturalny	un	`0x00002D3Fun`
int64	podpisana 64-bitowa liczba całkowita	L	`86L`
uint64	niepodpisany 64-bitowy numer naturalny	UL	`86UL`
single, float32	32-bitowa liczba zmiennoprzecinkowa	F lub f	`4.14F`lub lub `4.14finfinityf-infinityf`
		Lf	`0x00000000lf`
Float; Podwójne	64-bitowa liczba zmiennoprzecinkowa	Brak	`4.14`lub `2.3E+32` lub lub `infinity2.3e+32-infinity`
		LF	`0x0000000000000000LF`
bigint	Liczba całkowita nie ogranicza się do reprezentacji 64-bitowej	I	`9999999999999999999999999999I`
decimal	liczba ułamkowa reprezentowana jako stały punkt lub liczba racjonalna	M lub m	`0.7833M` lub `0.7833m`
Char	znak Unicode	Brak	`'a'` lub `'\u0061'`
String	Ciąg Unicode	Brak	`"text\n"` lub `@"c:\filename"` lub `"""<book title="Paradise Lost">"""` lub `"string1" + "string2"` Zobacz też Ciągi.
byte	Znak ASCII	B	`'a'B`
byte[]	Ciąg ASCII	B	`"text"B`
Ciąg lub bajt[]	ciąg dosłowny	prefiks @	`@"\\server\share"` (Unicode) `@"\\server\share"B` (ASCII)

Nazwane literały

Wartości, które mają być stałymi, można oznaczyć atrybutem Literał .

Ten atrybut ma wpływ na przyczynę kompilowania wartości jako stałej. W poniższym przykładzie oba x i y poniższe są niezmienne wartości, ale x są oceniane w czasie wykonywania, natomiast y jest stałą czasu kompilacji.

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

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

Na przykład to rozróżnienie ma znaczenie podczas wywoływania funkcji zewnętrznej, ponieważ DllImport jest to atrybut, który musi znać wartość myDLL podczas kompilacji. Bez deklaracji [<Literal>] ten kod nie może skompilować:

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

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

W wyrażeniach dopasowywania wzorców identyfikatory rozpoczynające się od małych liter są zawsze traktowane jako zmienne, które mają być powiązane, a nie jako literały, dlatego podczas definiowania literałów należy zazwyczaj używać początkowych liter.

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

Uwagi

Nazwane literały są przydatne w następujących celach:

Dopasowywanie wzorca bez klauzuli when .
Argumenty atrybutów.
Argumenty dostawcy typu statycznego.

Ciągi Unicode mogą zawierać jawne kodowanie, które można określić przy użyciu \u 16-bitowego kodu szesnastkowego (0000 – FFFF) lub kodowań UTF-32, które można określić za pomocą \U 32-bitowego kodu szesnastkowego reprezentującego dowolny punkt kodu Unicode (000000000– 0010FFFF).

Użycie operatorów bitowych innych niż ||| jest niedozwolone.

Liczby całkowite w innych bazach

Podpisane 32-bitowe liczby całkowite można również określić w szesnastkowym, ósemkowym lub binarnym, odpowiednio przy użyciu prefiksu 0x0o lub 0b .

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

Podkreślenia w literałach liczbowych

Cyfry można oddzielić znakiem podkreślenia (_).

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Specjalne wartości nieskończoności zmiennoprzecinkowych

float Oba typy liczbowe i single zmiennoprzecinkowe mają skojarzone specjalne wartości reprezentujące nieskończoność dodatnią i ujemną.

Wartość języka F#	Typ języka F#	Odpowiadająca wartość platformy .NET
`infinity` lub `+infinity`	`float`	PositiveInfinity
`-infinity`	`float`	NegativeInfinity
`infinityf` lub `+infinityf`	`single`	PositiveInfinity
`-infinityf`	`single`	NegativeInfinity

Te wartości mogą być używane bezpośrednio lub są zwracane podczas dzielenia przez zero zmiennoprzecinkowe lub liczbę zbyt małą, aby być reprezentowane przez dany typ. Na przykład:

> 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

Udostępnij za pośrednictwem