Freigeben über


Ausführliche Syntax (F#)

In F# sind für viele Konstrukte zwei Formen von Syntax verfügbar: ausführliche Syntax und einfache Syntax. Die ausführliche Syntax wird weniger häufig verwendet, sie bietet jedoch den Vorteil, dass Einzüge von geringerer Bedeutung sind. Die einfache Syntax ist kürzer und signalisiert Anfang und Ende von Konstrukten mithilfe von Einzügen statt mit zusätzlichen Schlüsselwörtern wie begin, end, in usw. Die Standardsyntax ist die einfache Syntax. In diesem Thema wird die Syntax für F#-Konstrukte beschrieben, wenn einfache Syntax nicht aktiviert ist. Ausführliche Syntax ist immer aktiviert. Deshalb können Sie auch bei aktivierter einfacher Syntax dennoch für einige Konstrukte ausführliche Syntax verwenden. Sie können einfache Syntax mit der #light "off"-Direktive deaktivieren.

Tabelle von Konstrukten

In der folgenden Tabelle werden die einfache und die ausführliche Syntax für F#-Sprachkonstrukte in Kontexten dargestellt, in denen sich die beiden Formen unterscheiden. In der Tabelle sind vom Benutzer angegebene Syntaxelemente in spitze Klammern (<>) eingeschlossen. Ausführlichere Informationen zu der Syntax in diesen Konstrukten finden Sie in der Dokumentation für die einzelnen Sprachkonstrukte.

Sprachkonstrukt

Einfache Syntax

Ausführliche Syntax

Zusammengesetzte Ausdrücke

<expression1>
<expression2>
<expression1>; <expression2>

Geschachtelte let-Bindungen

let f x =
    let a = 1
    let b = 2
    x + a + b
let f x =
    let a = 1 in
    let b = 2 in
    x + a + b

Codeblock

    <expression1>
    <expression2>
    ...
    begin
        <expression1>;
        <expression2>;
    end

for...do

for counter = start to finish do
    ...
for counter = start .. finish do
    ...
    done

while...do

while <condition> do
    ...
while <condition> do
    ...
    done

for...in

for var in start .. finish do
    ...
for var in start .. finish do
    ...
    done

do

do ...
do ... in

Datensatz

type <record-name> =
    {
        <field-declarations>
    }
    <value-or-member-definitions>
type <record-name> =
    {
        <field-declarations>
    }
    with
        <value-or-member-definitions>
    end

class

type <class-name>(<params>) =
    ...
type <class-name>(<params>) =
    class
        ...
    end

Struktur

[<StructAttribute>]
type <structure-name> =
    ...
type <structure-name> =
    struct
        ...
    end

Unterscheidungs-Union

type <union-name> =
    | ...
    | ...
    ...
    <value-or-member definitions>
type <union-name> =
    | ...
    | ...
    ...
    with
         <value-or-member-definitions>

end

interface

type <interface-name> =
    ...
type <interface-name> =
    interface
        ...
    end

Objektausdruck

{ new <type-name>
    with
        <value-or-member-definitions>
    <interface-implementations>
}
{ new <type-name>
    with
        <value-or-member-definitions>
    end
    <interface-implementations>
}

Schnittstellenimplementierung

interface <interface-name>
    with
        <value-or-member-definitions>
interface <interface-name>
    with
        <value-or-member-definitions>
    end

Typerweiterung

type <type-name>
    with
        <value-or-member-definitions>
type <type-name>
    with
        <value-or-member-definitions>
    end

Modul

module <module-name> =
    ...
module <module-name> =
    begin
        ...
    end

Siehe auch

Konzepte

Richtlinien für das Formatieren von Code (F#)

Weitere Ressourcen

F#-Sprachreferenz

Compilerdirektiven (F#)