Ich wollte einen halben anständigen Blog-Beitrag über F # -Anweisungen schreiben, aber dann dachte ich, und ehrlich gesagt, ich konnte nicht allzu viele Vorteile erkennen, wenn ich einfach wiederholte, was auf MSDN bereits frei verfügbar ist, in dem ALLE F # -Anweisungen aufgelistet sind.
Eine vollständige Liste aller F # -Operatoren und -Zeichen finden Sie auf dieser MSDN-Seite.Wenn Sie diesem Link folgen, werden Sie als Erstes verstehen, dass F # viele Operatoren und Symbole enthält, zu viele, als dass ich sie in einen Blog-Beitrag aufnehmen könnte. In diesem Sinne habe ich die Absicht übernommen, einen halben anständigen Blog-Beitrag über Betreiber zu erstellen, und beschlossen, den Umfang ein wenig zu reduzieren, um nur eine Diskussion der häufigsten Betreiber aufzunehmen. Ich denke, man könnte sagen, dass dies nur 1/4 sein wird oder 1/8 eines anständigen Beitrags, für den ich mich demütig entschuldige.
Bevor wir beginnen, wollte ich nur sagen, dass ich nur die gängigsten Operatoren durchgehen werde. Sie werden höchstwahrscheinlich den MSDN-Link studieren müssen, den ich am Anfang dieses Beitrags eingefügt habe, wenn Sie wirklich anfangen, F # zu verwenden, aber jetzt hoffe ich, dass die, auf die wir uns konzentrieren, ausreichen, um loszulegen.
Arithmetische Operatoren
+ Zusammenfassung
Unkontrollierbar. Eine mögliche Überlaufbedingung ist, wenn Zahlen summiert werden und die Summe den vom Typ unterstützten maximalen Absolutwert überschreitet.
- Subtraktion
Unkontrollierbar. Mögliche Unterfüllungsbedingung, wenn vorzeichenlose Typen subtrahiert werden oder wenn Gleitkommawerte zu klein sind, um vom Typ dargestellt zu werden.
* Multiplikation
Unkontrollierbar. Eine mögliche Überlaufbedingung, wenn die Zahlen multipliziert werden und das Produkt den vom Typ unterstützten maximalen Absolutwert überschreitet.
/ Abteilung
Die Division durch Null löst eine DivideByZeroException für ganzzahlige Typen aus. Bei Gleitkommatypen erhalten Sie durch Teilen durch Null spezielle Gleitkommawerte + Unendlich oder -Infinität. Eine Unterfüllungsbedingung ist auch möglich, wenn die Gleitkommazahl zu klein ist, um durch einen Typ dargestellt zu werden.
% Modul
Gibt den Rest einer Divisionsoperation zurück. Das Vorzeichen des Ergebnisses entspricht dem Vorzeichen des ersten Operanden.
** Belichtung
Möglicher Überlaufzustand, wenn das Ergebnis den maximalen Absolutwert für den Typ überschreitet. Der Exponentiationsoperator arbeitet nur mit Gleitkommatypen.
Demo
//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
Und hier ist das Startergebnis:
Binäroperatoren
Die folgende Tabelle zeigt die binären Vergleichsoperatoren, die für Ganzzahltypen und Gleitkommatypen verfügbar sind. Diese Operatoren geben Werte vom Typ bool zurück.
= Gleich
Dies ist kein Zuweisungsoperator. Es wird nur zum Vergleich verwendet. Dies ist ein universeller Operator.
> mehr als
Dies ist ein universeller Operator.
<weniger als
Dies ist ein universeller Operator.
> = größer oder gleich
Dies ist ein universeller Operator.
<= größer oder gleich
Dies ist ein universeller Operator.
<> Nicht gleich
Dies ist ein universeller Operator.
//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))
Boolesche Operatoren
In der folgenden Tabelle sind die in F # verfügbaren logischen Operatoren aufgeführt. Der einzige von diesen Operatoren unterstützte Typ ist der Bool-Typ.
nicht
Boolesche Negation
||
Logisches ODER
&&
Logisch und
Hier ist eine kleine Demonstration der oben aufgeführten booleschen Operatoren
//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)
Bitoperatoren
In der folgenden Tabelle werden die bitweisen Operatoren beschrieben, die für entpackte Ganzzahltypen in F # unterstützt werden.
&&&
Der bitweise AND-Operator. Bits haben daher genau dann den Wert 1, wenn die entsprechenden Bits in beiden Quelloperanden 1 sind.
|||
Der bitweise ODER-Operator. Die Bits haben als Ergebnis den Wert 1, wenn eines der entsprechenden Bits in den Quelloperanden 1 ist.
^^^
Der bitweise exklusive Operator "ODER". Bits haben daher genau dann den Wert 1, wenn die Bits in den ursprünglichen Operanden ungleiche Werte haben.
~~~
Bitweiser Negationsoperator. Dies ist ein unärer Operator, der ein Ergebnis erzeugt, bei dem alle 0 Bits im ursprünglichen Operanden in 1 Bit und alle 1 Bits in 0 Bits konvertiert werden.
<<<
Bitweiser Linksschieber. Das Ergebnis ist der erste Operand, bei dem die Bits um die Anzahl der Bits im zweiten Operanden nach links verschoben sind. Von der höchstwertigen Position verschobene Bits werden nicht zur niedrigstwertigen Position. Die niedrigstwertigen Bits werden mit Nullen aufgefüllt. Der Typ des zweiten Arguments ist int32.
>>>
Bitweiser Rechtsschieber. Das Ergebnis ist ein erster Operand mit um die Anzahl der Bits im zweiten Operanden nach rechts verschobenen Bits. Von der niedrigstwertigen Position verschobene Bits werden nicht zur höchstwertigen Position. Bei vorzeichenlosen Typen werden die höchstwertigen Bits mit Nullen aufgefüllt. Bei vorzeichenbehafteten Typen werden die höchstwertigen Bits mit Einsen aufgefüllt. Der Typ des zweiten Arguments ist 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)
Bedienerüberlastung
Wie bereits erwähnt, wird es Zeiten geben, in denen Sie Ihre eigene Operatorlogik implementieren müssen. In anderen .NET-Sprachen kann dies erreicht werden, indem Sie Ihre eigenen Operatorüberladungen bereitstellen. Es überrascht nicht, dass Sie dasselbe in F # tun müssen. Ich wollte noch nicht in Klassen und OO gehen, aber es scheint mit der aktuellen Diskussion übereinzustimmen. Lassen Sie uns also sehen, wie Sie Ihre eigenen Operatoren in F # implementieren können.
Ich habe es wieder von MSDN gestohlen. Der folgende Code zeigt eine Vektorklasse mit nur zwei Operatoren: einen für das unäre Minus und einen für die Multiplikation mit einem Skalar. In diesem Beispiel werden zwei Überladungen für die Skalarmultiplikation benötigt, da der Operator unabhängig von der Reihenfolge arbeiten muss, in der der Vektor und der Skalar angezeigt werden.
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()