Littéraux

Article
02/04/2025

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 montre les types littérals en F#. Les caractères qui représentent des chiffres en notation hexadécimale ne sont pas sensibles à la casse ; les caractères qui identifient le type sont sensibles à la casse.

Type	Description	Suffixe ou préfixe	Exemples
sbyte	entier 8 bits signé	y	`86y` `0b00000101y`
byte	nombre naturel de 8 bits non signé	uy	`86uy` `0b00000101uy`
int16	entier 16 bits signé	s	`86s`
uint16	nombre naturel non signé 16 bits	nous	`86us`
int int32	entier 32 bits signé	l ou aucun	`86` `86l`
uint uint32	nombre naturel non signé 32 bits	u ou ul	`86u` `86ul`
nativeint	pointeur natif vers 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 de 64 bits non signé	UL	`86UL`
seul, float32	Nombre à virgule flottante 32 bits	F ou f	`4.14F` ou `4.14f` ou `infinityf` ou `-infinityf`
		Si	`0x00000000lf`
float ; double	Nombre à virgule flottante 64 bits	aucun	`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 fractionnel représenté sous la forme d’un point fixe ou d’un nombre rationnel	M ou m	`0.7833M` ou `0.7833m`
Char	Caractère Unicode	aucun	`'a'` ou `'\u0061'`
Chaîne	Chaîne Unicode	aucun	`"text\n"` or `@"c:\filename"` or `"""<book title="Paradise Lost">"""` or `"string1" + "string2"` Consultez également Chaînes.
byte	Caractère ASCII	B	`'a'B`
byte[]	Chaîne ASCII	B	`"text"B`
Chaîne ou octet[]	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 Littéral.

Cet attribut a l’effet de compiler une valeur en tant que constante. Dans l’exemple suivant, les x et les y ci-dessous sont des valeurs immuables, mais x est évaluée au moment 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

Remarque

Les fonctions ne peuvent pas être utilisées pour calculer des valeurs [<Literal>], car les littéraux doivent être déterminés au moment de la compilation et ne peuvent pas dépendre de l’évaluation au temps d'exécution.

Pourquoi les fonctions ne peuvent pas calculer de littéraux

L’attribut [<Literal>] nécessite que les valeurs soient connues au moment de la compilation. Les fonctions, même si elles semblent produire des sorties constantes, sont évaluées au moment de l’exécution, ce qui les rend inadaptées à [<Literal>]. Cette restriction garantit que les littéraux peuvent être utilisés en toute sécurité dans des scénarios tels que la correspondance de modèles, les arguments d’attribut et l’interopérabilité avec des fonctions externes.

Par exemple, la tentative d’affectation du résultat d’une fonction à un littéral échoue :

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

Cette distinction est également importante lors de l’appel d’une fonction externe . Par exemple, DllImport est un attribut qui doit connaître la valeur de myDLL pendant la compilation. Sans la déclaration [<Literal>], ce code ne peut pas être compilé :

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

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

Dans les expressions de correspondance de modèle, les identificateurs commençant 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

Exemple de correspondance de modèle concis à l’aide de littéraux nommés

Les littéraux nommés peuvent rendre la correspondance de modèles plus concise en évitant la nécessité de clauses when ou d’une logique additionnelle. Par exemple:

[<Literal>]
let ErrorCode = 404

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

Remarques

Les littéraux nommés sont utiles pour :

La correspondance de modèles sans clause when.
Arguments d’attribut.
Les arguments du fournisseur de types statiques.

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

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

Entiers dans d’autres bases

Les entiers 32 bits signés peuvent également être spécifiés en hexadécimal, octal ou binaire à l’aide d’un 0x, 0o ou 0b préfixe, 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 des 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 float et single à virgule flottante ont tous deux associé des valeurs spéciales représentant l’infini positif et 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 de la 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

Partager via