J'avais l'intention d'écrire un demi-blog décent sur les instructions F #, mais j'ai pensé, et honnêtement, je ne pouvais pas voir trop d'avantages en répétant simplement ce qui est déjà librement disponible sur MSDN, qui répertorie TOUTES les instructions F #.
Vous pouvez trouver une liste complète de tous les opérateurs et caractères F # sur cette page MSDN.Si vous suivez ce lien, la première chose que vous comprendrez est que F # a beaucoup d'opérateurs et de symboles, trop pour moi à inclure dans un article de blog. Dans cet esprit, j'ai pris l'intention de créer un demi-blog décent sur les opérateurs et j'ai décidé de réduire un peu la portée pour n'inclure qu'une discussion sur les opérateurs les plus courants, donc je pense que vous pourriez dire que ce ne sera que 1/4 ou 1/8 d'un poste décent, pour lequel je m'excuse humblement.
Maintenant, avant de commencer, je voulais juste dire que je vais passer par les opérateurs les plus courants; Vous devrez très probablement étudier le lien MSDN que j'ai inclus au début de cet article lorsque vous commencez vraiment à utiliser F #, mais maintenant j'espère que ceux sur lesquels nous nous attarderons suffiront pour que nous commencions.
Opérateurs arithmétiques
+ Sommation
Incontrôlable. Une condition de dépassement possible est lorsque les nombres sont additionnés et que la somme dépasse la valeur absolue maximale prise en charge par le type.
- Soustraction
Incontrôlable. Condition possible de remplissage insuffisant lorsque des types non signés sont soustraits ou lorsque les valeurs à virgule flottante sont trop petites pour être représentées par le type.
* Multiplication
Incontrôlable. Une condition de débordement possible si les nombres sont multipliés et que le produit dépasse la valeur absolue maximale prise en charge par le type.
/ Division
La division par zéro déclenche une DivideByZeroException pour les types entiers. Pour les types à virgule flottante, la division par zéro vous donne des valeurs à virgule flottante spéciales + Infinity ou -Infinity. Une condition de sous-remplissage est également possible lorsque le nombre à virgule flottante est trop petit pour être représenté par un type.
Module%
Renvoie le reste d'une opération de division. Le signe du résultat est le même que le signe du premier opérande.
** Exposition
Condition de débordement possible lorsque le résultat dépasse la valeur absolue maximale pour le type. L'opérateur d'exponentiation fonctionne uniquement avec les types à virgule flottante.
Démo
//Arithmetic operators printfn "25 + 25 = %i" (25 + 25) printfn "75 - 25 = %i" (75 - 25) printfn "12 * 12 = %i" (12 * 12) printfn "100 / 4 = %i" (100 / 4) printfn "101 %% 10 = %i" (101
Et voici le résultat du lancement:
Opérateurs binaires
Le tableau suivant présente les opérateurs de comparaison binaires disponibles pour les types entiers et les types à virgule flottante. Ces opérateurs renvoient des valeurs de type bool.
= Égal
Ce n'est pas un opérateur d'affectation. Il est utilisé uniquement à des fins de comparaison. Il s'agit d'un opérateur universel.
> plus que
Il s'agit d'un opérateur universel.
<moins de
Il s'agit d'un opérateur universel.
> = supérieur ou égal
Il s'agit d'un opérateur universel.
<= supérieur ou égal
Il s'agit d'un opérateur universel.
<> Pas égal
Il s'agit d'un opérateur universel.
//Binary operators printfn "25 = 25 = %b" (25 = 25) printfn "26 > 25 = %b" (26 > 25) printfn "26 < 25 = %b" (26 < 25) printfn "26 >= 25 = %b" (26 >= 25) printfn "26 <= 25 = %b" (26 <= 25) printfn "'a' <= 'b' = %b" ('a' <> 'b') //how about a more complex example, a tuple printfn "(1,'a') = (2,'a') = %b" ((1,'a') = (2,'a')) printfn "(1,'a') = (1,'a') = %b" ((1,'a') = (1,'a')) printfn "Some(1) = Some(2) = %b" (Some(1) = Some(2)) printfn "Some(2) = Some(2) = %b" (Some(2) = Some(2))
Opérateurs booléens
Le tableau suivant répertorie les opérateurs logiques disponibles en F #. Le seul type pris en charge par ces opérateurs est le type bool.
pas
Négation booléenne
||
OU logique
&&
Logique et
Voici une petite démonstration des opérateurs booléens listés ci-dessus
//Boolean operators printfn "not true = %b" (not true) printfn "true || false = %b" (true || false) printfn "true && true = %b" (true && true) printfn "true && false = %b" (true && false)
Opérateurs de bits
Le tableau suivant décrit les opérateurs au niveau du bit pris en charge pour les types entiers décompressés en F #.
&&&
L'opérateur ET au niveau du bit. Par conséquent, les bits ont une valeur de 1 si et seulement si les bits correspondants dans les deux opérandes source sont 1.
|||
L'opérateur OR au niveau du bit. En conséquence, les bits ont une valeur de 1 si l'un des bits correspondants dans les opérandes source est 1.
^^^
L'opérateur exclusif au niveau du bit "OR". Par conséquent, les bits ont une valeur de 1 si et seulement si les bits des opérandes d'origine ont des valeurs inégales.
~~~
Opérateur de négation au niveau du bit. Il s'agit d'un opérateur unaire qui produit un résultat dans lequel tous les 0 bits de l'opérande d'origine sont convertis en 1 bit et tous les 1 bits sont convertis en 0 bits.
<<<
Opérateur de décalage gauche au niveau du bit. Le résultat est le premier opérande avec les bits décalés vers la gauche du nombre de bits dans le deuxième opérande. Les bits décalés de la position la plus significative ne deviennent pas la position la moins significative. Les bits les moins significatifs sont remplis de zéros. Le type du deuxième argument est int32.
>>>
Opérateur de décalage à droite au niveau du bit. Le résultat est un premier opérande avec des bits décalés vers la droite du nombre de bits dans le second opérande. Les bits décalés de la position la moins significative ne deviennent pas la position la plus significative. Pour les types non signés, les bits les plus significatifs sont remplis de zéros. Pour les types signés, les bits les plus significatifs sont remplis de uns. Le type du deuxième argument est int32.
//Bit shift operators //&&& and printfn "2 &&& 4 (which is 0010 &&& 0100, should be 0) = %X" (2 &&& 4) printfn "2 &&& 3 (which is 0010 &&& 0011, should be 2) = %X" (2 &&& 3) //||| or printfn "2 ||| 4 (which is 0010 ||| 0100, should be 6) = %X" (2 ||| 4) printfn "2 ||| 3 (which is 0010 ||| 0011, should be 3) = %X" (2 ||| 3) //^^^ xor printfn "2 ^^^ 4 (which is 0010 ^^^ 0100, should be 6) = %X" (2 ^^^ 4) printfn "2 ^^^ 3 (which is 0010 ^^^ 0011, should be 1) = %X" (2 ^^^ 3) //^^^ negate printfn "~~~4 (which is not 0100, should be 1011 (B hex), or 11 decimal) = %X" (~~~4) //<<< bit shift left printfn "4 <<< 1 (which is 0100 <<< by 1 place left , should be 1000 (8 hex), or 8 decimal) = %X" (4 <<< 1) //>>> bit shift right printfn "4 >>> 1 (which is 0100 >>> by 1 place right , should be 0010 (2 hex), or 2 decimal) = %X" (4 >>> 1)
Surcharge de l'opérateur
Comme je l'ai mentionné, il y aura des moments où vous devrez implémenter votre propre logique opérateur. Dans d'autres langages .NET, cela peut être réalisé en fournissant vos propres surcharges d'opérateur. Sans surprise, vous devez faire de même en F #. Je ne voulais pas encore entrer dans les classes et OO, mais cela semble cohérent avec la discussion actuelle, alors voyons comment vous pouvez implémenter vos propres opérateurs en F #.
Je l'ai encore volé sur MSDN. Le code suivant illustre une classe vectorielle qui n'a que deux opérateurs: un pour le moins unaire et un pour la multiplication par un scalaire. Dans cet exemple, deux surcharges sont nécessaires pour la multiplication scalaire, car l'opérateur doit fonctionner quel que soit l'ordre dans lequel le vecteur et le scalaire apparaissent.
type Vector(x: float, y : float) = member this.x = x member this.y = y static member (~-) (v : Vector) = Vector(-1.0 * vx, -1.0 * vy) static member (*) (v : Vector, a) = Vector(a * vx, a * vy) static member (*) (a, v: Vector) = Vector(a * vx, a * vy) override this.ToString() = this.x.ToString() + " " + this.y.ToString()