Freigeben über


Literale

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