let-Bindungen (F#)
Eine Bindung ordnet einem Wert oder einer Funktion einen Bezeichner zu. Mithilfe des let-Schlüsselworts binden Sie einen Namen an einen Wert oder eine Funktion.
// Binding a value:
let identifier-or-pattern [: type] =
expression
body-expression
// Binding a function value:
let identifier parameter-list [: return-type ] =
expression
body-expression
Hinweise
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 einen Namen wie folgt an einen einfachen Wert.
let i = 1
Wenn Sie den Ausdruck mithilfe einer neuen Zeile vom Bezeichner trennen, müssen Sie jede Zeile des Ausdrucks einziehen, wie im folgenden Code.
let someVeryLongIdentifier =
// Note indentation below.
3 * 4 + 5 * 6
Statt lediglich eines Namens kann ein Muster angegeben werden, das Namen enthält, z. B. ein Tupel, wie im folgenden Code gezeigt.
let i, j, k = (1, 2, 3)
Die body-expression ist der Ausdruck, in dem die Namen verwendet werden. Der Body-Ausdruck befindet sich in einer eigenen Zeile, deren Einzug genau am ersten Zeichen im let-Schlüsselwort ausgerichtet ist:
let result =
let i, j, k = (1, 2, 3)
// Body expression:
i + 2*j + 3*k
Eine let-Bindung kann sich auf Modulebene, in der Definition eines Klassentyps oder in lokalen Gültigkeitsbereichen, z. B. in einer Funktionsdefinition, befinden. Eine let-Bindung auf der obersten Ebene in einem Modul oder in einem Klassentyp muss über keinen Body-Ausdruck verfügen, jedoch ist der Body-Ausdruck auf anderen Gültigkeitsbereichsebenen erforderlich. Die gebundenen Namen sind nach der Definition verwendbar, jedoch nicht vor der let-Bindung, wie im folgenden Code veranschaulicht.
// Error:
printfn "%d" x
let x = 100
// OK:
printfn "%d" x
Funktionsbindungen
Für Funktionsbindungen gelten die gleichen Regeln wie für Wertbindungen, mit dem Unterschied, dass Funktionsbindungen den Funktionsnamen und die Parameter enthalten, wie im folgenden Code gezeigt.
let function1 a =
a + 1
Im Allgemeinen sind Parameter Muster, z. B. ein Tupelmuster:
let function2 (a, b) = a + b
Ein let-Bindungsausdruck ergibt den Wert des letzten Ausdrucks. Daher wird im folgenden Codebeispiel der Wert von result anhand von 100 * function3 (1, 2) berechnet, und der Ausdruck ergibt 300.
let result =
let function3 (a, b) = a + b
100 * function3 (1, 2)
Weitere Informationen finden Sie unter Funktionen (F#).
Typanmerkungen
Sie können Typen für Parameter angeben, indem Sie einen Doppelpunkt (:), gefolgt von einem Typnamen, einfügen und die gesamten Elemente in Klammern einschließen. Sie können auch den Typ des Rückgabewerts angeben, indem Sie nach dem letzten Parameter den Doppelpunkt und den Typ anfügen. Die vollständigen Typanmerkungen für function1, mit ganzen Zahlen als Parametertypen, lauten wie folgt.
let function1 (a: int) : int = a + 1
Wenn keine expliziten Typparameter vorhanden sind, werden die Typen von Funktionsparametern mithilfe von Typrückschluss bestimmt. Hierbei wird möglicherweise der Typ eines Parameters automatisch als generischer Typ verallgemeinert.
Weitere Informationen finden Sie unter Automatische Verallgemeinerung (F#) und Typrückschluss (F#).
let-Bindungen in Klassen
Eine let-Bindung kann in einem Klassentyp, jedoch nicht in einem Struktur- oder Datensatztyp enthalten sein. Für die Verwendung einer let-Bindung in einem Klassentyp muss die Klasse über einen primären Konstruktor verfügen. Konstruktorparameter müssen nach dem Typnamen in der Klassendefinition angegeben werden. Eine let-Bindung in einem Klassentyp definiert private Felder und Member für diesen Klassentyp und bildet, zusammen mit do-Bindungen in dem Typ, den Code für den primären Konstruktor des Typs. In den folgenden Codebeispielen wird die Klasse MyClass mit den privaten Feldern field1 und field2 veranschaulicht.
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 Gültigkeitsbereiche von field1 und field2 sind auf den Typ beschränkt, in dem sie deklariert werden. Weitere Informationen finden Sie unter let-Bindungen in Klassen (F#) und Klassen (F#).
Typparameter in let-Bindungen
Eine let-Bindung auf Modulebene, in einem Typ oder einem Berechnungsausdruck kann über explizite Typparameter verfügen. Eine let-Bindung in einem Ausdruck, z. B. in einer Funktionsdefinition, darf über keine Typparameter verfügen. Weitere Informationen finden Sie unter Generika (F#).
Attribute für let-Bindungen
Attribute können in einem Modul für let-Bindungen der obersten Ebene übernommen werden, wie im folgenden Code gezeigt.
[<Obsolete>]
let function1 x y = x + y
Bereich und Barrierefreiheit von let-Bindungen
Der Gültigkeitsbereich einer Entität, die einer let-Bindung deklariert wird, ist der Teil des enthaltenden Bereich eingeschränkt (z. B. eine Funktion, ein Modul, eine Klasse oder eine Datei), nachdem die Bindung wird. Deshalb kann es sein, dass gesagt einer let-Bindung einen Namen in einen Bereich vorstellt. In einem Modul ist eine LET-gebundener Wert oder eine Funktion, die Clients eines Moduls möglich, solange das Modul zugegriffen werden kann, da die let-Bindungen in einem Modul in öffentliche Funktionen des Moduls kompiliert werden. Im Gegensatz dazu sind let-Bindungen in einer Klasse die Klasse privat.
Normalerweise müssen Features in Modulen das Modul mit dem Namen qualifiziert werden, wenn sie von Clientcode verwendet werden. Wenn beispielsweise ein Modul Module1 eine Funktion function1 hat, werden Benutzer Module1.function1 angeben, um die Funktion zuzugreifen.
Verwenden eines Moduls Benutzer kann eine Einfuhrerklärung, um die Funktionen innerhalb dieses Moduls ausgeführt werden, das für die Verwendung verfügbar ist, ohne durch den Modulnamen qualifiziert werden. Im gerade genannten Beispiel, können Benutzer des Moduls In diesem Fall das Modul öffnen, indem Sie die Einfuhrerklärung Öffnen Module1 verwenden und anschließend function1 direkt verweisen.
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 haben das Attribut RequireQualifiedAccess. Dies bedeutet, dass die Funktionen, die sie verfügbar machen, dem Namen des Moduls qualifiziert werden müssen. Zum Beispiel verfügt das Modul F#-Listen dieses Attribut.
Weitere Informationen zu Modulen und Zugriffssteuerung finden Sie unter Module (F#) und Zugriffssteuerung (F#).