Literaler

Artikel
05/29/2024

Den här artikeln innehåller en tabell som visar hur du anger typen av en literal i F#.

Literaltyper

I följande tabell visas literaltyperna i F#. Tecken som representerar siffror i hexadecimal notation är inte skiftlägeskänsliga. tecken som identifierar typen är skiftlägeskänsliga.

Typ	Beskrivning	Suffix eller prefix	Exempel
sbyte	signerat 8-bitars heltal	y	`86y` `0b00000101y`
byte	osignerat 8-bitars naturligt tal	Uy	`86uy` `0b00000101uy`
int16	signerat 16-bitars heltal	s	`86s`
uint16	osignerat 16-bitars naturligt tal	us	`86us`
heltal int32	signerat 32-bitars heltal	l eller ingen	`86` `86l`
uint uint32	osignerat 32-bitars naturligt tal	u eller ul	`86u` `86ul`
nativeint	inbyggt pekare till ett signerat naturligt tal	n	`123n`
unativeint	inbyggt pekare som ett osignerat naturligt tal	un	`0x00002D3Fun`
int64	signerat 64-bitars heltal	L	`86L`
uint64	osignerat 64-bitars naturligt tal	UL	`86UL`
single, float32	32-bitars flyttalsnummer	F eller f	`4.14F`eller `4.14f` eller `infinityf-infinityf`
		Lf	`0x00000000lf`
Flyta; Dubbel	64-bitars flyttalsnummer	inget	`4.14`eller `2.3E+32` eller `2.3e+32` eller `infinity-infinity`
		LF	`0x0000000000000000LF`
bigint	heltal som inte är begränsat till 64-bitars representation	I	`9999999999999999999999999999I`
decimal	bråktal som representeras som en fast punkt eller ett rationellt tal	M eller m	`0.7833M` eller `0.7833m`
Char	Unicode-tecken	inget	`'a'` eller `'\u0061'`
String	Unicode-sträng	inget	`"text\n"` eller `@"c:\filename"` eller `"""<book title="Paradise Lost">"""` eller `"string1" + "string2"` Se även Strängar.
byte	ASCII-tecken	F	`'a'B`
byte[]	ASCII-sträng	F	`"text"B`
Sträng eller byte[]	ordagrann sträng	@ prefix	`@"\\server\share"` (Unicode) `@"\\server\share"B` (ASCII)

Namngivna literaler

Värden som är avsedda att vara konstanter kan markeras med attributet Literal .

Det här attributet leder till att ett värde kompileras som en konstant. I följande exempel är både x och y nedan oföränderliga värden, men x utvärderas vid körning, medan y är en kompileringskonstant.

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

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

Den här skillnaden är till exempel viktig när du anropar en extern funktion, eftersom DllImport det är ett attribut som måste känna till värdet för myDLL under kompilering. Utan deklarationen [<Literal>] skulle den här koden inte kompilera:

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

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

I mönstermatchningsuttryck behandlas identifierare som börjar med gemener alltid som variabler som ska bindas, i stället för som literaler, så du bör vanligtvis använda inledande versaler när du definierar literaler.

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

Kommentarer

Namngivna literaler är användbara för:

Mönstermatchning utan en when sats.
Attributargument.
Argument för statisk typprovider.

Unicode-strängar kan innehålla explicita kodningar som du kan ange med hjälp \u av följt av en 16-bitars hexadecimal kod (0000 – FFFF) eller UTF-32-kodningar som du kan ange med hjälp \U av följt av en 32-bitars hexadecimal kod som representerar valfri Unicode-kodpunkt (000000000 - 0010FFFF).

Användning av andra bitoperatorer än ||| tillåts inte.

Heltal i andra baser

Signerade 32-bitars heltal kan också anges i hexadecimalt, oktalt eller binärt med hjälp av ett 0xeller 0o0b prefix.

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

Understreck i numeriska literaler

Du kan separera siffror med understreckstecknet (_).

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Särskilda oändlighetsvärden för flyttalspunkter

Både de numeriska typerna float och single flyttalstyperna har associerade specialvärden som representerar positiv och negativ oändlighet.

F#-värde	F#-typ	Motsvarande .NET-värde
`infinity` eller `+infinity`	`float`	PositiveInfinity
`-infinity`	`float`	NegativeInfinity
`infinityf` eller `+infinityf`	`single`	PositiveInfinity
`-infinityf`	`single`	NegativeInfinity

Dessa värden kan användas direkt eller returneras när de divideras med en flyttal noll eller ett tal som är för litet för att representeras av den angivna typen. Till exempel:

> 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

Dela via