Bindungen zulassen

Eine Bindung ordnet einen Bezeichner einem Wert oder einer Funktion zu. Sie verwenden das let Schlüsselwort, um einen Namen an einen Wert oder eine Funktion zu binden.

Syntax

// Binding a value:
let identifier-or-pattern [: type] =expressionbody-expression
// Binding a function value:
let identifier parameter-list [: return-type ] =expressionbody-expression

Bemerkungen

Das let Schlüsselwort wird in Bindungsausdrücken verwendet, um Werte oder Funktionswerte für einen oder mehrere Namen zu definieren. Die einfachste Form des let Ausdrucks bindet wie folgt einen Namen an einen einfachen Wert.

let i = 1

Wenn Sie den Ausdruck durch eine neue Zeile vom Bezeichner trennen, müssen Sie jede Zeile des Ausdrucks wie im folgenden Code einrücken.

let someVeryLongIdentifier =
    // Note indentation below.
    3 * 4 + 5 * 6

Anstelle eines Namens kann ein Muster, das Namen enthält, angegeben werden, z. B. ein Tupel, wie im folgenden Code gezeigt.

let i, j, k = (1, 2, 3)

Der Textkörperausdruck ist der Ausdruck, in dem die Namen verwendet werden. Der Textkörperausdruck wird in einer eigenen Zeile eingerückt, um genau mit dem ersten Zeichen im let Schlüsselwort zu beginnen:

let result =

    let i, j, k = (1, 2, 3)

    // Body expression:
    i + 2 * j + 3 * k

Eine let Bindung kann auf Modulebene, in der Definition eines Klassentyps oder in lokalen Bereichen angezeigt werden, z. B. in einer Funktionsdefinition. Eine let Bindung auf der obersten Ebene in einem Modul oder in einem Klassentyp muss keinen Textkörperausdruck aufweisen, aber auf anderen Bereichsebenen ist der Textkörperausdruck erforderlich. Die gebundenen Namen können nach dem Definitionspunkt verwendet werden, aber nicht zu einem Zeitpunkt, bevor die let Bindung angezeigt wird, wie im folgenden Code dargestellt.

// Error:
printfn "%d" x
let x = 100
// OK:
printfn "%d" x

Funktionsbindungen

Funktionsbindungen folgen den Regeln für Wertbindungen, mit der Ausnahme, dass Funktionsbindungen den Funktionsnamen und die Parameter enthalten, wie im folgenden Code dargestellt.

let function1 a = a + 1

Im Allgemeinen sind Parameter Muster, z. B. ein Tupelmuster:

let function2 (a, b) = a + b

Ein let Bindungsausdruck wertet den Wert des letzten Ausdrucks aus. Aus diesem Grund wird im folgenden Codebeispiel der Wert result berechnet, aus 100 * function3 (1, 2)dem ausgewertet wird 300.

let result =
    let function3 (a, b) = a + b
    100 * function3 (1, 2)

Weitere Informationen finden Sie unter Funktionen.

Typanmerkungen

Sie können Typen für Parameter angeben, indem Sie einen Doppelpunkt einschließen (:) gefolgt von einem Typnamen, alle in Klammern eingeschlossen. Sie können auch den Typ des Rückgabewerts angeben, indem Sie den Doppelpunkt und den Typ nach dem letzten Parameter anfügen. Die vollständigen Typanmerkungen für function1, mit ganzzahligen Zahlen als Parametertypen, würden wie folgt aussehen.

let function1 (a: int) : int = a + 1

Wenn keine expliziten Typparameter vorhanden sind, wird die Typeinleitung verwendet, um die Typen von Parametern von Funktionen zu bestimmen. Dies kann die automatische Generalisierung des Typs eines Parameters umfassen, der generisch sein soll.

Weitere Informationen finden Sie unter "Automatische Generalisierung " und "Typeinschluss".

Bindungen in Klassen zulassen

Eine let Bindung kann in einem Klassentyp, aber nicht in einer Struktur oder einem Datensatztyp angezeigt werden. Um eine Let-Bindung in einem Klassentyp zu verwenden, muss die Klasse über einen primären Konstruktor verfügen. Konstruktorparameter müssen nach dem Typnamen in der Klassendefinition angezeigt werden. Eine let Bindung in einem Klassentyp definiert private Felder und Member für diesen Klassentyp und bildet zusammen mit do Bindungen im Typ den Code für den primären Konstruktor für den Typ. Die folgenden Codebeispiele zeigen eine Klasse MyClass mit privaten Feldern field1 und field2.

type MyClass(a) =
    let field1 = a
    let field2 = "text"
    do printfn "%d %s" field1 field2
    member this.F input =
        printfn "Field1 %d Field2 %s Input %A" field1 field2 input

Die Bereiche field1 und field2 sind auf den Typ beschränkt, in dem sie deklariert werden. Weitere Informationen finden Sie unter let Bindungen in Klassen und Klassen.

Typparameter in let Bindings

Eine let Bindung auf Modulebene, in einem Typ oder in einem Berechnungsausdruck kann explizite Typparameter aufweisen. Eine Let-Bindung in einem Ausdruck, z. B. innerhalb einer Funktionsdefinition, darf keine Typparameter aufweisen. Weitere Informationen finden Sie unter Generics.

Attribute zum Zulassen von Bindungen

Attribute können auf Bindungen auf oberster Ebene let in einem Modul angewendet werden, wie im folgenden Code dargestellt.

[<Obsolete>]
let function1 x y = x + y

Gültigkeitsbereich und Barrierefreiheit von Let-Bindungen

Der Bereich einer Entität, die mit einer Let-Bindung deklariert wurde, ist auf den Teil des enthaltenden Bereichs (z. B. eine Funktion, ein Modul, eine Datei oder eine Klasse) beschränkt, nachdem die Bindung angezeigt wird. Daher kann man sagen, dass eine Bindung einen Namen in einen Bereich einführt. In einem Modul ist ein let-gebundener Wert oder eine Funktion für Clients eines Moduls zugänglich, solange auf das Modul zugegriffen werden kann, da die Bindungen in einem Modul in öffentlichen Funktionen des Moduls kompiliert werden. Lassen Sie Bindungen in einer Klasse dagegen privat für die Klasse sein.

Normalerweise müssen Funktionen in Modulen durch den Namen des Moduls qualifiziert werden, wenn es vom Clientcode verwendet wird. Wenn z. B. ein Modul Module1 eine Funktion function1aufweist, würden Benutzer angeben Module1.function1 , dass auf die Funktion verwiesen werden soll.

Benutzer eines Moduls können eine Importdeklaration verwenden, um die Funktionen innerhalb dieses Moduls zur Verwendung zur Verfügung zu stellen, ohne durch den Modulnamen qualifiziert zu werden. Im soeben erwähnten Beispiel können Benutzer des Moduls in diesem Fall das Modul mithilfe der Importdeklaration open Module1 öffnen und anschließend direkt darauf verweisen function1 .

module Module1 =
    let function1 x = x + 1.0

module Module2 =
    let function2 x =
        Module1.function1 x

open Module1

let function3 x =
    function1 x

Einige Module weisen das Attribut RequireQualifiedAccess auf. Dies bedeutet, dass die verfügbaren Funktionen mit dem Namen des Moduls qualifiziert werden müssen. Beispielsweise verfügt das F#-Listenmodul über dieses Attribut.

Weitere Informationen zu Modulen und Zugriffssteuerung finden Sie unter Module und Zugriffssteuerung.

Siehe auch

• Funktionen
• let Bindungen in Klassen