Référence des symboles et opérateurs (F#)

Cette rubrique comprend un tableau des symboles et des opérateurs utilisés en langage F#.

Tableau de symboles et d'opérateurs

Le tableau suivant décrit les symboles utilisés en langage F#, fournit des liens vers des rubriques qui fournissent plus d'informations et offre une brève description de certaines utilisations des symboles.Les symboles sont classés selon l'ordre du jeu de caractères ASCII.

Symbole ou opérateur	Liens	Description
!	Cellules de référence (F#) Expressions de calcul (F#)	Déréférence une cellule de référence. Indique, après un mot clé, une version modifiée du comportement du mot clé sous le contrôle d'un workflow.
!=	Non applicable.	Non utilisé en F#.Utilisez <> pour les opérations d'inégalité.
"	Littéraux (F#) Chaînes (F#)	Délimite une chaîne de texte.
"""	Chaînes (F#)	Délimite une chaîne de texte sans prise en compte des caractères de contrôle.Diffère de @"..." car vous pouvez indiquer un guillemet à l'aide d'un guillemet simple dans la chaîne.
#	Directives de compilateur (F#) Types flexibles (F#)	Préfixe une directive de préprocesseur ou de compilateur, par exemple #light. En cas d'utilisation avec un type, indique un type flexible qui fait référence à un type ou à l'un de ses types dérivés.
$	Aucune information supplémentaire n'est disponible.	Utilisé en interne pour certains noms de variable et de fonction générés par le compilateur.
%	Opérateurs arithmétiques (F#) Quotations de code (F#)	Calcule le modulo entier.Utilisé pour l'ajout de quotations.
%?	Opérateurs autorisant la valeur Null (F#)	Calcule le modulo entier, lorsque le côté droit est un type Nullable.
&	Expressions match (F#)	Calcule l'adresse d'une valeur mutable, pour une utilisation lors de l'interaction avec d'autres langages. Utilisé dans les modèles AND.
&&	Opérateurs booléens (F#)	Calcule l'opération AND booléenne.
&&&	Opérateurs de bits (F#)	Calcule l'opération de bits AND.
'	Littéraux (F#) Généralisation automatique (F#)	Délimite un littéral à un caractère. Indique un paramètre de type générique.
``...``	Aucune information supplémentaire n'est disponible.	Délimite un identificateur qui ne serait sinon pas un identificateur légal, tel qu'un mot clé de langage.
( )	Type unit (F#)	Représente la valeur unique du type d'unité.
(...)	Tuples (F#) Surcharge d'opérateur (F#)	Indique l'ordre dans lequel les expressions sont évaluées. Délimite un tuple. Utilisé dans les définitions d'opérateur.
(*...*)		Délimite un commentaire qui peut couvrir plusieurs lignes.
(|...|)	Modèles actifs (F#)	Délimite un modèle actif.Aussi appelé « banana clips ».
*	Opérateurs arithmétiques (F#) Tuples (F#) Unités de mesure (F#)	En cas d'utilisation comme opérateur binaire, multiplie les côtés gauche et droit. Dans les types, indique le jumelage dans un tuple. Utilisé dans les unités de types de mesure.
*?	Opérateurs autorisant la valeur Null (F#)	Multiplie les côtés gauche et droit, lorsque le côté droit est un type Nullable.
**	Opérateurs arithmétiques (F#)	Calcule l'opération d'élévation à la puissance (x ** y signifie x puissance y).
+	Opérateurs arithmétiques (F#)	En cas d'utilisation comme opérateur binaire, ajoute les côtés gauche et droit. En cas d'utilisation comme opérateur unaire, indique une quantité positive.(Formellement, il produit la même valeur avec le signe inchangé.)
+?	Opérateurs autorisant la valeur Null (F#)	Ajoute les côtés gauche et droit, lorsque le côté droit est un type Nullable.
,	Tuples (F#)	Sépare les éléments d'un tuple ou les paramètres de type.
-	Opérateurs arithmétiques (F#)	En cas d'utilisation comme opérateur binaire, soustraie le côté droit du côté gauche. En cas d'utilisation comme opérateur unaire, effectue une opération de négation.
-	Opérateurs autorisant la valeur Null (F#)	Soustrait le côté droit sur le côté gauche, lorsque le côté droit est un type Nullable.
->	Fonctions (F#) Expressions match (F#)	Dans les types de fonction, délimite les arguments et les valeurs de retour. Produit une expression (dans les expressions de séquence) ; équivaut au mot clé yield. Utilisé dans les expressions de correspondance
.	Membres (F#) Types primitifs (F#)	Accède à un membre et sépare les noms individuels dans un nom qualifié complet. Spécifie une virgule décimale dans les nombres à virgule flottante.
..	Boucles : expression for...in (F#)	Spécifie une plage.
.. ..	Boucles : expression for...in (F#)	Spécifie une plage et un incrément.
.[...]	Tableaux (F#)	Accède à un élément de tableau.
/	Opérateurs arithmétiques (F#) Unités de mesure (F#)	Divise le côté gauche (numérateur) par le côté droit (dénominateur). Utilisé dans les unités de types de mesure.
/?	Opérateurs autorisant la valeur Null (F#)	Divise le côté gauche par le côté droit, lorsque le côté droit est un type Nullable.
//		Indique le début d'un commentaire sur une ligne.
///	Documentation XML (F#)	Indique un commentaire XML.
:	Fonctions (F#)	Dans une annotation de type, sépare un nom de paramètre ou de membre de son type.
::	Listes (F#) Expressions match (F#)	Crée une liste.L'élément côté gauche est ajouté à la liste côté droit. Utilisé dans les critères spéciaux pour séparer les parties d'une liste.
:=	Cellules de référence (F#)	Assigne une valeur à une cellule de référence.
:>	Cast et conversions (F#)	Convertit un type en un type qui est plus haut dans la hiérarchie.
:?	Expressions match (F#)	Retourne la valeur true si la valeur correspond au type spécifié ; sinon, retourne la valeur false (opérateur de test de type).
:?>	Cast et conversions (F#)	Convertit un type en un type qui est plus bas dans la hiérarchie.
;	Syntaxe détaillée (F#) Listes (F#) Enregistrements (F#)	Sépare des expressions (utilisé principalement dans la syntaxe détaillée). Sépare les éléments d'une liste. Sépare les champs d'un enregistrement.
<	Opérateurs arithmétiques (F#)	Calcule l'opération inférieur à.
<?	Opérateurs autorisant la valeur Null (F#)	Calcule l´opération ¨moins que¨, lorsque le côté droit est un type Nullable.
<<	Fonctions (F#)	Compose deux fonctions dans l'ordre inverse ; la deuxième est exécutée en premier (opérateur de composition arrière).
<<<	Opérateurs de bits (F#)	Déplace la quantité de bits côté gauche vers la gauche selon le nombre de bits spécifié côté droit.
<-	Valeurs (F#)	Assigne une valeur à une variable.
<...>	Généralisation automatique (F#)	Délimite les paramètres de type.
<>	Opérateurs arithmétiques (F#)	Retourne la valeur true si le côté gauche n'est pas égal au côté droit ; sinon, retourne la valeur false.
<>?	Opérateurs autorisant la valeur Null (F#)	Calcule l´opération ¨différent de¨, lorsque le côté droit est un type Nullable.
<=	Opérateurs arithmétiques (F#)	Retourne la valeur true si le côté gauche est inférieur ou égal au côté droit ; sinon, retourne la valeur false.
<=?	Opérateurs autorisant la valeur Null (F#)	Calcule l´opération « inférieur ou égal à » lorsque le côté droit est un type Nullable.
<|	Fonctions (F#)	Passe le résultat de l'expression côté droit à la fonction côté gauche (opérateur de barre verticale inverse).
<||	Operators.( <|| )<'T1,'T2,'U>, fonction (F#)	Passe le tuple de deux arguments du côté droit à la fonction côté gauche.
<|||	Operators.( <||| )<'T1,'T2,'T3,'U>, fonction (F#)	Passe le tuple de trois arguments du côté droit à la fonction côté gauche.
<@...@>	Quotations de code (F#)	Délimite une quotation de code typée.
<@@...@@>	Quotations de code (F#)	Délimite une quotation de code non typée.
=	Opérateurs arithmétiques (F#)	Retourne la valeur true si le côté gauche est égal au côté droit ; sinon, retourne la valeur false.
=?	Opérateurs autorisant la valeur Null (F#)	Calcule l´opération ¨égal¨, lorsque le côté droit est un type Nullable.
==	Non applicable.	Non utilisé en F#.Utilisez = pour les opérations d'égalité.
>	Opérateurs arithmétiques (F#)	Retourne la valeur true si le côté gauche est supérieur au côté droit ; sinon, retourne la valeur false.
>?	Opérateurs autorisant la valeur Null (F#)	Calcule l´opération ¨plus grand que¨, lorsque le côté droit est un type Nullable.
>>	Fonctions (F#)	Compose deux fonctions (opérateur de composition avant).
>>>	Opérateurs de bits (F#)	Déplace la quantité de bits côté gauche vers la droite selon le nombre de bits spécifié côté droit.
>=	Opérateurs arithmétiques (F#)	Retourne la valeur true si le côté droit est supérieur ou égal au côté gauche ; sinon, retourne la valeur false.
>=?	Opérateurs autorisant la valeur Null (F#)	Calcule l´opération « suppérieur ou égal » lorsque le côté droit est un type Nullable.
?	Paramètres et arguments (F#)	Spécifie un argument facultatif. Utilisé comme opérateur pour les appels dynamiques de méthode et de propriété.Vous devez fournir votre propre implémentation.
? ... <- ...	Aucune information supplémentaire n'est disponible.	Utilisé comme opérateur pour définir les propriétés dynamiques.Vous devez fournir votre propre implémentation.
?>=, ?>, ?<=, ?<, ?=, ?<>, ?+, ?-, ?*, ?/	Opérateurs autorisant la valeur Null (F#)	Équivalent aux opérateurs correspondants sans ?préfixe, où un type Nullable est située à gauche.
>=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /?	Opérateurs autorisant la valeur Null (F#)	Équivalent aux opérateurs correspondants sans ?suffix, où un type Nullable est à droite.
?>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/?	Opérateurs autorisant la valeur Null (F#)	Équivalent aux opérateurs correspondants sans points d'interrogation voisins, où les deux côtés sont des types Nullable.
@	Listes (F#) Chaînes (F#)	Concatène deux listes. En cas de placement avant un littéral de chaîne, indique que la chaîne doit être interprétée mot à mot, sans interprétation des caractères d'échappement.
[...]	Listes (F#)	Délimite les éléments d'une liste.
[|...|]	Tableaux (F#)	Délimite les éléments d'un tableau.
[<...>]	Attributs (F#)	Délimite un attribut.
\	Chaînes (F#)	Échappe le caractère suivant ; utilisé dans les littéraux de caractère et de chaîne.
^	Paramètres de type résolus statiquement (F#) Chaînes (F#)	Spécifie des paramètres de type qui doivent être résolus au moment de la compilation, et non au moment de l'exécution. Concatène des chaînes.
^^^	Opérateurs de bits (F#)	Calcule l'opération de bits OR exclusive.
_	Expressions match (F#) Génériques (F#)	Indique un modèle de caractère générique. Spécifie un paramètre générique anonyme.
`	Généralisation automatique (F#)	Utilisé en interne pour indiquer un paramètre de type générique.
{...}	Séquences (F#) Enregistrements (F#)	Délimite des expressions de séquence et des expressions de calcul. Utilisé dans les définitions d'enregistrement.
|	Expressions match (F#)	Délimite des cas de correspondance individuels, des cas d'union discriminée individuels et des valeurs d'énumération.
||	Opérateurs booléens (F#)	Calcule l'opération OR booléenne.
|||	Opérateurs de bits (F#)	Calcule l'opération de bits OR.
|>	Fonctions (F#)	Passe le résultat côté gauche à la fonction côté droit (opérateur de canal).
||>	Operators.( ||> )<'T1,'T2,'U>, fonction (F#)	Passe le tuple de deux arguments du côté gauche à la fonction côté droit.
|||>	Operators.( |||> )<'T1,'T2,'T3,'U>, fonction (F#)	Passe le tuple de trois arguments du côté gauche à la fonction côté droit.
~~	Surcharge d'opérateur (F#)	Permet de déclarer une surcharge pour l'opérateur de négation unaire.
~~~	Opérateurs de bits (F#)	Calcule l'opération de bits NOT.
~-	Surcharge d'opérateur (F#)	Permet de déclarer une surcharge pour l'opérateur moins unaire.
~+	Surcharge d'opérateur (F#)	Permet de déclarer une surcharge pour l'opérateur unaire plus.

Priorité des opérateurs

Le tableau suivant indique l'ordre de précédence des opérateurs et d'autres mots clés d'expression dans le langage F#, de la précédence la plus faible à la plus élevée.Le cas échéant, l'associativité est également indiquée.

Opérateur	Associativité
as	Droite
when	Droite
| (canal)	Left
;	Droite
let	Non associatif
function, fun, match, try	Non associatif
if	Non associatif
->	Droite
:=	Droite
,	Non associatif
or, ||	Left
&, &&	Left
<op, >op, =, |op, &op	Left
&&&, |||, ^^^, ~~~, <<<, >>>	Left
^op	Droite
::	Droite
:?>, :?	Non associatif
-op, +op, (binaire)	Left
*op, /op, %op	Left
**op	Droite
f x (application de fonction)	Left
| (correspondance de modèle)	Droite
opérateurs préfixés (+op, -op, %, %%, &, &&, !op, ~op)	Left
.	Left
f(x)	Left
f<types>	Left

F# prend en charge la surcharge d'opérateur personnalisée.Cela signifie que vous pouvez définir vos propres opérateurs.Dans le tableau précédent, op peut être une séquence valide (éventuellement vide) de caractères d'opérateur, intégrée ou définie par l'utilisateur.Vous pouvez donc utiliser ce tableau pour déterminer la séquence de caractères à utiliser pour un opérateur personnalisé afin d'obtenir le niveau de précédence désiré.Les caractères de début . sont ignorés lorsque le compilateur détermine la précédence.

Voir aussi

Référence

Surcharge d'opérateur (F#)

Autres ressources

Référence du langage F#