Letterlijke waarden

Artikel
05/29/2024

Dit artikel bevat een tabel waarin wordt beschreven hoe u het type letterlijke waarde in F# kunt opgeven.

Letterlijke typen

In de volgende tabel ziet u de letterlijke typen in F#. Tekens die cijfers in hexadecimale notatie vertegenwoordigen, zijn niet hoofdlettergevoelig; tekens die het type identificeren, zijn hoofdlettergevoelig.

Type	Description	Achtervoegsel of voorvoegsel	Voorbeelden
sbyte	ondertekend 8-bits geheel getal	y	`86y` `0b00000101y`
Byte	niet-ondertekend 8-bits natuurlijk getal	Uy	`86uy` `0b00000101uy`
int16	ondertekend 16-bits geheel getal	s	`86s`
uint16	niet-ondertekend 16-bits natuurlijk getal	VS	`86us`
int int32	ondertekend 32-bits geheel getal	l of geen	`86` `86l`
uint uint32	niet-ondertekend 32-bits natuurlijk getal	u of ul	`86u` `86ul`
nativeint	systeemeigen aanwijzer naar een ondertekend natuurlijk getal	n	`123n`
unativeint	systeemeigen aanwijzer als een niet-ondertekend natuurlijk getal	un	`0x00002D3Fun`
int64	ondertekend 64-bits geheel getal	L	`86L`
uint64	niet-ondertekend 64-bits natuurlijk getal	UL	`86UL`
enkelvoudig, float32	32-bits drijvendekommanummer	F of f	`4.14F`of `4.14f` of `infinityf-infinityf`
		Lf	`0x00000000lf`
Float; Dubbele	64-bits drijvendekommanummer	Geen	`4.14`of `2.3E+32` of `2.3e+32` of `infinity-infinity`
		LF	`0x0000000000000000LF`
bigint	geheel getal niet beperkt tot 64-bits weergave	I	`9999999999999999999999999999I`
decimal	fractioneel getal dat wordt weergegeven als een vast punt of rationeel getal	M of m	`0.7833M` of `0.7833m`
Char	Unicode-teken	Geen	`'a'` of `'\u0061'`
String	Unicode-tekenreeks	Geen	`"text\n"` or `@"c:\filename"` or `"""<book title="Paradise Lost">"""` or `"string1" + "string2"` Zie ook Tekenreeksen.
Byte	ASCII-teken	B	`'a'B`
byte[]	ASCII-tekenreeks	B	`"text"B`
Tekenreeks of byte[]	verbatimtekenreeks	@ voorvoegsel	`@"\\server\share"` (Unicode) `@"\\server\share"B` (ASCII)

Benoemde letterlijke tekens

Waarden die zijn bedoeld om constanten te zijn, kunnen worden gemarkeerd met het kenmerk Letterlijk .

Dit kenmerk heeft het effect dat een waarde als een constante wordt gecompileerd. In het volgende voorbeeld zijn beide x en y onderstaande onveranderbare waarden, maar x worden tijdens runtime geëvalueerd, terwijl y dit een compilatieconstante is.

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

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

Dit onderscheid is bijvoorbeeld belangrijk bij het aanroepen van een externe functie, omdat DllImport dit een kenmerk is dat de waarde van myDLL tijdens de compilatie moet weten. Zonder de [<Literal>] declaratie kan deze code niet worden gecompileerd:

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

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

In patroonkoppelingsexpressies worden id's die beginnen met kleine letters altijd behandeld als variabelen die moeten worden gebonden, in plaats van als letterlijke waarden, dus moet u in het algemeen initiële hoofdletters gebruiken wanneer u letterlijke waarden definieert.

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

Opmerkingen

Benoemde letterlijke waarden zijn handig voor:

Patroonkoppeling zonder een when component.
Kenmerkargumenten.
Argumenten van de statische typeprovider.

Unicode-tekenreeksen kunnen expliciete coderingen bevatten die u kunt opgeven met behulp van \u een 16-bits hexadecimale code (0000 - FFFF) of UTF-32-coderingen die u kunt opgeven door een \U 32-bits hexadecimale code te gebruiken die elk Unicode-codepunt vertegenwoordigt (000000000 - 0010FFFF).

Het gebruik van bitsgewijze operatoren anders dan ||| is niet toegestaan.

Gehele getallen in andere bases

Ondertekende 32-bits gehele getallen kunnen ook worden opgegeven in hexadecimaal, octaal of binair met respectievelijk een 0x, 0o of 0b voorvoegsel.

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

Onderstrepingstekens in numerieke letterlijke waarden

U kunt cijfers scheiden met het onderstrepingsteken (_).

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Speciale oneindige waarden voor zwevende komma

Zowel de float numerieke typen single drijvende komma's hebben speciale waarden gekoppeld die positief en negatief oneindig zijn.

F#-waarde	F#-type	Corresponderende .NET-waarde
`infinity` of `+infinity`	`float`	PositiveInfinity
`-infinity`	`float`	NegativeInfinity
`infinityf` of `+infinityf`	`single`	PositiveInfinity
`-infinityf`	`single`	NegativeInfinity

Deze waarden kunnen rechtstreeks worden gebruikt of worden geretourneerd bij het delen door een drijvendekommageul of een getal dat te klein is om te worden weergegeven door het opgegeven type. Voorbeeld:

> 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

Delen via