Valori letterali

Articolo
06/04/2024

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; caratteri che identificano il tipo fanno distinzione tra maiuscole e minuscole.

Tipo	Descrizione	Suffisso o prefisso	Esempi
sbyte	valore intero con segno a 8 bit	y	`86y` `0b00000101y`
byte	numero naturale senza segno a 8 bit	uy	`86uy` `0b00000101uy`
int16	valore intero con segno a 16 bit	s	`86s`
uint16	numero naturale senza segno a 16 bit	us	`86us`
int int32	valore intero con segno a 32 bit	l o nessuna	`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`
unativeint	puntatore nativo come numero naturale senza segno	un	`0x00002D3Fun`
int64	valore intero con segno a 64 bit	L	`86L`
uint64	numero naturale senza segno a 64 bit	UL	`86UL`
singolo, float32	numero a virgola mobile a 32 bit	F o f	`4.14F` o `4.14f` o `infinityf` o `-infinityf`
		lf	`0x00000000lf`
float; doppia	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	valore intero non limitato alla rappresentazione a 64 bit	I	`9999999999999999999999999999I`
decimale	numero frazionario rappresentato come un punto fisso o un numero razionale	M o m	`0.7833M` oppure `0.7833m`
Char	Carattere Unicode	Nessuno	`'a'` oppure `'\u0061'`
String	Stringa Unicode	Nessuno	`"text\n"` or `@"c:\filename"` or `"""<book title="Paradise Lost">"""` or `"string1" + "string2"` Vedere anche stringhe.
byte	Carattere ASCII	G	`'a'B`
byte[]	Stringa ASCII	G	`"text"B`
Stringa o byte[]	stringhe letterali	prefisso @	`@"\\server\share"` (Unicode) `@"\\server\share"B` (ASCII)

Valori letterali denominati

I valori destinati a essere costanti possono essere contrassegnati con l'attributo valore 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

Ad esempio, questa distinzione è importante quando si chiama una funzione esterna, perché 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 in genere è consigliabile usare le iniziali maiuscole 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

Osservazioni:

I valori letterali denominati sono utili per:

Criteri di ricerca senza una clausola when.
Argomenti di attributo.
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.

Valori interi in altre basi

È anche possibile specificare valori interi con segno a 32 bit rispettivamente in un prefisso esadecimale, ottale o binario usando 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

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

Valore F#	Tipo F#	Valore .NET corrispondente
`infinity` oppure `+infinity`	`float`	PositiveInfinity
`-infinity`	`float`	NegativeInfinity
`infinityf` oppure `+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. Ad 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

Condividi tramite