Condividi tramite


Valori letterali

Questo articolo fornisce una tabella che illustra come specificare il tipo di un valore letterale in F#.

Tipi letterali

La tabella seguente illustra i tipi letterali in F#. I caratteri che rappresentano cifre nella notazione esadecimale non fanno distinzione tra maiuscole e minuscole; i caratteri che identificano il tipo fanno distinzione tra maiuscole e minuscole.

Digitare Descrizione Suffisso o prefisso Esempi
sbyte intero con segno a 8 bit y 86y

0b00000101y
byte numero naturale senza segno a 8 bit uy 86uy

0b00000101uy
int16 intero con segno a 16 bit s 86s
uint16 numero naturale senza segno a 16 bit noi 86us
Int

int32
intero con segno a 32 bit l o nessuno 86

86l
uint

uint32
numero naturale senza segno a 32 bit u o ul 86u

86ul
nativeint puntatore nativo a un numero naturale con segno n 123n
non intenzionale puntatore nativo come numero naturale senza segno un 0x00002D3Fun
int64 intero con segno a 64 bit L 86L
uint64 numero naturale senza segno a 64 bit UL 86UL
single, float32 Numero a virgola mobile a 32 bit F o f 4.14F o 4.14f o infinityf o -infinityf
lf 0x00000000lf
galleggiare; doppio Numero a virgola mobile a 64 bit nessuno 4.14 o 2.3E+32 o 2.3e+32 o infinity o -infinity
LF 0x0000000000000000LF
bigint Integer non limitato alla rappresentazione a 64 bit Io 9999999999999999999999999999I
decimale numero frazionario rappresentato come un numero a virgola fissa o un numero razionale M o m 0.7833M o 0.7833m
Char Carattere Unicode nessuno 'a' o '\u0061'
Stringa Stringa Unicode nessuno "text\n"

o

@"c:\filename"

o

"""<book title="Paradise Lost">"""

o

"string1" + "string2"

Vedi anche String.
byte Carattere ASCII B 'a'B
byte[] Stringa ASCII B "text"B
Stringa o byte[] stringa verbatim Prefisso @ @"\\server\share" (Unicode)

@"\\server\share"B (ASCII)

Letterali nominati

I valori destinati a essere costanti possono essere contrassegnati con l'attributo letterale.

Questo attributo ha l'effetto di causare la compilazione di un valore come costante. Nell'esempio seguente, sia x che y seguenti sono valori non modificabili, ma x viene valutato in fase di esecuzione, mentre y è una costante in fase di compilazione.

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

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

Nota

Non è possibile utilizzare funzioni per calcolare valori [<Literal>] perché i numeri letterali devono essere determinati in fase di compilazione e non possono dipendere dalla valutazione di runtime.

Perché le funzioni non possono calcolare valori letterali

L'attributo [<Literal>] richiede che i valori siano noti in fase di compilazione. Le funzioni, anche se sembrano produrre output costanti, vengono valutate in fase di esecuzione, rendendole non adatte per [<Literal>]. Questa restrizione garantisce che i valori letterali possano essere usati in modo sicuro in scenari come il matching dei pattern, i parametri degli attributi e l'interop con funzioni esterne.

Ad esempio, il tentativo di assegnare il risultato di una funzione a un valore letterale avrà esito negativo:

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

Questa distinzione è importante anche quando si chiama una funzione esterna . Ad esempio, DllImport è un attributo che deve conoscere il valore di myDLL durante la compilazione. Senza la dichiarazione di [<Literal>], il codice non verrà compilato:

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

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

Nelle espressioni di corrispondenza dei criteri di ricerca gli identificatori che iniziano con caratteri minuscoli vengono sempre considerati variabili da associare, anziché come valori letterali, pertanto è consigliabile usare in genere maiuscole iniziali quando si definiscono valori letterali.

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

Esempio di criteri di ricerca concisi usando valori letterali denominati

I valori letterali denominati possono rendere il pattern matching più conciso evitando la necessità di clausole when o logica aggiuntiva. Per esempio:

[<Literal>]
let ErrorCode = 404

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

Osservazioni

I valori letterali denominati sono utili per:

  • Riscontro dei pattern senza una clausola when.
  • Argomenti degli attributi.
  • Argomenti del provider di tipi statici.

Le stringhe Unicode possono contenere codifiche esplicite che è possibile specificare usando \u seguito da un codice esadecimale a 16 bit (0000 - FFFF) o codifiche UTF-32 che è possibile specificare usando \U seguito da un codice esadecimale a 32 bit che rappresenta qualsiasi punto di codice Unicode (000000000 - 0010FFFF).

L'uso di operatori bit per bit diversi da ||| non è consentito.

Numeri interi in altre basi

I numeri interi con segno a 32 bit possono essere specificati in esadecimale, ottale o binario usando rispettivamente un prefisso 0x, 0o o 0b.

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

Caratteri di sottolineatura nei valori letterali numerici

È possibile separare le cifre con il carattere di sottolineatura (_).

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Valori di infinito a virgola mobile speciali

Sia i tipi numerici float che single a virgola mobile hanno associato valori speciali che rappresentano un infinito positivo e negativo.

Valore F# Tipo F# Valore .NET corrispondente
infinity o +infinity float PositiveInfinity
-infinity float NegativeInfinity
infinityf o +infinityf single PositiveInfinity
-infinityf single NegativeInfinity

Questi valori possono essere utilizzati direttamente o vengono restituiti quando si divide per zero a virgola mobile o un numero troppo piccolo per essere rappresentato dal tipo specificato. Per esempio:

> 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