Literale

Artikel
02/04/2025

Dieser Artikel enthält eine Tabelle, in der gezeigt wird, wie der Typ eines Literals in F# angegeben wird.

Literaltypen

In der folgenden Tabelle werden die Literaltypen in F# angegeben. Bei Zeichen, die Ziffern in Hexadezimalschreibweise darstellen, wird die Groß-/Kleinschreibung nicht beachtet. Bei Zeichen, die den Typ angeben, wird die Groß-/Kleinschreibung beachtet.

Typ	Beschreibung	Suffix oder Präfix	Beispiele
sbyte	ganze 8-Bit-Zahl mit Vorzeichen	j	`86y` `0b00000101y`
byte	Nicht signierte 8-Bit-natürliche Zahl	uy	`86uy` `0b00000101uy`
int16	ganze 16-Bit-Zahl mit Vorzeichen	s	`86s`
uint16	Nicht signierte 16-Bit-natürliche Zahl	USA	`86us`
INT int32	ganze 32-Bit-Zahl mit Vorzeichen	l oder keine	`86` `86l`
uint uint32	Nicht signierte natürliche 32-Bit-Zahl	u oder ul	`86u` `86ul`
nativeint	nativer Zeiger auf eine natürliche Zahl mit Vorzeichen	n	`123n`
unativeint	nativer Zeiger als nicht signierte natürliche Zahl	un	`0x00002D3Fun`
int64	ganze 64-Bit-Zahl mit Vorzeichen	L	`86L`
uint64	Nicht signierte natürliche 64-Bit-Zahl	UL	`86UL`
single, float32	32-Bit-Gleitkommazahl	F oder f	`4.14F` oder `4.14f` oder `infinityf` oder `-infinityf`
		lf	`0x00000000lf`
float; double	64-Bit-Gleitkommazahl	nichts	`4.14` oder `2.3E+32` oder `2.3e+32` oder `infinity` oder `-infinity`
		LF	`0x0000000000000000LF`
BIGINT	ganze Zahl, die nicht auf 64-Bit-Darstellung beschränkt ist	Ich	`9999999999999999999999999999I`
Decimal	Bruchzahl, die als fester Punkt oder rationale Zahl dargestellt wird	M oder m	`0.7833M` oder `0.7833m`
Char	Unicode-Zeichen	nichts	`'a'` oder `'\u0061'`
Schnur	Unicode-Zeichenfolge	nichts	`"text\n"` oder `@"c:\filename"` oder `"""<book title="Paradise Lost">"""` oder `"string1" + "string2"` Siehe auch Zeichenfolgen.
byte	ASCII-Zeichen	B	`'a'B`
byte[]	ASCII-Zeichenfolge	B	`"text"B`
String oder byte[]	wörtliche Zeichenfolge	@-Präfix	`@"\\server\share"` (Unicode) `@"\\server\share"B` (ASCII)

Benannte Literale

Werte, die Konstanten sein sollen, können mit dem attribut Literal gekennzeichnet werden.

Dieses Attribut hat die Auswirkung, dass ein Wert als Konstante kompiliert wird. Im folgenden Beispiel sind sowohl x als auch y unten unveränderliche Werte, während x zur Laufzeit ausgewertet werden, während y eine Kompilierungszeitkonstante ist.

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

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

Anmerkung

Funktionen können nicht zur Berechnung von [<Literal>]-Werten verwendet werden, da Literale zur Kompilierungszeit festgelegt werden müssen und nicht von der Laufzeitauswertung abhängen können.

Warum Funktionen keine Literale berechnen können

Für das attribut [<Literal>] müssen Werte zur Kompilierungszeit bekannt sein. Funktionen, auch wenn sie scheinbar konstante Ausgaben erzeugen, werden zur Laufzeit ausgewertet, wodurch sie für [<Literal>]ungeeignet sind. Diese Einschränkung stellt sicher, dass Literale in Szenarien wie Musterabgleich, Attributargumenten und Interoperabilität mit externen Funktionen sicher verwendet werden können.

Wenn Sie beispielsweise versuchen, das Ergebnis einer Funktion einem Literal zuzuweisen, schlägt folgendes fehl:

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

Diese Unterscheidung ist auch beim Aufrufen einer externen Funktionwichtig. Beispielsweise ist DllImport ein Attribut, das den Wert von myDLL während der Kompilierung kennen muss. Ohne die [<Literal>]-Deklaration kann dieser Code nicht kompiliert werden:

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

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

Bei Musterabgleichsausdrücken werden Bezeichner, die mit Kleinbuchstaben beginnen, immer als zu bindende Variablen und nicht als Literale behandelt, daher sollten Sie beim Definieren von Literalen in der Regel Anfangsbuchstaben verwenden.

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

Beispiel für einen präzisen Musterabgleich mit benannten Literalen

Benannte Literale können den Musterabgleich präziser gestalten, da keine when-Klauseln oder zusätzliche Logik notwendig sind. Zum Beispiel:

[<Literal>]
let ErrorCode = 404

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

Bemerkungen

Benannte Literale sind nützlich für:

Musterabgleich ohne when-Klausel.
Attributargumente.
Statische Typanbieterargumente.

Unicode-Zeichenfolgen können explizite Codierungen enthalten, die Sie mithilfe von \u gefolgt von einem 16-Bit-Hexadezimalcode (0000 - FFFF) oder UTF-32-Codierungen angeben können, die Sie mithilfe von \U gefolgt von einem 32-Bit-Hexadezimalcode angeben können, der einen Unicode-Codepunkt darstellt (0000000 - 0010FFFF).

Die Verwendung anderer bitweiser Operatoren als ||| ist nicht zulässig.

Ganze Zahlen in anderen Basen

Signierte 32-Bit-Ganzzahlen können auch mithilfe eines 0x, 0o oder 0b Präfixes in hexadezimal, oktal oder binär angegeben werden.

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

Unterstriche in numerischen Literalen

Sie können Ziffern mit dem Unterstrichzeichen (_) trennen.

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Spezielle Gleitkomma-Unendlichkeitswerte

Sowohl die float als auch single numerischen Gleitkommatypen weisen spezielle Werte auf, die positive und negative Unendlichkeit darstellen.

F#-Wert	F#-Typ	Entsprechender .NET-Wert
`infinity` oder `+infinity`	`float`	PositiveInfinity
`-infinity`	`float`	NegativeInfinity
`infinityf` oder `+infinityf`	`single`	PositiveInfinity
`-infinityf`	`single`	NegativeInfinity

Diese Werte können direkt verwendet werden oder werden bei der Division durch eine Null mit Gleitkomma oder eine Zahl, die zu klein ist, um durch den angegebenen Typ dargestellt zu werden, zurückgegeben. Zum Beispiel:

> 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

Freigeben über