Litteraler

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	signerad 8-bit 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	oss	86us
Int int32	signerat 32-bit heltal	l eller ingen	86 86l
uint uint32	osignerat 32-bitars naturligt tal	u eller ul	86u 86ul
nativeint	** ursprunglig pekare till ett signerat heltal	n	123n
unativeint	inbyggt pekare som ett osignerat naturligt tal	ett	0x00002D3Fun
int64	Signerad 64 bitars heltal	L	86L
uint64	osignerat 64-bitars naturligt tal	UL	86UL
enkel, float32	32-bitars flyttalsnummer	F eller f	4.14F eller 4.14f eller infinityf eller -infinityf
		Lf	0x00000000lf
flyta; dubbel	64-bitars flyttalsnummer	ingen	4.14 eller 2.3E+32 eller 2.3e+32 eller infinity eller -infinity
		LF	0x0000000000000000LF
bigint	heltal som inte är begränsat till 64-bitars representation	Jag	9999999999999999999999999999I
decimal	bråktal som representeras som en fast punkt eller ett rationellt tal	M eller m	0.7833M eller 0.7833m
Röding	Unicode-tecken	ingen	'a' eller '\u0061'
Sträng	Unicode-sträng	ingen	"text\n" eller @"c:\filename" eller """<book title="Paradise Lost">""" eller "string1" + "string2" Se även Strängar.
byte	ASCII-tecken	B	'a'B
byte[]	ASCII-sträng	B	"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

Not

Funktioner kan inte användas för att beräkna [<Literal>] värden eftersom literaler måste fastställas vid kompileringstid och inte kan vara beroende av körningsutvärdering.

Varför funktioner inte kan beräkna literaler

Attributet [<Literal>] kräver att värden är kända vid kompileringstid. Funktioner, även om de verkar generera konstanta utdata, utvärderas vid körning, vilket gör dem olämpliga för [<Literal>]. Den här begränsningen säkerställer att literaler kan användas på ett säkert sätt i scenarier som mönstermatchning, attributargument och interop med externa funktioner.

Ett försök att tilldela resultatet av en funktion till en literal misslyckas till exempel:

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

Den här skillnaden är också viktig när du anropar en extern funktion. Till exempel är DllImport ett attribut som behöver veta värdet för myDLL under kompilering. Utan [<Literal>]-deklarationen 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

Exempel på koncis mönstermatchning med namngivna literaler

Namngivna literaler kan göra mönstermatchningen mer koncis genom att undvika behovet av when-satser eller ytterligare logik. Till exempel:

[<Literal>]
let ErrorCode = 404

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

Anmärkningar

Namngivna literaler är användbara för:

• Mönstermatchning utan en when-sats.
• Attributargument.
• Argument för statiska typprovider.

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

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 0x, 0o eller 0b 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 float och single numeriska flyttalstyper 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