Literale

Artikel
06/04/2024

Dieser Artikel enthält eine Tabelle, die zeigt, wie in F# der Typ eines Literals 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.

type	Beschreibung	Suffix oder Präfix	Beispiele
sbyte	ganze 8-Bit-Zahl mit Vorzeichen	Y	`86y` `0b00000101y`
byte	natürliche 8-Bit-Zahl ohne Vorzeichen	uy	`86uy` `0b00000101uy`
int16	ganze 16-Bit-Zahl mit Vorzeichen	s	`86s`
uint16	natürliche 16-Bit-Zahl ohne Vorzeichen	USA	`86us`
INT int32	ganze 32-Bit-Zahl mit Vorzeichen	I oder keins	`86` `86l`
uint uint32	natürliche 32-Bit-Zahl ohne Vorzeichen	u oder ul	`86u` `86ul`
nativeint	nativer Zeiger auf eine natürliche Zahl mit Vorzeichen	n	`123n`
unativeint	systemeigener Zeiger als natürliche Zahl ohne Vorzeichen	un	`0x00002D3Fun`
int64	ganze 64-Bit-Zahl mit Vorzeichen	L	`86L`
uint64	natürliche 64-Bit-Zahl ohne Vorzeichen	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	Keine	`4.14`, `2.3E+32`, `2.3e+32`, `infinity` oder `-infinity`
		LF	`0x0000000000000000LF`
BIGINT	ganze Zahl, die nicht auf 64-Bit-Darstellung beschränkt ist	I	`9999999999999999999999999999I`
Decimal	als Festkommazahl oder rationale Zahl dargestellte Bruchzahl	M oder m	`0.7833M` oder `0.7833m`
Char	Unicode-Zeichen	Keine	`'a'` oder `'\u0061'`
String	Unicode-Zeichenfolge	Keine	`"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 Literal-Attribut markiert werden.

Dieses Attribut bewirkt, dass ein Wert als Konstante kompiliert wird. Im folgenden Beispiel sind x sowie y unveränderliche Werte, aber x wird zur Laufzeit ausgewertet, während y eine Kompilierzeitkonstante ist.

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

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

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

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

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

In Musterabgleichsausdrücken werden Bezeichner, die mit Kleinbuchstaben beginnen, immer als zu bindende Variablen statt als Literale behandelt. Verwenden Sie daher im Allgemeinen Großbuchstaben am Wortanfang, wenn Sie Literale definieren.

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

Hinweise

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). Sie können auch UTF-32-Codierungen enthalten, die Sie mithilfe von \U gefolgt von 32-Bit-Hexadezimalcode angeben können, der einen beliebigen Unicode-Codepunkt (00000000–0010FFFF) darstellt.

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

Ganze Zahlen in anderen Basen

Ganze 32-Bit-Zahlen mit Vorzeichen können auch hexadezimal, oktal oder binär mit einem 0x-, 0o-, bzw. 0b-Präfix 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 Unterstrich (_) trennen.

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Spezielle Gleitkomma-Unendlichkeitswerte

Die numerischen Gleitkommatypen float und single 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