Parametry a argumenty (F#)
Toto téma popisuje jazyková podpora pro definování parametrů a předávání argumentů funkce, metody a vlastnosti.Obsahuje informace o předání odkazovat sea jak definovat a používat metody, které mohou proměnná počet argumentů.
Parametry a argumenty
Termín parametr se používá k popisu názvů pro hodnoty, které se očekává, že mají být dodány.Termín argument se používá pro hodnot pro každý parametr.
Parametry lze zadat v n-tice nebo curried formulář, nebo kombinaci obou.Pomocí explicitních parametr názvu můžete předat argumenty.Parametry metody můžete jako nepovinné a výchozí hodnota.
Parametr vzorky
Parametry zadané na funkce a metody jsou obecně vzorky, které jsou odděleny mezerami.To znamená, že v principvšechny vzorky podle Shoda výrazy (F#) lze použít v seznamu parametr pro funkce nebo člena.
Metody obvykle používají tuple formulář předávání argumentů.To dosahuje jasnější výsledek z hlediska ostatních.NET jazyků, protože n-tice formulář odpovídá způsobu předáno argumentů.NET metody.
Curried formulář se nejčastěji používá s funkcemi, které jsou vytvořeny pomocí let vazby.
Následující pseudocode jsou uvedeny příklady n-tice a curried argumenty.
// Tuple form.
member this.SomeMethod(param1, param2) = ...
// Curried form.
let function1 param1 param2 = ...
Kombinované formulářů jsou možné, pokud jsou některé argumenty v n-tice a některé ne.
let function2 param1 (param2a, param2b) param3 = ...
V seznamech parametr lze také použít jiné vzorky, ale pokud vzorek parametr neodpovídá všechny možné vstupy, pravděpodobně neúplné shoda v době spuštění.výjimka MatchFailureException je generována, pokud hodnota argument neodpovídá vzorky uvedené v seznamu parametr . kompilátor vydá upozornění při umožňuje neúplné odpovídá parametr vzorek.Alespoň jeden další vzorek je často užitečné pro seznamy parametr a který je maska zástupných znaků.Maska zástupných znaků v seznamu parametr pomocí chcete jednoduše ignorovat všechny argumenty, které jsou dodány.Následující kód ilustruje použití zástupných vzorek v seznamu argument .
let makeList _ = [ for i in 1 .. 100 -> i * i ]
// The arguments 100 and 200 are ignored.
let list1 = makeList 100
let list2 = makeList 200
Vzor zástupných může být užitečné při každém nutné argumenty předané, například v hlavní položka bod program-li se zajímají o argumentyčára příkazu-, které jsou obvykle poskytovány jako pole řetězců, jako v následujícím kódu.
[<EntryPoint>]
let main _ =
printfn "Entry point!"
0
Jiné vzorky, které se někdy používá argumenty jsou as vzorek a vzorky identifikátor přidružený k discriminated odborů a aktivní vzorky.Takto můžete použít jediný případ vzorek discriminated unie.
type Slice = Slice of int * int * string
let GetSubstring1 (Slice(p0, p1, text)) =
printfn "Data begins at %d and ends at %d in string %s" p0 p1 text
text.[p0..p1]
let substring = GetSubstring1 (Slice(0, 4, "Et tu, Brute?"))
printfn "Substring: %s" substring
Výstup je takto.
Data begins at 0 and ends at 4 in string Et tu, Brute?
Et tu
Aktivní vzorky mohou být užitečné jako parametry, například při transformaci argument do požadovaného formátu, jako v následujícím příkladu:
type Point = { x : float; y : float }
let (| Polar |) { x = x; y = y} =
( sqrt (x*x + y*y), System.Math.Atan (y/ x) )
let radius (Polar(r, _)) = r
let angle (Polar(_, theta)) = theta
Můžete použít as vzorek uložit odpovídající hodnotu jako místní hodnotu, která je zobrazena v následujícím čára kódu.
let GetSubstring2 (Slice(p0, p1, text) as s) = s
Jiný vzorek, který se někdy používá je funkce ponechá poslední argument nepojmenované poskytnutím jako hlavní funkce, lambda výraz, který okamžitě provede porovnávací vzorek na implicitní argument.Příklad je následující čára kódu.
let isNil = function [] -> true | _::_ -> false
Tento kód definuje funkce přebírá obecný seznam a vrátí true Pokud je seznam prázdný, a false jinak.Použití těchto technik může ztížit kód číst.
V některých případech vzorky, které obsahují neúplné shody jsou užitečné, například pokud víte, že pouze tři prvky seznamů v program , můžete použít následující vzorek v seznamu parametr .
let sum [a; b; c;] = a + b + c
Použití vzorky, které mají neúplné shody se nejlépe hodí pro rychlý vývoj prototypů a další dočasné použití.kompilátor vydá upozornění takový kód.Takové vzorky nelze případ obecné všech možných vstupů a proto nejsou vhodné pro komponenta rozhraní API.
Pojmenované argumenty
Argumenty pro metody lze určit podle umístění v seznamu oddělené čárkami argument nebo názvem, následuje symbol rovná se a hodnota musí být předány tyto mohou být předány do metoda explicitně.Pokud je zadán zadáním názvu, mohou být zobrazeny v jiném pořadí než v prohlášení.
Pojmenované argumenty můžete provést kód čitelnější a více přizpůsobitelné určité typy změn, jako je například změna pořadí parametrů metoda rozhraní API.
Pojmenované argumenty jsou povoleny pouze pro metody, není pro let-vázané funkce, funkce hodnoty nebo výrazy lambda.
Následující příklad kódu ukazuje použití pojmenovaných argumentů.
type SpeedingTicket() =
member this.GetMPHOver(speed: int, limit: int) = speed - limit
let CalculateFine (ticket : SpeedingTicket) =
let delta = ticket.GetMPHOver(limit = 55, speed = 70)
if delta < 20 then 50.0 else 100.0
let ticket1 : SpeedingTicket = SpeedingTicket()
printfn "%f" (CalculateFine ticket1)
Voláníkonstruktor třídamůžete nastavit hodnoty vlastností třída pomocí syntaxe, která je podobná pojmenované argumenty. Následující příklad ukazuje tato syntaxe.
type Account() =
let mutable balance = 0.0
let mutable number = 0
let mutable firstName = ""
let mutable lastName = ""
member this.AccountNumber
with get() = number
and set(value) = number <- value
member this.FirstName
with get() = firstName
and set(value) = firstName <- value
member this.LastName
with get() = lastName
and set(value) = lastName <- value
member this.Balance
with get() = balance
and set(value) = balance <- value
member this.Deposit(amount: float) = this.Balance <- this.Balance + amount
member this.Withdraw(amount: float) = this.Balance <- this.Balance - amount
let account1 = new Account(AccountNumber=8782108,
FirstName="Darren", LastName="Parker",
Balance=1543.33)
Další informace naleznete v tématu konstruktory (F#).
Volitelné parametry
Otazník názvem parametr můžete zadat volitelný parametr metoda .Volitelné parametry jsou interpretovány jako možnost Typ F#, takže můžete dotaz je běžným způsobem, který možnost typy jsou dotazovány, pomocí match výrazu s Some a None.Volitelné parametry jsou povoleny pouze na členy nejsou na vytvořené pomocí funkce let vazby.
Můžete také použít funkce defaultArg, který nastaví výchozí hodnota nepovinný argument.defaultArg funkce má volitelný parametr jako první argument a výchozí hodnota jako druhý.
Následující příklad ukazuje použití volitelných parametrů.
type DuplexType =
| Full
| Half
type Connection(?rate0 : int, ?duplex0 : DuplexType, ?parity0 : bool) =
let duplex = defaultArg duplex0 Full
let parity = defaultArg parity0 false
let mutable rate = match rate0 with
| Some rate1 -> rate1
| None -> match duplex with
| Full -> 9600
| Half -> 4800
do printfn "Baud Rate: %d Duplex: %A Parity: %b" rate duplex parity
let conn1 = Connection(duplex0 = Full)
let conn2 = Connection(duplex0 = Half)
let conn3 = Connection(300, Half, true)
Výstup je takto.
Baud Rate: 9600 Duplex: Full Parity: false
Baud Rate: 4800 Duplex: Half Parity: false
Baud Rate: 300 Duplex: Half Parity: true
Předání odkazem
F# podporuje byref klíčové slovo, které určuje, že parametr je předána odkazovat se. To znamená, že po spuštění funkcebudou zachovány všechny změny hodnoty.Hodnoty, které jsou poskytovány byref parametr musí být proměnlivých. Můžete také předat odkazovat se na buňky příslušného typu.
odkazovat se v předávání.NET jazyků evolved tak vrátit více než jednu hodnotu z funkce.F# n-tice vrátit k tomuto účelu nebo použít jako parametrproměnlivých odkazovat se buňku.byref parametr hlavně stanovené spolupráce s.NET knihoven.
Následující příklady ilustrují použití byref klíčové slovo. Poznámka: Použijete-li odkazovat se buňku jako parametr, musíte vytvořit odkazovat se buňku jako pojmenovanou hodnotu a použití, který jako parametrnejen přidat ref operátor , jak je uvedeno v první volání Increment v následujícím kódu. Protože vytváření odkazovat se buňku vytvoříte kopii podkladové hodnoty, první volání pouze zvýší dočasná hodnota.
type Incrementor(z) =
member this.Increment(i : int byref) =
i <- i + z
let incrementor = new Incrementor(1)
let mutable x = 10
// Not recommended: Does not actually increment the variable.
incrementor.Increment(ref x)
// Prints 10.
printfn "%d" x
let mutable y = 10
incrementor.Increment(&y)
// Prints 11.
printfn "%d" y
let refInt = ref 10
incrementor.Increment(refInt)
// Prints 11.
printfn "%d" !refInt
N-tice vrácenou hodnotu můžete použít k uložení libovolné out v parametrech.NET knihovna metody.Alternativně můžete pracovat outjako parametr byref parametr. Následující příklad kódu ukazuje obou způsobů.
// TryParse has a second parameter that is an out parameter
// of type System.DateTime.
let (b, dt) = System.DateTime.TryParse("12-20-04 12:21:00")
printfn "%b %A" b dt
// The same call, using an address of operator.
let mutable dt2 = System.DateTime.Now
let b2 = System.DateTime.TryParse("12-20-04 12:21:00", &dt2)
printfn "%b %A" b2 dt2
Parametr matice
Někdy je nezbytné definovat libovolný počet parametrů typu heterogenní trvá funkce .By nebylo praktické vytvořit všechny možné přetížení metody na účet pro všechny typy, které by mohly být použity.Na.NET platforma poskytuje podporu pro takové metody, které prostřednictvím pole parametr funkce.metoda přebírá parametr pole signatura lze poskytnout s libovolný počet parametrů.Parametry jsou vloženy do pole.Typ prvků pole určuje typy parametr , které lze předat funkce.Je-li definovat parametr pole s Object jako typ prvku pak klientský kód hodnoty předat libovolného typu.
V F# lze parametr pole definovat pouze v metodách.Nelze je použít v samostatné funkce nebo funkcí, které jsou definovány v modulech.
Definujete pole parametr pomocí atributParamArray.ParamArray, který může být pouze atribut použije poslední parametr.
Následující kód ilustruje, jak volací.NET metoda , která přebírá parametr array a definice typu F# který má metoda přebírá parametr array.
open System
type X() =
member this.F([<ParamArray>] args: Object[]) =
for arg in args do
printfn "%A" arg
[<EntryPoint>]
let main _ =
// call a .NET method that takes a parameter array, passing values of various types
Console.WriteLine("a {0} {1} {2} {3} {4}", 1, 10.0, "Hello world", 1u, true)
let xobj = new X()
// call an F# method that takes a parameter array, passing values of various types
xobj.F("a", 1, 10.0, "Hello world", 1u, true)
0
Při spuštění aplikace projekt, je výstup předchozího kódu takto:
a 1 10 Hello world 1 True
"a"
1
10.0
"Hello world"
1u
true