Symbol- und Operatorenreferenz

Hinweis

Mit dem API-Referenz-Link in diesem Artikel gelangen Sie auf MSDN. Die docs.microsoft.com-API-Referenz ist nicht abgeschlossen.

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

Berechnungsausdrücke
  • 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

      Zeichenfolgen
      • Begrenzt eine Textzeichenfolge.
        """ Zeichenfolgen 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.
        # Compileranweisungen

        Flexible Typen
        • 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

            Zitieren von Code
            • Berechnet den ganzzahligen Modulo.
            • Wird beim Splicing von Ausdrücken in typisierte Codequotationen verwendet.
              %% Zitieren von Code
              • Wird beim Splicing von Ausdrücken in nicht typisierte Codequotationen verwendet.
                %? Operatoren, die NULL-Werte zulassen
                • Berechnet den ganzzahligen Modulo, wenn die rechte Seite ein Typ ist, der einen Null-Wert zulässt.
                  & Vergleichsausdrücke
                  • Berechnet die Adresse eines änderbaren Werts, der bei der Interoperation mit anderen Sprachen verwendet werden kann.
                  • Wird in AND-Mustern verwendet.
                    && Boolesche Operatoren
                    • Berechnet die boolesche AND-Operation.
                      &&& Bitweise Operatoren
                      • Berechnet die bitweise AND-Operation.
                        ' Literale

                        Automatische Verallgemeinerung
                        • 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
                            • Stellt den einzelnen Wert des Einheitentyps dar.
                              (...) Tupel

                              Operatorüberladung
                              • 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
                                  • Begrenzt ein aktives Muster. Wird auch als Bananenklammern bezeichnet.
                                    * Arithmetische Operatoren

                                    Tupel

                                    Maßeinheiten
                                    • 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
                                      • Multipliziert die linke mit der rechten Seite, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
                                        ** Arithmetische Operatoren
                                        • Berechnet die Potenzierung (x ** y steht für x potenziert mit y).
                                          + Arithmetische Operatoren
                                          • 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
                                            • Addiert die linke und die rechte Seite, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
                                              , Tupel
                                              • Trennt die Elemente eines Tupels oder Typparameters.
                                                - Arithmetische Operatoren
                                                • 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
                                                  • Subtrahiert die rechte Seite von der linken, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
                                                    -> Funktionen

                                                    Vergleichsausdrücke
                                                    • Begrenzt bei Funktionstypen die Argumente und Rückgabewerte.
                                                    • Ergibt einen Ausdruck (in Sequenzausdrücken); entspricht dem yield-Schlüsselwort.
                                                    • Wird in Übereinstimmungsausdrücken verwendet.
                                                      . Mitglieder

                                                      Primitive Typen
                                                      • Greift auf einen Member zu und trennt einzelne Namen in einem vollqualifizierten Namen.
                                                      • Gibt ein Dezimaltrennzeichen in Gleitkommazahlen an.
                                                        .. Schleifen: for...in-Ausdruck
                                                        • Gibt einen Bereich an.
                                                          .. .. Schleifen: for...in-Ausdruck
                                                          • Gibt einen Bereich zusammen mit einem Inkrement an.
                                                            .[...] Arrays
                                                            • Greift auf ein Arrayelement zu.
                                                              / Arithmetische Operatoren

                                                              Maßeinheiten
                                                              • Dividiert die linke Seite (Zähler) durch die rechte Seite (Nenner).
                                                              • Wird in Maßeinheittypen verwendet.
                                                                /? Operatoren, die NULL-Werte zulassen
                                                                • 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
                                                                    • Gibt einen XML-Kommentar an.
                                                                      : Funktionen
                                                                      • Trennt in einer Typanmerkung einen Parameter- oder Membernamen vom Typ.
                                                                        :: Listen

                                                                        Vergleichsausdrücke
                                                                        • Erstellt eine Liste. Das Element auf der linken Seite wird der Liste auf der rechten Seite vorangestellt.
                                                                        • Wird im Musterabgleich verwendet, um die Teile einer Liste zu trennen.
                                                                          := Referenzzellen
                                                                          • Weist einer Verweiszelle einen Wert zu.
                                                                            :> Umwandlung und Konvertierungen
                                                                            • Konvertiert einen Typen in einen Typen, der in der Hierarchie höher ist.
                                                                              :? Vergleichsausdrücke
                                                                              • Gibt true zurück, wenn der Wert dem angegebenen Typen entspricht; andernfalls wird false zurückgegeben (Typtestoperator).
                                                                                :?> Umwandlung und Konvertierungen
                                                                                • Konvertiert einen Typen in einen Typen, der in der Hierarchie weiter unten ist.
                                                                                  ; Ausführliche Syntax

                                                                                  Listen

                                                                                  Datensätze
                                                                                  • Trennt Ausdrücke (meist in ausführlicher Syntax verwendet).
                                                                                  • Trennt Elemente einer Liste.
                                                                                  • Trennt Felder eines Datensatzes.
                                                                                    < Arithmetische Operatoren
                                                                                    • Berechnet die Kleiner-als-Operation.
                                                                                      <? Operatoren, die NULL-Werte zulassen Berechnet die "kleiner als"-Operation, wenn die rechte Seite ein Typ ist, der einen Null-Wert zulässt.
                                                                                      << Funktionen
                                                                                      • Verfasst zwei Funktionen in umgekehrter Reihenfolge, d. h., die zweite Funktion wird zuerst ausgeführt (Rückwärtskompositionsoperator).
                                                                                        <<< Bitweise Operatoren
                                                                                        • Verschiebt Bits in der Menge auf der linken Seite um die Anzahl der Bits nach links, die auf der rechten Seite angegeben wurde.
                                                                                          <- Werte
                                                                                          • Weist einer Variablen einen Wert zu.
                                                                                            <...> Automatische Verallgemeinerung
                                                                                            • Begrenzt Typparameter.
                                                                                              <> Arithmetische Operatoren
                                                                                              • Gibt true zurück, wenn die linke Seite nicht gleich der rechten Seite ist; andernfalls wird "false" zurückgegeben.
                                                                                                <>? Operatoren, die NULL-Werte zulassen
                                                                                                • Berechnet die "nicht gleich"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
                                                                                                  <= Arithmetische Operatoren
                                                                                                  • Gibt true zurück, wenn die linke Seite kleiner gleich die rechte Seite ist; andernfalls wird false zurückgegeben.
                                                                                                    <=? Operatoren, die NULL-Werte zulassen
                                                                                                    • Berechnet die "kleiner gleich"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
                                                                                                      <| Funktionen
                                                                                                      • Übergibt das Ergebnis des Ausdrucks auf der rechten Seite an die Funktion auf der linken Seite (Rückwärtspipeoperator).
                                                                                                        <|| Operatoren.( <|| )<'T1,'T2,'U> Funktion
                                                                                                        • Übergibt das Tupel aus zwei Argumenten auf der rechten Seite an die Funktion auf der linken Seite.
                                                                                                          <||| Operatoren.( <||| )<'T1,'T2,'T3,'U> Funktion
                                                                                                          • Übergibt das Tupel aus drei Argumenten auf der rechten Seite an die Funktion auf der linken Seite.
                                                                                                            <@...@> Zitieren von Code
                                                                                                            • Begrenzt eine typisierte Codequotation.
                                                                                                              <@@...@@> Zitieren von Code
                                                                                                              • Begrenzt eine nicht typisierte Codequotation.
                                                                                                                = Arithmetische Operatoren
                                                                                                                • Gibt true zurück, wenn die linke Seite gleich der rechten Seite ist; andernfalls wird false zurückgegeben.
                                                                                                                  =? Operatoren, die NULL-Werte zulassen
                                                                                                                  • 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
                                                                                                                      • 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
                                                                                                                        • Berechnet die "größer als"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
                                                                                                                          >> Funktionen
                                                                                                                          • Verfasst zwei Funktionen (Vorwärtskompositionsoperator).
                                                                                                                            >>> Bitweise Operatoren
                                                                                                                            • 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
                                                                                                                              • 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
                                                                                                                                • Berechnet die "größer gleich"-Operation, wenn die rechte Seite ein Typ ist, der Null-Werte zulässt.
                                                                                                                                  ? Parameter und Argumente
                                                                                                                                  • 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
                                                                                                                                      • Entspricht den jeweiligen Operatoren ohne das ? Präfix, wobei sich links ein Typ befindet, der Null-Werte zulässt.
                                                                                                                                        >=?, >?, <=?, <?, =?, <>?, +?, -?, *?, /? Operatoren, die NULL-Werte zulassen
                                                                                                                                        • Entspricht den jeweiligen Operatoren ohne das ? Suffix, wobei sich rechts ein Typ befindet, der Null-Werte zulässt.
                                                                                                                                          ?>=?, ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/? Operatoren, die NULL-Werte zulassen
                                                                                                                                          • Entspricht den jeweiligen Operatoren ohne die umgebenden Fragezeichen, wobei sich auf beiden Seiten Typen befinden, die Null-Werte zulassen.
                                                                                                                                            @ Listen

                                                                                                                                            Zeichenfolgen
                                                                                                                                            • 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
                                                                                                                                              • Begrenzt die Elemente einer Liste.
                                                                                                                                                [|...|] Arrays
                                                                                                                                                • Begrenzt die Elemente eines Arrays.
                                                                                                                                                  [<...>] Attribute
                                                                                                                                                  • Begrenzt ein Attribut.
                                                                                                                                                    \ Zeichenfolgen
                                                                                                                                                    • Versieht das nächste Zeichen mit einem Escapezeichen; wird in Zeichen- und Zeichenfolgenliteralen verwendet.
                                                                                                                                                      ^ Statisch aufgelöste Typparameter

                                                                                                                                                      Zeichenfolgen
                                                                                                                                                      • Gibt die Typparameter an, die zum Zeitpunkt der Kompilierung, nicht zur Laufzeit aufgelöst werden müssen.
                                                                                                                                                      • Verkettet Zeichenfolgen.
                                                                                                                                                        ^^^ Bitweise Operatoren
                                                                                                                                                        • Berechnet die bitweise XOR-Operation.
                                                                                                                                                          _ Vergleichsausdrücke

                                                                                                                                                          Generika
                                                                                                                                                          • Gibt ein Platzhaltermuster an.
                                                                                                                                                          • Gibt einen anonymen generischen Parameter an.
                                                                                                                                                            ` Automatische Verallgemeinerung
                                                                                                                                                            • Wird intern verwendet, um einen generischen Typparameter anzugeben.
                                                                                                                                                              {...} Sequenzen

                                                                                                                                                              Datensätze
                                                                                                                                                              • Begrenzt Sequenzausdrücke und Berechnungsausdrücke.
                                                                                                                                                              • Wird in Datensatzdefinitionen verwendet.
                                                                                                                                                                | Vergleichsausdrücke
                                                                                                                                                                • Begrenzt einzelne Übereinstimmungsfälle, einzelne diskriminierte Union-Fälle und Enumerationswerte.
                                                                                                                                                                  || Boolesche Operatoren
                                                                                                                                                                  • Berechnet die boolesche OR-Operation.
                                                                                                                                                                    ||| Bitweise Operatoren
                                                                                                                                                                    • Berechnet die bitweise OR-Operation.
                                                                                                                                                                      |> Funktionen
                                                                                                                                                                      • Übergibt das Ergebnis der linken Seite an die Funktion auf der rechten Seite (Vorwärtspipeoperator).
                                                                                                                                                                        ||> Operatoren.( ||> )<'T1,'T2,'U> Funktion
                                                                                                                                                                        • Übergibt das Tupel aus zwei Argumenten auf der linken Seite an die Funktion auf der rechten Seite.
                                                                                                                                                                          |||> Operatoren.( |||> )<'T1,'T2,'T3,'U> Funktion
                                                                                                                                                                          • Übergibt das Tupel aus drei Argumenten auf der linken Seite an die Funktion auf der rechten Seite.
                                                                                                                                                                            ~~ Operatorüberladung
                                                                                                                                                                            • Wird verwendet, um eine Überladung für den unären Negationsoperator zu deklarieren.
                                                                                                                                                                              ~~~ Bitweise Operatoren
                                                                                                                                                                              • Berechnet die bitweise NOT-Operation.
                                                                                                                                                                                ~- Operatorüberladung
                                                                                                                                                                                • Wird verwendet, um eine Überladung für den unären Minusoperator zu deklarieren.
                                                                                                                                                                                  ~+ Operatorüberladung
                                                                                                                                                                                  • 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
                                                                                                                                                                                    :>, :?> Rechts
                                                                                                                                                                                    !=op, <op, >op, =, |op, &op, &

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

                                                                                                                                                                                    (einschließlich ^^^)
                                                                                                                                                                                    Rechts
                                                                                                                                                                                    :: Rechts
                                                                                                                                                                                    :? Nicht assoziativ
                                                                                                                                                                                    -op, +op Gilt für infix-Verwendung dieser Symbole
                                                                                                                                                                                    *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<Typen> 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

                                                                                                                                                                                    F#-Sprachreferenz

                                                                                                                                                                                    Operatorüberladung