Partager via


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