låt bindningar
En bindning associerar en identifierare med ett värde eller en funktion. Du använder nyckelordet let för att binda ett namn till ett värde eller en funktion.
Syntax
// Binding a value:
let identifier-or-pattern [: type] =expressionbody-expression
// Binding a function value:
let identifier parameter-list [: return-type ] =expressionbody-expression
Kommentarer
Nyckelordet let används i bindningsuttryck för att definiera värden eller funktionsvärden för ett eller flera namn. Den enklaste formen av let uttrycket binder ett namn till ett enkelt värde enligt följande.
let i = 1
Om du separerar uttrycket från identifieraren med hjälp av en ny rad måste du dra in varje rad i uttrycket, som i följande kod.
let someVeryLongIdentifier =
// Note indentation below.
3 * 4 + 5 * 6
I stället för bara ett namn kan ett mönster som innehåller namn anges, till exempel en tupplar, som visas i följande kod.
let i, j, k = (1, 2, 3)
Body-expression är uttrycket där namnen används. Brödtextuttrycket visas på en egen rad, indraget för att rada upp exakt med det första tecknet i nyckelordet let :
let result =
let i, j, k = (1, 2, 3)
// Body expression:
i + 2 * j + 3 * k
En let bindning kan visas på modulnivå, i definitionen av en klasstyp eller i lokala omfång, till exempel i en funktionsdefinition. En let bindning på den översta nivån i en modul eller i en klasstyp behöver inte ha ett brödtextuttryck, men på andra omfångsnivåer krävs brödtextuttrycket. De bundna namnen kan användas efter definitionspunkten, men inte någon gång innan bindningen let visas, vilket visas i följande kod.
// Error:
printfn "%d" x
let x = 100
// OK:
printfn "%d" x
Funktionsbindningar
Funktionsbindningar följer reglerna för värdebindningar, förutom att funktionsbindningar innehåller funktionsnamnet och parametrarna, enligt följande kod.
let function1 a = a + 1
I allmänhet är parametrar mönster, till exempel ett tupplarmönster:
let function2 (a, b) = a + b
Ett let bindningsuttryck utvärderas till värdet för det senaste uttrycket. I följande kodexempel beräknas därför värdet result för från 100 * function3 (1, 2), som utvärderas till 300.
let result =
let function3 (a, b) = a + b
100 * function3 (1, 2)
Mer information finns i Funktioner.
Skriv anteckningar
Du kan ange typer för parametrar genom att inkludera ett kolon (:) följt av ett typnamn, som alla omges av parenteser. Du kan också ange typen av returvärde genom att lägga till kolonet och skriva efter den sista parametern. De fullständiga typanteckningarna för function1, med heltal som parametertyper, skulle vara följande.
let function1 (a: int) : int = a + 1
När det inte finns några explicita typparametrar används typinferens för att fastställa typerna av parametrar för funktioner. Detta kan inkludera att automatiskt generalisera typen av en parameter som ska vara generisk.
Mer information finns i Automatisk generalisering och typinferens.
let Bindings in Classes
En let bindning kan visas i en klasstyp men inte i en struktur- eller posttyp. Om du vill använda en let-bindning i en klasstyp måste klassen ha en primär konstruktor. Konstruktorparametrarna måste visas efter typnamnet i klassdefinitionen. En let bindning i en klasstyp definierar privata fält och medlemmar för den klasstypen och bildar tillsammans med do bindningar i typen koden för den primära konstruktorn för typen. Följande kodexempel visar en klass MyClass med privata fält field1 och 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
Omfången field1 för och field2 är begränsade till den typ som de deklareras i. Mer information let finns i Bindningar i klasser och klasser.
Skriv parametrar i let Bindings
En let bindning på modulnivå, i en typ eller i ett beräkningsuttryck kan ha explicita typparametrar. En let-bindning i ett uttryck, till exempel inom en funktionsdefinition, kan inte ha typparametrar. Mer information finns i Generiska objekt.
Attribut för let-bindningar
Attribut kan tillämpas på bindningar på den översta nivån let i en modul, enligt följande kod.
[<Obsolete>]
let function1 x y = x + y
Omfattning och tillgänglighet för let-bindningar
Omfattningen för en entitet som deklareras med en let-bindning är begränsad till den del av det innehållande omfånget (till exempel en funktion, modul, fil eller klass) efter att bindningen visas. Därför kan man säga att en let-bindning introducerar ett namn i ett omfång. I en modul är ett let-bound-värde eller en funktion tillgänglig för klienter i en modul så länge modulen är tillgänglig, eftersom let-bindningarna i en modul kompileras till offentliga funktioner i modulen. Låt däremot bindningar i en klass vara privata för klassen.
Normalt måste funktioner i moduler kvalificeras med namnet på modulen när de används av klientkoden. Om en modul Module1 till exempel har en funktion function1anger Module1.function1 användarna att de ska referera till funktionen.
Användare av en modul kan använda en importdeklaration för att göra funktionerna i modulen tillgängliga för användning utan att kvalificeras av modulnamnet. I exemplet som nyss nämndes kan användare av modulen i så fall öppna modulen med hjälp av importdeklarationen open Module1 och därefter referera till function1 direkt.
module Module1 =
let function1 x = x + 1.0
module Module2 =
let function2 x =
Module1.function1 x
open Module1
let function3 x =
function1 x
Vissa moduler har attributet RequireQualifiedAccess, vilket innebär att de funktioner som de exponerar måste vara kvalificerade med namnet på modulen. Modulen F#-lista har till exempel det här attributet.
Mer information om moduler och åtkomstkontroll finns i Moduler och åtkomstkontroll.
