Littéraux

Cet article fournit un tableau qui montre comment spécifier le type d’un littéral en F#.

Types de littéral

Le tableau suivant présente les types de littéraux en F#. Les caractères qui représentent des chiffres en notation hexadécimale ne respectent pas la casse. Les caractères qui identifient le type respectent la casse.

Type	Description	Suffixe ou préfixe	Exemples
sbyte	Entier 8 bits signé	y	86y 0b00000101y
byte	Nombre naturel 8 bits non signé	uy	86uy 0b00000101uy
int16	Entier 16 bits signé	s	86s
uint16	Nombre naturel 16 bits non signé	us	86us
int int32	Entier 32 bits signé	l ou aucun	86 86l
uint uint32	Nombre naturel 32 bits non signé	u ou ul	86u 86ul
nativeint	pointeur natif désignant un nombre naturel signé	n	123n
unativeint	pointeur natif en tant que nombre naturel non signé	un	0x00002D3Fun
int64	Entier 64 bits signé	L	86L
uint64	Nombre naturel 64 bits non signé	UL	86UL
simple, float32	Nombre à virgule flottante 32 bits	F ou f	4.14F ou 4.14f ou infinityf ou -infinityf
		lf	0x00000000lf
float ; double	Nombre à virgule flottante 64 bits	Aucune	4.14 ou 2.3E+32 ou 2.3e+32 ou infinity ou -infinity
		LF	0x0000000000000000LF
bigint	Entier non limité à la représentation 64 bits	I	9999999999999999999999999999I
Décimal	Nombre fractionnaire représenté sous la forme d’un nombre rationnel ou à virgule fixe	M ou m	0.7833M ou 0.7833m
Char	Caractère Unicode	aucun	'a' ou '\u0061'
String	chaîne Unicode	aucun	"text\n" or @"c:\filename" or """<book title="Paradise Lost">""" or "string1" + "string2" Voir aussi Chaînes.
byte	Caractères ASCII	B	'a'B
byte[]	Chaîne ASCII	B	"text"B
Chaîne ou byte[]	Chaîne verbatim	Préfixe @	@"\\server\share" (Unicode) @"\\server\share"B (ASCII)

Littéraux nommés

Les valeurs destinées à être des constantes peuvent être marquées avec l’attribut Literal.

Cet attribut a pour effet d’entraîner la compilation d’une valeur en tant que constante. Dans l’exemple suivant, x et y ci-dessous sont des valeurs immuables, mais l’évaluation de x s’effectue lors de l’exécution, tandis que y est une constante au moment de la compilation.

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

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

Par exemple, cette distinction est importante au moment de l’appel d’une fonction externe, car DllImport est un attribut qui doit connaître la valeur de myDLL pendant la compilation. Sans la déclaration [<Literal>], la compilation de ce code échouera :

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

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

Dans les expressions de critères spéciaux, les identificateurs qui commencent par des caractères minuscules sont toujours traités comme des variables à lier, plutôt que comme des littéraux. Vous devez donc généralement utiliser des majuscules initiales lorsque vous définissez des littéraux.

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

Notes

Les littéraux nommés sont utiles pour :

• Les critères spéciaux sans clause when
• Les arguments d’attribut
• Les arguments du fournisseur de type statique

Les chaînes Unicode peuvent contenir des encodages explicites que vous pouvez spécifier à l’aide de \u suivi d’un code hexadécimal 16 bits (0000 – FFFF), ou des encodages UTF-32 que vous pouvez spécifier à l’aide de \U suivi d’un code hexadécimal 32 bits qui représente n’importe quel code de caractère Unicode (00000000 – 0010FFFF).

L’utilisation d’opérateurs au niveau du bit autres que ||| n’est pas autorisée.

Entiers dans d’autres bases

Les entiers 32 bits signés peuvent également être spécifiés en notation hexadécimale, octale ou binaire à l’aide d’un préfixe 0x, 0o ou 0b, respectivement.

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

Traits de soulignement dans les littéraux numériques

Vous pouvez séparer les chiffres avec le caractère de soulignement (_).

let value = 0xDEAD_BEEF

let valueAsBits = 0b1101_1110_1010_1101_1011_1110_1110_1111

let exampleSSN = 123_45_6789

Valeurs d’infini à virgule flottante spéciales

Les types numériques à virgule flottante float et single ont des valeurs spéciales associées représentant l’infini positif et l’infini négatif.

Valeur F#	Type F#	Valeur .NET correspondante
infinity ou +infinity	float	PositiveInfinity
-infinity	float	NegativeInfinity
infinityf ou +infinityf	single	PositiveInfinity
-infinityf	single	NegativeInfinity

Ces valeurs peuvent être utilisées directement ou sont retournées lors d’une division par un zéro à virgule flottante ou un nombre trop petit pour être représenté par le type donné. Par exemple :

> 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