Partager via


Littéraux (F#)

Cette rubrique comprend un tableau qui indique comment spécifier le type d'un littéral en F#.

Types de littéraux

Le tableau ci-dessous répertorie les types de littéraux en F#. Les caractères qui représentent des chiffres en notation hexadécimale ne respectent pas la casse ; par contre, ceux 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

unativeint

pointeur natif sous forme de nombre naturel non signé

un

0x00002D3Fun

int64

entier 64 bits signé

L

86L

uint64

nombre naturel 64 bits non signé

UL

86UL

single, float32

nombre à virgule flottante 32 bits

F ou f

4.14F ou 4.14f

lf

0x00000000lf

float, double

nombre à virgule flottante 64 bits

aucun

4.14 ou 2.3E+32 ou 2.3e+32

LF

0x0000000000000000LF

bigint

entier non limité à la représentation 64 bits

I

9999999999999999999999999999I

decimal

nombre fractionnaire représenté sous forme d'un nombre à virgule fixe ou rationnel

M ou m

0.7833M ou 0.7833m

Char

Caractère Unicode

aucun

'a'

Chaîne

chaîne Unicode

aucun

"text\n"

ou

@"c:\filename"

ou

"""<book title="Paradise Lost">"""

ou

"string1" + "string2"

Voir aussi Chaînes (F#).

byte

un caractère ASCII

B

'a'B

byte[]

Chaîne ASCII

B

"text"B

String ou byte[]

chaîne textuelle

préfixe @

@"\\server\share" (Unicode)

@"\\server\share"B (ASCII)

Notes

Les chaînes Unicode peuvent contenir des encodages explicites que vous pouvez spécifier en utilisant \u suivi d'un code hexadécimal 16 bits, ou des encodages UTF-32 que vous pouvez spécifier en utilisant \U suivi d'un code hexadécimal 32 bits représentant une paire de substitution Unicode.

Avec F# 3,1, vous pouvez utiliser le signe + pour combiner des littéraux de chaîne. Vous pouvez également utiliser l'opérateur au niveau du bit ou (|||) pour combiner les indicateurs d'énumération. Par exemple, le code suivant est autorisé dans F# 3.1 :

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

Vous ne pouvez pas utiliser d'autres opérateurs de bits.

Littéraux nommés

Les valeurs qui sont prévues pour être des constantes peuvent être marquées avec l'attribut Literal. Cet attribut a pour effet de provoquer la compilation d'une valeur en tant que constante.

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

Voir aussi

Référence

Littéraux (F#)

Core.LiteralAttribute, classe (F#)