Symbol- und OperatorenreferenzSymbol and Operator Reference

Hinweis

Mit dem API-Referenz-Link in diesem Artikel gelangen Sie auf MSDN.The API reference links in this article will take you to MSDN. Die docs.microsoft.com-API-Referenz ist nicht abgeschlossen.The docs.microsoft.com API reference is not complete.

Dieses Thema enthält eine Tabelle mit Symbolen und Operatoren, die in der Sprache F# verwendet werden.This topic includes a table of symbols and operators that are used in the F# language.

Tabelle der Symbole und OperatorenTable of Symbols and Operators

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.The following table describes symbols used in the F# language, provides links to topics that provide more information, and provides a brief description of some of the uses of the symbol. Symbole sind nach dem ASCII-Zeichensatz sortiert.Symbols are ordered according to the ASCII character set ordering.

Symbol oder OperatorSymbol or operator LinksLinks BeschreibungDescription
! ReferenzzellenReference Cells

BerechnungsausdrückeComputation Expressions
  • Dereferenziert eine Verweiszelle.Dereferences a reference cell.
  • Nach einem Schlüsselwort weist dies auf eine geänderte Version des von einem Workflow gesteuerten Verhaltens des Schlüsselworts hin.After a keyword, indicates a modified version of the keyword's behavior as controlled by a workflow.
    != Nicht zutreffend.Not applicable.
    • Nicht in F# verwendet.Not used in F#. Verwenden Sie <> für Ungleichheitsoperationen.Use <> for inequality operations.
      " LiteraleLiterals

      ZeichenfolgenStrings
      • Begrenzt eine Textzeichenfolge.Delimits a text string.
        """ ZeichenfolgenStrings Begrenzt eine wörtliche Textzeichenfolge.Delimits a verbatim text string. Unterscheidet sich insofern von @"...", dass Sie mit einem einfachen Anführungszeichen in der Zeichenfolge ein Anführungszeichen angeben können.Differs from @"..." in that a you can indicate a quotation mark character by using a single quote in the string.
        # CompileranweisungenCompiler Directives

        Flexible TypenFlexible Types
        • Präfix für eine Präprozessor- oder Compilerdirektive, z. B. #light.Prefixes a preprocessor or compiler directive, such as #light.
        • Gibt bei Verwendung mit einem Typ einen flexiblen Typ an, der auf einen Typ oder einen seiner abgeleiteten Typen verweist.When used with a type, indicates a flexible type, which refers to a type or any one of its derived types.
          $ Es sind keine weiteren Informationen verfügbar.No more information available.
          • Wird intern für bestimmte vom Compiler generierte Variablen- und Funktionsnamen verwendet.Used internally for certain compiler-generated variable and function names.
            % Arithmetische OperatorenArithmetic Operators

            Zitieren von CodeCode Quotations
            • Berechnet den ganzzahligen Modulo.Computes the integer modulus.
            • Wird beim Splicing von Ausdrücken in typisierte Codequotationen verwendet.Used for splicing expressions into typed code quotations.
              %% Zitieren von CodeCode Quotations
              • Wird beim Splicing von Ausdrücken in nicht typisierte Codequotationen verwendet.Used for splicing expressions into untyped code quotations.
                %? Operatoren, die NULL-Werte zulassenNullable Operators
                • Berechnet den ganzzahligen Modulo, wenn die rechte Seite ein Typ ist, der einen Null-Wert zulässt.Computes the integer modulus, when the right side is a nullable type.
                  & VergleichsausdrückeMatch Expressions
                  • Berechnet die Adresse eines änderbaren Werts, der bei der Interoperation mit anderen Sprachen verwendet werden kann.Computes the address of a mutable value, for use when interoperating with other languages.
                  • Wird in AND-Mustern verwendet.Used in AND patterns.
                    && Boolesche OperatorenBoolean Operators
                    • Berechnet die boolesche AND-Operation.Computes the Boolean AND operation.
                      &&& Bitweise OperatorenBitwise Operators
                      • Berechnet die bitweise AND-Operation.Computes the bitwise AND operation.
                        ' LiteraleLiterals

                        Automatische VerallgemeinerungAutomatic Generalization
                        • Begrenzt ein Literal mit einem Zeichen.Delimits a single-character literal.
                        • Gibt einen generischen Typparameter an.Indicates a generic type parameter.
                          ``...`` Es sind keine weiteren Informationen verfügbar.No more information available.
                          • Begrenzt einen Bezeichner, der ansonsten kein gültiger Bezeichner wäre, z. B. ein Sprachschlüsselwort.Delimits an identifier that would otherwise not be a legal identifier, such as a language keyword.
                            ( ) Unit-TypUnit Type
                            • Stellt den einzelnen Wert des Einheitentyps dar.Represents the single value of the unit type.
                              (...) TupelTuples

                              OperatorüberladungOperator Overloading
                              • Gibt die Reihenfolge an, in der Ausdrücke ausgewertet werden.Indicates the order in which expressions are evaluated.
                              • Begrenzt ein Tupel.Delimits a tuple.
                              • Wird in Operatordefinitionen verwendet.Used in operator definitions.
                                (*...*)
                                • Begrenzt einen Kommentar, der mehrere Zeilen umfassen kann.Delimits a comment that could span multiple lines.
                                  (|...|) Aktive MusterActive Patterns
                                  • Begrenzt ein aktives Muster.Delimits an active pattern. Wird auch als Bananenklammern bezeichnet.Also called banana clips.
                                    * Arithmetische OperatorenArithmetic Operators

                                    TupelTuples

                                    MaßeinheitenUnits of Measure
                                    • Bei Verwendung als binärer Operator wird die linke mit der rechten Seite multipliziert.When used as a binary operator, multiplies the left and right sides.
                                    • Gibt in Typen die Paarung in einem Tupel an.In types, indicates pairing in a tuple.
                                    • Wird in Maßeinheittypen verwendet.Used in units of measure types.
                                      *? Operatoren, die NULL-Werte zulassenNullable Operators
                                      • Multipliziert die linke mit der rechten Seite, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.Multiplies the left and right sides, when the right side is a nullable type.
                                        ** Arithmetische OperatorenArithmetic Operators
                                        • Berechnet die Potenzierung (x ** y steht für x potenziert mit y).Computes the exponentiation operation (x ** y means x to the power of y).
                                          + Arithmetische OperatorenArithmetic Operators
                                          • Bei Verwendung als binärer Operator werden die linke und die rechte Seite addiert.When used as a binary operator, adds the left and right sides.
                                          • Gibt bei Verwendung als unärer Operator eine positive Menge an.When used as a unary operator, indicates a positive quantity. (Formell erzeugt es den gleichen Wert bei unverändertem Vorzeichen.)(Formally, it produces the same value with the sign unchanged.)
                                            +? Operatoren, die NULL-Werte zulassenNullable Operators
                                            • Addiert die linke und die rechte Seite, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.Adds the left and right sides, when the right side is a nullable type.
                                              , TupelTuples
                                              • Trennt die Elemente eines Tupels oder Typparameters.Separates the elements of a tuple, or type parameters.
                                                - Arithmetische OperatorenArithmetic Operators
                                                • Bei Verwendung als binärer Operator wird rechte Seite von der linken subtrahiert.When used as a binary operator, subtracts the right side from the left side.
                                                • Führt bei Verwendung als unärer Operator eine Negationsoperation aus.When used as a unary operator, performs a negation operation.
                                                  - Operatoren, die NULL-Werte zulassenNullable Operators
                                                  • Subtrahiert die rechte Seite von der linken, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.Subtracts the right side from the left side, when the right side is a nullable type.
                                                    -> FunktionenFunctions

                                                    VergleichsausdrückeMatch Expressions
                                                    • Begrenzt bei Funktionstypen die Argumente und Rückgabewerte.In function types, delimits arguments and return values.
                                                    • Ergibt einen Ausdruck (in Sequenzausdrücken); entspricht dem yield-Schlüsselwort.Yields an expression (in sequence expressions); equivalent to the yield keyword.
                                                    • Wird in Übereinstimmungsausdrücken verwendet.Used in match expressions
                                                      . MitgliederMembers

                                                      Primitive TypenPrimitive Types
                                                      • Greift auf einen Member zu und trennt einzelne Namen in einem vollqualifizierten Namen.Accesses a member, and separates individual names in a fully qualified name.
                                                      • Gibt ein Dezimaltrennzeichen in Gleitkommazahlen an.Specifies a decimal point in floating point numbers.
                                                        .. Schleifen: for...in-AusdruckLoops: for...in Expression
                                                        • Gibt einen Bereich an.Specifies a range.
                                                          .. .. Schleifen: for...in-AusdruckLoops: for...in Expression
                                                          • Gibt einen Bereich zusammen mit einem Inkrement an.Specifies a range together with an increment.
                                                            .[...] ArraysArrays
                                                            • Greift auf ein Arrayelement zu.Accesses an array element.
                                                              / Arithmetische OperatorenArithmetic Operators

                                                              MaßeinheitenUnits of Measure
                                                              • Dividiert die linke Seite (Zähler) durch die rechte Seite (Nenner).Divides the left side (numerator) by the right side (denominator).
                                                              • Wird in Maßeinheittypen verwendet.Used in units of measure types.
                                                                /? Operatoren, die NULL-Werte zulassenNullable Operators
                                                                • Dividiert die linke Seite durch die rechte, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.Divides the left side by the right side, when the right side is a nullable type.
                                                                  //
                                                                  • Gibt den Anfang eines einzeiligen Kommentars an.Indicates the beginning of a single-line comment.
                                                                    /// XML-DokumentationXML Documentation
                                                                    • Gibt einen XML-Kommentar an.Indicates an XML comment.
                                                                      : FunktionenFunctions
                                                                      • Trennt in einer Typanmerkung einen Parameter- oder Membernamen vom Typ.In a type annotation, separates a parameter or member name from its type.
                                                                        :: ListenLists

                                                                        VergleichsausdrückeMatch Expressions
                                                                        • Erstellt eine Liste.Creates a list. Das Element auf der linken Seite wird der Liste auf der rechten Seite vorangestellt.The element on the left side is prepended to the list on the right side.
                                                                        • Wird im Musterabgleich verwendet, um die Teile einer Liste zu trennen.Used in pattern matching to separate the parts of a list.
                                                                          := ReferenzzellenReference Cells
                                                                          • Weist einer Verweiszelle einen Wert zu.Assigns a value to a reference cell.
                                                                            :> Umwandlung und KonvertierungenCasting and Conversions
                                                                            • Konvertiert einen Typen in einen Typen, der in der Hierarchie höher ist.Converts a type to type that is higher in the hierarchy.
                                                                              :? VergleichsausdrückeMatch Expressions
                                                                              • Gibt true zurück, wenn der Wert dem angegebenen Typen entspricht; andernfalls wird false zurückgegeben (Typtestoperator).Returns true if the value matches the specified type; otherwise, returns false (type test operator).
                                                                                :?> Umwandlung und KonvertierungenCasting and Conversions
                                                                                • Konvertiert einen Typen in einen Typen, der in der Hierarchie weiter unten ist.Converts a type to a type that is lower in the hierarchy.
                                                                                  ; Ausführliche SyntaxVerbose Syntax

                                                                                  ListenLists

                                                                                  DatensätzeRecords
                                                                                  • Trennt Ausdrücke (meist in ausführlicher Syntax verwendet).Separates expressions (used mostly in verbose syntax).
                                                                                  • Trennt Elemente einer Liste.Separates elements of a list.
                                                                                  • Trennt Felder eines Datensatzes.Separates fields of a record.
                                                                                    < Arithmetische OperatorenArithmetic Operators
                                                                                    • Berechnet die Kleiner-als-Operation.Computes the less-than operation.
                                                                                      <? Operatoren, die NULL-Werte zulassenNullable Operators Berechnet die "kleiner als"-Operation, wenn die rechte Seite ein Typ ist, der einen Null-Wert zulässt.Computes the less than operation, when the right side is a nullable type.
                                                                                      << FunktionenFunctions
                                                                                      • Verfasst zwei Funktionen in umgekehrter Reihenfolge, d. h., die zweite Funktion wird zuerst ausgeführt (Rückwärtskompositionsoperator).Composes two functions in reverse order; the second one is executed first (backward composition operator).
                                                                                        <<< Bitweise OperatorenBitwise Operators
                                                                                        • Verschiebt Bits in der Menge auf der linken Seite um die Anzahl der Bits nach links, die auf der rechten Seite angegeben wurde.Shifts bits in the quantity on the left side to the left by the number of bits specified on the right side.
                                                                                          <- WerteValues
                                                                                          • Weist einer Variablen einen Wert zu.Assigns a value to a variable.
                                                                                            <...> Automatische VerallgemeinerungAutomatic Generalization
                                                                                            • Begrenzt Typparameter.Delimits type parameters.
                                                                                              <> Arithmetische OperatorenArithmetic Operators
                                                                                              • Gibt true zurück, wenn die linke Seite nicht gleich der rechten Seite ist; andernfalls wird "false" zurückgegeben.Returns true if the left side is not equal to the right side; otherwise, returns false.
                                                                                                <>? Operatoren, die NULL-Werte zulassenNullable Operators
                                                                                                • Berechnet die "nicht gleich"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.Computes the "not equal" operation when the right side is a nullable type.
                                                                                                  <= Arithmetische OperatorenArithmetic Operators
                                                                                                  • Gibt true zurück, wenn die linke Seite kleiner gleich die rechte Seite ist; andernfalls wird false zurückgegeben.Returns true if the left side is less than or equal to the right side; otherwise, returns false.
                                                                                                    <=? Operatoren, die NULL-Werte zulassenNullable Operators
                                                                                                    • Berechnet die "kleiner gleich"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.Computes the "less than or equal to" operation when the right side is a nullable type.
                                                                                                      <| FunktionenFunctions
                                                                                                      • Übergibt das Ergebnis des Ausdrucks auf der rechten Seite an die Funktion auf der linken Seite (Rückwärtspipeoperator).Passes the result of the expression on the right side to the function on left side (backward pipe operator).
                                                                                                        <|| Operatoren.( <|| )<'T1,'T2,'U> FunktionOperators.( <|| )<'T1,'T2,'U> Function
                                                                                                        • Übergibt das Tupel aus zwei Argumenten auf der rechten Seite an die Funktion auf der linken Seite.Passes the tuple of two arguments on the right side to the function on left side.
                                                                                                          <||| Operatoren.( <||| )<'T1,'T2,'T3,'U> FunktionOperators.( <||| )<'T1,'T2,'T3,'U> Function
                                                                                                          • Übergibt das Tupel aus drei Argumenten auf der rechten Seite an die Funktion auf der linken Seite.Passes the tuple of three arguments on the right side to the function on left side.
                                                                                                            <@...@> Zitieren von CodeCode Quotations
                                                                                                            • Begrenzt eine typisierte Codequotation.Delimits a typed code quotation.
                                                                                                              <@@...@@> Zitieren von CodeCode Quotations
                                                                                                              • Begrenzt eine nicht typisierte Codequotation.Delimits an untyped code quotation.
                                                                                                                = Arithmetische OperatorenArithmetic Operators
                                                                                                                • Gibt true zurück, wenn die linke Seite gleich der rechten Seite ist; andernfalls wird false zurückgegeben.Returns true if the left side is equal to the right side; otherwise, returns false.
                                                                                                                  =? Operatoren, die NULL-Werte zulassenNullable Operators
                                                                                                                  • Berechnet die "gleich"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.Computes the "equal" operation when the right side is a nullable type.
                                                                                                                    == Nicht zutreffend.Not applicable.
                                                                                                                    • Nicht in F# verwendet.Not used in F#. Verwenden Sie = für Gleichheitsoperationen.Use = for equality operations.
                                                                                                                      > Arithmetische OperatorenArithmetic Operators
                                                                                                                      • Gibt true zurück, wenn die linke Seite größer als die rechte Seite ist; andernfalls wird false zurückgegeben.Returns true if the left side is greater than the right side; otherwise, returns false.
                                                                                                                        >? Operatoren, die NULL-Werte zulassenNullable Operators
                                                                                                                        • Berechnet die "größer als"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.Computes the "greather than" operation when the right side is a nullable type.
                                                                                                                          >> FunktionenFunctions
                                                                                                                          • Verfasst zwei Funktionen (Vorwärtskompositionsoperator).Composes two functions (forward composition operator).
                                                                                                                            >>> Bitweise OperatorenBitwise Operators
                                                                                                                            • Verschiebt Bits in der Menge auf der linken Seite um die Anzahl der Bits nach rechts, die auf der rechten Seite angegeben wurde.Shifts bits in the quantity on the left side to the right by the number of places specified on the right side.
                                                                                                                              >= Arithmetische OperatorenArithmetic Operators
                                                                                                                              • Gibt true ist die linke Seite größer als oder gleich der rechten Seite ist; andernfalls gibt false.Returns true if the left side is greater than or equal to the right side; otherwise, returns false.
                                                                                                                                >=? Operatoren, die NULL-Werte zulassenNullable Operators
                                                                                                                                • Berechnet die "größer gleich"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.Computes the "greater than or equal" operation when the right side is a nullable type.
                                                                                                                                  ? Parameter und ArgumenteParameters and Arguments
                                                                                                                                  • Gibt ein optionales Argument an.Specifies an optional argument.
                                                                                                                                  • Wird als Operator für dynamische Methoden- und Eigenschaftenaufrufe verwendet.Used as an operator for dynamic method and property calls. Sie müssen Ihre eigene Implementierung bereitstellen.You must provide your own implementation.
                                                                                                                                    ? ... <- ... Es sind keine weiteren Informationen verfügbar.No more information available.
                                                                                                                                    • Wird als Operator zum Festlegen von dynamischen Eigenschaften verwendet.Used as an operator for setting dynamic properties. Sie müssen Ihre eigene Implementierung bereitstellen.You must provide your own implementation.
                                                                                                                                      ?>=, ?>, ?<=, ?<, ?=, ?<>, ?+, ?-, ?*, ?/?>=, ?>, ?<=, ?<, ?=, ?<>, ?+, ?-, ?*, ?/ Operatoren, die NULL-Werte zulassenNullable Operators
                                                                                                                                      • Entspricht den jeweiligen Operatoren ohne das ?Equivalent to the corresponding operators without the ? Präfix, wobei sich links ein Typ befindet, der Null-Werte zulässt.prefix, where a nullable type is on the left.
                                                                                                                                        >=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /?>=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /? Operatoren, die NULL-Werte zulassenNullable Operators
                                                                                                                                        • Entspricht den jeweiligen Operatoren ohne das ?Equivalent to the corresponding operators without the ? Suffix, wobei sich rechts ein Typ befindet, der Null-Werte zulässt.suffix, where a nullable type is on the right.
                                                                                                                                          ?>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/??>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/? Operatoren, die NULL-Werte zulassenNullable Operators
                                                                                                                                          • Entspricht den jeweiligen Operatoren ohne die umgebenden Fragezeichen, wobei sich auf beiden Seiten Typen befinden, die Null-Werte zulassen.Equivalent to the corresponding operators without the surrounding question marks, where both sides are nullable types.
                                                                                                                                            @ ListenLists

                                                                                                                                            ZeichenfolgenStrings
                                                                                                                                            • Verkettet zwei Listen.Concatenates two lists.
                                                                                                                                            • Wenn es vor einem Zeichenfolgenliteral platziert wird, gibt dies an, dass die Zeichenfolge wörtlich interpretiert werden kann, ohne die Escapezeichen zu interpretieren.When placed before a string literal, indicates that the string is to be interpreted verbatim, with no interpretation of escape characters.
                                                                                                                                              [...] ListenLists
                                                                                                                                              • Begrenzt die Elemente einer Liste.Delimits the elements of a list.
                                                                                                                                                [|...|] ArraysArrays
                                                                                                                                                • Begrenzt die Elemente eines Arrays.Delimits the elements of an array.
                                                                                                                                                  [<...>] AttributeAttributes
                                                                                                                                                  • Begrenzt ein Attribut.Delimits an attribute.
                                                                                                                                                    \ ZeichenfolgenStrings
                                                                                                                                                    • Versieht das nächste Zeichen mit einem Escapezeichen; wird in Zeichen- und Zeichenfolgenliteralen verwendet.Escapes the next character; used in character and string literals.
                                                                                                                                                      ^ Statisch aufgelöste TypparameterStatically Resolved Type Parameters

                                                                                                                                                      ZeichenfolgenStrings
                                                                                                                                                      • Gibt die Typparameter an, die zum Zeitpunkt der Kompilierung, nicht zur Laufzeit aufgelöst werden müssen.Specifies type parameters that must be resolved at compile time, not at runtime.
                                                                                                                                                      • Verkettet Zeichenfolgen.Concatenates strings.
                                                                                                                                                        ^^^ Bitweise OperatorenBitwise Operators
                                                                                                                                                        • Berechnet die bitweise XOR-Operation.Computes the bitwise exclusive OR operation.
                                                                                                                                                          _ VergleichsausdrückeMatch Expressions

                                                                                                                                                          GenerikaGenerics
                                                                                                                                                          • Gibt ein Platzhaltermuster an.Indicates a wildcard pattern.
                                                                                                                                                          • Gibt einen anonymen generischen Parameter an.Specifies an anonymous generic parameter.
                                                                                                                                                            ` Automatische VerallgemeinerungAutomatic Generalization
                                                                                                                                                            • Wird intern verwendet, um einen generischen Typparameter anzugeben.Used internally to indicate a generic type parameter.
                                                                                                                                                              {...} SequenzenSequences

                                                                                                                                                              DatensätzeRecords
                                                                                                                                                              • Begrenzt Sequenzausdrücke und Berechnungsausdrücke.Delimits sequence expressions and computation expressions.
                                                                                                                                                              • Wird in Datensatzdefinitionen verwendet.Used in record definitions.
                                                                                                                                                                | VergleichsausdrückeMatch Expressions
                                                                                                                                                                • Begrenzt einzelne Übereinstimmungsfälle, einzelne diskriminierte Union-Fälle und Enumerationswerte.Delimits individual match cases, individual discriminated union cases, and enumeration values.
                                                                                                                                                                  || Boolesche OperatorenBoolean Operators
                                                                                                                                                                  • Berechnet die boolesche OR-Operation.Computes the Boolean OR operation.
                                                                                                                                                                    ||| Bitweise OperatorenBitwise Operators
                                                                                                                                                                    • Berechnet die bitweise OR-Operation.Computes the bitwise OR operation.
                                                                                                                                                                      |> FunktionenFunctions
                                                                                                                                                                      • Übergibt das Ergebnis der linken Seite an die Funktion auf der rechten Seite (Vorwärtspipeoperator).Passes the result of the left side to the function on the right side (forward pipe operator).
                                                                                                                                                                        ||> Operatoren.( ||> )<'T1,'T2,'U> FunktionOperators.( ||> )<'T1,'T2,'U> Function
                                                                                                                                                                        • Übergibt das Tupel aus zwei Argumenten auf der linken Seite an die Funktion auf der rechten Seite.Passes the tuple of two arguments on the left side to the function on the right side.
                                                                                                                                                                          |||> Operatoren.( |||> )<'T1,'T2,'T3,'U> FunktionOperators.( |||> )<'T1,'T2,'T3,'U> Function
                                                                                                                                                                          • Übergibt das Tupel aus drei Argumenten auf der linken Seite an die Funktion auf der rechten Seite.Passes the tuple of three arguments on the left side to the function on the right side.
                                                                                                                                                                            ~~ OperatorüberladungOperator Overloading
                                                                                                                                                                            • Wird verwendet, um eine Überladung für den unären Negationsoperator zu deklarieren.Used to declare an overload for the unary negation operator.
                                                                                                                                                                              ~~~ Bitweise OperatorenBitwise Operators
                                                                                                                                                                              • Berechnet die bitweise NOT-Operation.Computes the bitwise NOT operation.
                                                                                                                                                                                ~- OperatorüberladungOperator Overloading
                                                                                                                                                                                • Wird verwendet, um eine Überladung für den unären Minusoperator zu deklarieren.Used to declare an overload for the unary minus operator.
                                                                                                                                                                                  ~+ OperatorüberladungOperator Overloading
                                                                                                                                                                                  • Wird verwendet, um eine Überladung für den unären Plusoperator zu deklarieren.Used to declare an overload for the unary plus operator.

                                                                                                                                                                                    OperatorrangfolgeOperator Precedence

                                                                                                                                                                                    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.The following table shows the order of precedence of operators and other expression keywords in the F# language, in order from lowest precedence to the highest precedence. Ggf. wird auch die Assoziativität aufgeführt.Also listed is the associativity, if applicable.

                                                                                                                                                                                    OperatorOperator AssoziativitätAssociativity
                                                                                                                                                                                    as RechtsRight
                                                                                                                                                                                    when RechtsRight
                                                                                                                                                                                    |(senkrechter Strich)| (pipe) LinksLeft
                                                                                                                                                                                    ; RechtsRight
                                                                                                                                                                                    let Nicht assoziativNonassociative
                                                                                                                                                                                    function, fun, match, tryfunction, fun, match, try Nicht assoziativNonassociative
                                                                                                                                                                                    if Nicht assoziativNonassociative
                                                                                                                                                                                    -> RechtsRight
                                                                                                                                                                                    := RechtsRight
                                                                                                                                                                                    , Nicht assoziativNonassociative
                                                                                                                                                                                    or, ||or, || LinksLeft
                                                                                                                                                                                    &, &&&, && LinksLeft
                                                                                                                                                                                    :>, :?>:>, :?> RechtsRight
                                                                                                                                                                                    !=Op, < Op, > Op, =, | Op, & Op,&!=op, <op, >op, =, |op, &op, &

                                                                                                                                                                                    (einschließlich <<<, >>>, |||, &&&)(including <<<, >>>, |||, &&&)
                                                                                                                                                                                    LinksLeft
                                                                                                                                                                                    ^op^op

                                                                                                                                                                                    (einschließlich ^^^)(including ^^^)
                                                                                                                                                                                    RechtsRight
                                                                                                                                                                                    :: RechtsRight
                                                                                                                                                                                    :? Nicht assoziativNot associative
                                                                                                                                                                                    -op, +op-op, +op Gilt für infix-Verwendung dieser SymboleApplies to infix uses of these symbols
                                                                                                                                                                                    *op, /op, %op*op, /op, %op LinksLeft
                                                                                                                                                                                    **op**op RechtsRight
                                                                                                                                                                                    f x (Funktionsanwendung)f x (function application) LinksLeft
                                                                                                                                                                                    |(Musterübereinstimmung)| (pattern match) RechtsRight
                                                                                                                                                                                    Präfixoperatoren (+op, -op, %, %%, &, &&, !op, ~op)prefix operators (+op, -op, %, %%, &, &&, !op, ~op) LinksLeft
                                                                                                                                                                                    . LinksLeft
                                                                                                                                                                                    f(x) LinksLeft
                                                                                                                                                                                    f<Typen>f<types> LinksLeft

                                                                                                                                                                                    F# unterstützt die benutzerdefinierte Operatorüberladung.F# supports custom operator overloading. Dies bedeutet, dass Sie eigene Operatoren definieren können.This means that you can define your own operators. In der vorherigen Tabelle kann op eine beliebige gültige (möglicherweise leere) Sequenz von integrierten oder benutzerdefinierten Operatorzeichen sein.In the previous table, op can be any valid (possibly empty) sequence of operator characters, either built-in or user-defined. 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.Thus, you can use this table to determine what sequence of characters to use for a custom operator to achieve the desired level of precedence. Vorangestellte .-Zeichen werden ignoriert, wenn der Compiler die Rangfolge bestimmt.Leading . characters are ignored when the compiler determines precedence.

                                                                                                                                                                                    Siehe auchSee Also

                                                                                                                                                                                    F#-SprachreferenzF# Language Reference

                                                                                                                                                                                    OperatorüberladungOperator Overloading