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