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.

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

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.

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