Symbol- und Operatorenreferenz (F#)

Dieses Thema enthält eine Tabelle mit Symbolen und Operatoren, die in der Sprache F# verwendet werden.

Tabelle der Symbole und Operatoren

In der folgenden Tabelle werden die in der Sprache F# verwendeten Symbole beschrieben; sie enthält zudem Links zu Themen, die weitere Informationen enthalten, und eine kurze Beschreibung für einige Verwendungszwecke des Symbols. Symbole sind nach dem ASCII-Zeichensatz sortiert.

Symbol oder Operator	Links	Beschreibung
!	Referenzzellen (F#) Berechnungsausdrücke (F#)	Dereferenziert eine Verweiszelle. Nach einem Schlüsselwort weist dies auf eine geänderte Version des von einem Workflow gesteuerten Verhaltens des Schlüsselworts hin.
!=	Nicht zutreffend.	Nicht in F# verwendet. Verwenden Sie <> für Ungleichheitsoperationen.
"	Literale (F#) Zeichenfolgen (F#)	Begrenzt eine Textzeichenfolge.
"""	Zeichenfolgen (F#)	Begrenzt eine wörtliche Textzeichenfolge. Unterscheidet sich insofern von @"...", dass Sie mit einem einfachen Anführungszeichen in der Zeichenfolge ein Anführungszeichen angeben können.
#	Compilerdirektiven (F#) Flexible Typen (F#)	Präfix für eine Präprozessor- oder Compilerdirektive, z. B. #light. Gibt bei Verwendung mit einem Typ einen flexiblen Typ an, der auf einen Typ oder einen seiner abgeleiteten Typen verweist.
$	Es sind keine weiteren Informationen verfügbar.	Wird intern für bestimmte vom Compiler generierte Variablen- und Funktionsnamen verwendet.
%	Arithmetische Operatoren (F#) Zitieren von Code (F#)	Berechnet den ganzzahligen Modulo. Wird beim Splicing von Ausdrücken in typisierte Codequotationen verwendet.
%%	Zitieren von Code (F#)	Wird beim Splicing von Ausdrücken in nicht typisierte Codequotationen verwendet.
%?	Operatoren, die NULL-Werte zulassen (F#)	Berechnet den ganzzahligen Modulo, wenn die rechte Seite ein Typ ist, der einen Null-Wert zulässt.
&	Vergleichsausdrücke (F#)	Berechnet die Adresse eines änderbaren Werts, der bei der Interoperation mit anderen Sprachen verwendet werden kann. Wird in AND-Mustern verwendet.
&&	Boolesche Operatoren (F#)	Berechnet die boolesche AND-Operation.
&&&	Bitweise Operatoren (F#)	Berechnet die bitweise AND-Operation.
'	Literale (F#) Automatische Verallgemeinerung (F#)	Begrenzt ein Literal mit einem Zeichen. Gibt einen generischen Typparameter an.
``...``	Es sind keine weiteren Informationen verfügbar.	Begrenzt einen Bezeichner, der ansonsten kein gültiger Bezeichner wäre, z. B. ein Sprachschlüsselwort.
( )	Unit-Typ (F#)	Stellt den einzelnen Wert des Einheitentyps dar.
(...)	Tupel (F#) Überladen von Operatoren (F#)	Gibt die Reihenfolge an, in der Ausdrücke ausgewertet werden. Begrenzt ein Tupel. Wird in Operatordefinitionen verwendet.
(*...*)		Begrenzt einen Kommentar, der mehrere Zeilen umfassen kann.
(|...|)	Aktive Muster (F#)	Begrenzt ein aktives Muster. Wird auch als Bananenklammern bezeichnet.
*	Arithmetische Operatoren (F#) Tupel (F#) Maßeinheiten (F#)	Bei Verwendung als binärer Operator wird die linke mit der rechten Seite multipliziert. Gibt in Typen die Paarung in einem Tupel an. Wird in Maßeinheittypen verwendet.
*?	Operatoren, die NULL-Werte zulassen (F#)	Multipliziert die linke mit der rechten Seite, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
**	Arithmetische Operatoren (F#)	Berechnet die Potenzierung (x ** y steht für x potenziert mit y).
+	Arithmetische Operatoren (F#)	Bei Verwendung als binärer Operator werden die linke und die rechte Seite addiert. Gibt bei Verwendung als unärer Operator eine positive Menge an. (Formell erzeugt es den gleichen Wert bei unverändertem Vorzeichen.)
+?	Operatoren, die NULL-Werte zulassen (F#)	Addiert die linke und die rechte Seite, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
,	Tupel (F#)	Trennt die Elemente eines Tupels oder Typparameters.
-	Arithmetische Operatoren (F#)	Bei Verwendung als binärer Operator wird rechte Seite von der linken subtrahiert. Führt bei Verwendung als unärer Operator eine Negationsoperation aus.
-	Operatoren, die NULL-Werte zulassen (F#)	Subtrahiert die rechte Seite von der linken, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
->	Funktionen (F#) Vergleichsausdrücke (F#)	Begrenzt bei Funktionstypen die Argumente und Rückgabewerte. Ergibt einen Ausdruck (in Sequenzausdrücken); entspricht dem yield-Schlüsselwort. Wird in Übereinstimmungsausdrücken verwendet.
.	Member (F#) Primitive Typen (F#)	Greift auf einen Member zu und trennt einzelne Namen in einem vollqualifizierten Namen. Gibt ein Dezimaltrennzeichen in Gleitkommazahlen an.
..	Schleifen: for...in-Ausdruck (F#)	Gibt einen Bereich an.
.. ..	Schleifen: for...in-Ausdruck (F#)	Gibt einen Bereich zusammen mit einem Inkrement an.
.[...]	Arrays (F#)	Greift auf ein Arrayelement zu.
/	Arithmetische Operatoren (F#) Maßeinheiten (F#)	Dividiert die linke Seite (Zähler) durch die rechte Seite (Nenner). Wird in Maßeinheittypen verwendet.
/?	Operatoren, die NULL-Werte zulassen (F#)	Dividiert die linke Seite durch die rechte, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
//		Gibt den Anfang eines einzeiligen Kommentars an.
///	XML-Dokumentation (F#)	Gibt einen XML-Kommentar an.
:	Funktionen (F#)	Trennt in einer Typanmerkung einen Parameter- oder Membernamen vom Typ.
::	Listen (F#) Vergleichsausdrücke (F#)	Erstellt eine Liste. Das Element auf der linken Seite wird an die Liste auf der rechten Seite angefügt. Wird im Mustervergleich verwendet, um die Teile einer Liste zu trennen.
:=	Referenzzellen (F#)	Weist einer Verweiszelle einen Wert zu.
:>	Umwandlung und Konvertierungen (F#)	Konvertiert einen Typen in einen Typen, der in der Hierarchie höher ist.
:?	Vergleichsausdrücke (F#)	Gibt true zurück, wenn der Wert dem angegebenen Typen entspricht; andernfalls wird false zurückgegeben (Typtestoperator).
:?>	Umwandlung und Konvertierungen (F#)	Konvertiert einen Typen in einen Typen, der in der Hierarchie weiter unten ist.
;	Ausführliche Syntax (F#) Listen (F#) Datensätze (F#)	Trennt Ausdrücke (meist in ausführlicher Syntax verwendet). Trennt Elemente einer Liste. Trennt Felder eines Datensatzes.
<	Arithmetische Operatoren (F#)	Berechnet die Kleiner-als-Operation.
<?	Operatoren, die NULL-Werte zulassen (F#)	Berechnet die "kleiner als"-Operation, wenn die rechte Seite ein Typ ist, der einen Null-Wert zulässt.
<<	Funktionen (F#)	Verfasst zwei Funktionen in umgekehrter Reihenfolge, d. h., die zweite Funktion wird zuerst ausgeführt (Rückwärtskompositionsoperator).
<<<	Bitweise Operatoren (F#)	Verschiebt Bits in der Menge auf der linken Seite um die Anzahl der Bits nach links, die auf der rechten Seite angegeben wurde.
<-	Werte (F#)	Weist einer Variablen einen Wert zu.
<...>	Automatische Verallgemeinerung (F#)	Begrenzt Typparameter.
<>	Arithmetische Operatoren (F#)	Gibt true zurück, wenn die linke Seite nicht gleich der rechten Seite ist; andernfalls wird "false" zurückgegeben.
<>?	Operatoren, die NULL-Werte zulassen (F#)	Berechnet die "nicht gleich"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
<=	Arithmetische Operatoren (F#)	Gibt true zurück, wenn die linke Seite kleiner gleich die rechte Seite ist; andernfalls wird "false" zurückgegeben.
<=?	Operatoren, die NULL-Werte zulassen (F#)	Berechnet die "kleiner gleich"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
<|	Funktionen (F#)	Übergibt das Ergebnis des Ausdrucks auf der rechten Seite an die Funktion auf der linken Seite (Rückwärtspipeoperator).
<||	Operators.( <|| )<'T1,'T2,'U>-Funktion (F#)	Übergibt das Tupel aus zwei Argumenten auf der rechten Seite an die Funktion auf der linken Seite.
<|||	Operators.( <||| )<'T1,'T2,'T3,'U>-Funktion (F#)	Übergibt das Tupel aus drei Argumenten auf der rechten Seite an die Funktion auf der linken Seite.
<@...@>	Zitieren von Code (F#)	Begrenzt eine typisierte Codequotation.
<@@...@@>	Zitieren von Code (F#)	Begrenzt eine nicht typisierte Codequotation.
=	Arithmetische Operatoren (F#)	Gibt true zurück, wenn die linke Seite gleich der rechten Seite ist; andernfalls wird "false" zurückgegeben.
=?	Operatoren, die NULL-Werte zulassen (F#)	Berechnet die "gleich"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
==	Nicht zutreffend.	Nicht in F# verwendet. Verwenden Sie = für Gleichheitsoperationen.
>	Arithmetische Operatoren (F#)	Gibt true zurück, wenn die linke Seite größer als die rechte Seite ist; andernfalls wird "false" zurückgegeben.
>?	Operatoren, die NULL-Werte zulassen (F#)	Berechnet die "größer als"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
>>	Funktionen (F#)	Verfasst zwei Funktionen (Vorwärtskompositionsoperator).
>>>	Bitweise Operatoren (F#)	Verschiebt Bits in der Menge auf der linken Seite um die Anzahl der Bits nach rechts, die auf der rechten Seite angegeben wurde.
>=	Arithmetische Operatoren (F#)	Gibt true zurück, wenn die rechte Seite größer gleich der linken Seite ist; andernfalls wird "false" zurückgegeben.
>=?	Operatoren, die NULL-Werte zulassen (F#)	Berechnet die "größer gleich"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
?	Parameter und Argumente (F#)	Gibt ein optionales Argument an. Wird als Operator für dynamische Methoden- und Eigenschaftenaufrufe verwendet. Sie müssen Ihre eigene Implementierung bereitstellen.
? ... <- ...	Es sind keine weiteren Informationen verfügbar.	Wird als Operator zum Festlegen von dynamischen Eigenschaften verwendet. Sie müssen Ihre eigene Implementierung bereitstellen.
?>=, ?>, ?<=, ?<, ?=, ?<>, ?+, ?-, ?*, ?/	Operatoren, die NULL-Werte zulassen (F#)	Entspricht den jeweiligen Operatoren ohne das ? Präfix, wobei sich links ein Typ befindet, der Null-Werte zulässt.
>=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /?	Operatoren, die NULL-Werte zulassen (F#)	Entspricht den jeweiligen Operatoren ohne das ? Suffix, wobei sich rechts ein Typ befindet, der Null-Werte zulässt.
?>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/?	Operatoren, die NULL-Werte zulassen (F#)	Entspricht den jeweiligen Operatoren ohne die umgebenden Fragezeichen, wobei sich auf beiden Seiten Typen befinden, die Null-Werte zulassen.
@	Listen (F#) Zeichenfolgen (F#)	Verkettet zwei Listen. Wenn es vor einem Zeichenfolgenliteral platziert wird, gibt dies an, dass die Zeichenfolge wörtlich interpretiert werden kann, ohne die Escapezeichen zu interpretieren.
[...]	Listen (F#)	Begrenzt die Elemente einer Liste.
[|...|]	Arrays (F#)	Begrenzt die Elemente eines Arrays.
[<...>]	Attribute (F#)	Begrenzt ein Attribut.
\	Zeichenfolgen (F#)	Versieht das nächste Zeichen mit einem Escapezeichen; wird in Zeichen- und Zeichenfolgenliteralen verwendet.
^	Statisch aufgelöste Typparameter (F#) Zeichenfolgen (F#)	Gibt die Typparameter an, die zum Zeitpunkt der Kompilierung, nicht zur Laufzeit aufgelöst werden müssen. Verkettet Zeichenfolgen.
^^^	Bitweise Operatoren (F#)	Berechnet die bitweise XOR-Operation.
_	Vergleichsausdrücke (F#) Generika (F#)	Gibt ein Platzhaltermuster an. Gibt einen anonymen generischen Parameter an.
`	Automatische Verallgemeinerung (F#)	Wird intern verwendet, um einen generischen Typparameter anzugeben.
{...}	Sequenzen (F#) Datensätze (F#)	Begrenzt Sequenzausdrücke und Berechnungsausdrücke. Wird in Datensatzdefinitionen verwendet.
|	Vergleichsausdrücke (F#)	Begrenzt einzelne Übereinstimmungsfälle, einzelne diskriminierte Union-Fälle und Enumerationswerte.
||	Boolesche Operatoren (F#)	Berechnet die boolesche OR-Operation.
|||	Bitweise Operatoren (F#)	Berechnet die bitweise OR-Operation.
|>	Funktionen (F#)	Übergibt das Ergebnis der linken Seite an die Funktion auf der rechten Seite (Vorwärtspipeoperator).
||>	Operators.( ||> )<'T1,'T2,'U>-Funktion (F#)	Übergibt das Tupel aus zwei Argumenten auf der linken Seite an die Funktion auf der rechten Seite.
|||>	Operators.( |||> )<'T1,'T2,'T3,'U>-Funktion (F#)	Übergibt das Tupel aus drei Argumenten auf der linken Seite an die Funktion auf der rechten Seite.
~~	Überladen von Operatoren (F#)	Wird verwendet, um eine Überladung für den unären Negationsoperator zu deklarieren.
~~~	Bitweise Operatoren (F#)	Berechnet die bitweise NOT-Operation.
~-	Überladen von Operatoren (F#)	Wird verwendet, um eine Überladung für den unären Minusoperator zu deklarieren.
~+	Überladen von Operatoren (F#)	Wird verwendet, um eine Überladung für den unären Plusoperator zu deklarieren.

Operatorrangfolge

Die folgende Tabelle zeigt die Rangreihenfolge der Operatoren und anderer Ausdrucksschlüsselwörter in der F#-Sprache, von der niedrigsten Rangfolge bis zur höchsten Rangfolge. Ggf. wird auch die Assoziativität aufgeführt.

Operator	Assoziativität
as	Rechts
when	Rechts
| (Pipe)	Links
;	Rechts
let	Nicht assoziativ
function, fun, match, try	Nicht assoziativ
if	Nicht assoziativ
->	Rechts
:=	Rechts
,	Nicht assoziativ
or, ||	Links
&, &&	Links
<op, >op, =, |op, &op	Links
&&&, |||, ^^^, ~~~, <<<, >>>	Links
^op	Rechts
::	Rechts
:?>, :?	Nicht assoziativ
-op, +op, (binär)	Links
*op, /op, %op	Links
**op	Rechts
f x (Funktionsanwendung)	Links
| (Musterübereinstimmung)	Rechts
Präfixoperatoren (+op, -op, %, %%, &, &&, !op, ~op)	Links
.	Links
f(x)	Links
f<types>	Links

F# unterstützt die benutzerdefinierte Operatorüberladung. Dies bedeutet, dass Sie eigene Operatoren definieren können. In der vorherigen Tabelle kann op eine beliebige gültige (möglicherweise leere) Sequenz von integrierten oder benutzerdefinierten Operatorzeichen sein. Mit dieser Tabelle können Sie daher bestimmen, welche Sequenz von Zeichen für einen benutzerdefinierten Operator verwendet werden muss, um die gewünschte Rangfolge zu erhalten. Vorangestellte .-Zeichen werden ignoriert, wenn der Compiler die Rangfolge bestimmt.

Siehe auch

Referenz

Überladen von Operatoren (F#)

Weitere Ressourcen

F#-Sprachreferenz