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.14Fo 4.14f o 2.3e+32f o 2.3e-32f o o o infinityf-infinityf
		lf	0x00000000lf
galleggiare; doppio	Numero a virgola mobile a 64 bit	nessuno	4.14o 2.3E+32 o 2.3e+32 o 2.3e-32 o o o infinity-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 che xy di seguito sono valori non modificabili, ma x vengono valutati in fase di esecuzione, mentre y è una costante in fase di compilazione.

let x = "a" + "b" // evaluated at runtime

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