Parametreler ve Bağımsız Değişkenler

Bu konuda, parametreleri tanımlama ve işlevlere, yöntemlere ve özelliklere bağımsız değişkenleri geçirme için dil desteği açıklanmaktadır. Başvuruya göre geçme ve değişken sayıda bağımsız değişken alan yöntemler tanımlama ve kullanma hakkında bilgi içerir.

Parametreler ve Bağımsız Değişkenler

Terimi parametresi , sağlanması beklenen değerlerin adlarını anlatmak için kullanılır. Bağımsız değişkeni , her bir parametre için belirtilen değerler için kullanılır.

Parametreler demet veya curried formunda ya da ikisinin bir birleşimi içinde belirtilebilir. Açık bir parametre adı kullanarak bağımsız değişkenler geçirebilirsiniz. Yöntemlerin parametreleri isteğe bağlı olarak belirtilebilir ve varsayılan bir değer verilir.

Parametre desenleri

İşlevlere ve yöntemlere sağlanan parametreler, genel olarak boşluklarla ayrılmış desenlerdir. Bu, ilke içinde, eşleşme ifadelerinde açıklanan desenlerin herhangi birinin bir işlev veya üye için parametre listesinde kullanılabileceği anlamına gelir.

Yöntemler genellikle bağımsız değişkenlerin geçirilerek demet biçimini kullanır. Bu, diğer .NET dillerinin perspektifinden daha net bir sonuca ulaşır çünkü demet formu, bağımsız değişkenlerin .NET yöntemlerine geçirilmesi ile eşleşir.

Curried form, genellikle bağlamalar kullanılarak oluşturulan işlevlerle kullanılır let .

Aşağıdaki sözde kod, kayıt düzeni ve curried bağımsız değişkenlerinin örneklerini gösterir.

// Tuple form.
member this.SomeMethod(param1, param2) = ...
// Curried form.
let function1 param1 param2 = ...

Bazı bağımsız değişkenler diziler halinde olduğunda ve bazıları olmadığında birleştirilmiş formlar mümkündür.

let function2 param1 (param2a, param2b) param3 = ...

Diğer desenler de parametre listelerinde kullanılabilir, ancak parametre deseni tüm olası girişlerle eşleşmezse, çalışma zamanında tamamlanmamış bir eşleşme olabilir. MatchFailureExceptionBir bağımsız değişkenin değeri, parametre listesinde belirtilen desenlerle eşleşmezse, bu özel durum oluşturulur. Bir parametre deseninin tamamlanmamış eşleştirmelere izin verdiği durumlarda derleyici bir uyarı verir. En az bir diğer model genellikle parametre listeleri için yararlıdır ve bu, joker karakter örüntü. Yalnızca sağlanan bağımsız değişkenleri yoksaymak istediğinizde joker karakter modelini bir parametre listesinde kullanırsınız. Aşağıdaki kod, bir bağımsız değişken listesinde joker karakter deseninin kullanımını gösterir.

let makeList _ = [ for i in 1 .. 100 -> i * i ]
// The arguments 100 and 200 are ignored.
let list1 = makeList 100
let list2 = makeList 200

Joker karakter düzeni, aşağıdaki kodda olduğu gibi, normalde bir dize dizisi olarak sağlanan komut satırı bağımsız değişkenleri ile ilgilenmediğiniz zaman, bir programa yönelik ana giriş noktasında, örneğin, bir program için ana giriş noktasında, bir programın ana giriş noktasındaki bağımsız değişkenlere ihtiyaç duymadığınızda yararlı olabilir.

[<EntryPoint>]
let main _ =
    printfn "Entry point!"
    0

Bazen bağımsız değişkenlerde kullanılan diğer desenler as , düzen ve ayrılmış birleşimler ve etkin desenlerle ilişkili tanımlayıcı desenlerdir. Tek durum ayrılmış birleşim modelini aşağıdaki gibi kullanabilirsiniz.

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

Çıktı aşağıdaki gibidir:

Data begins at 0 and ends at 4 in string Et tu, Brute?
Et tu

Etkin desenler, aşağıdaki örnekte olduğu gibi, bir bağımsız değişken istenen biçime dönüştürülürken parametre olarak yararlı olabilir:

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

asAşağıdaki kod satırında gösterildiği gibi, eşleşen bir değeri yerel bir değer olarak depolamak için, bu kalıbı kullanabilirsiniz.

let GetSubstring2 (Slice(p0, p1, text) as s) = s

Bazen kullanılan başka bir model, işlevin gövdesi olarak, örtük bağımsız değişkende bir model eşleşmesi yapan bir lambda ifadesi sağlayarak adlandırılmamış en son bağımsız değişkeni bir işlev olarak bırakır. Aşağıdaki kod satırı buna bir örnektir.

let isNil = function [] -> true | _::_ -> false

Bu kod, genel liste alan ve true Liste boşsa ve aksi takdirde döndüren bir işlevi tanımlar false . Bu tür tekniklerin kullanımı, kodun okunmasını zorlaştırabilir.

Bazen, tamamlanmamış eşleşmeleri içeren desenler yararlı olur, örneğin, programınızdaki listelerin yalnızca üç öğesi olduğunu biliyorsanız, aşağıdaki gibi bir deseni parametre listesinde kullanabilirsiniz.

let sum [a; b; c;] = a + b + c

Tamamlanmamış eşleşmelerin kullanıldığı desenlerin kullanımı, Hızlı Prototipleme ve diğer geçici kullanımlar için en iyi ayırmıştır. Derleyici bu tür kodlar için bir uyarı verebilir. Bu tür desenler tüm olası girdilerin genel durumunu kapsamaz ve bu nedenle bileşen API 'Leri için uygun değildir.

Adlandırılmış bağımsız değişkenler

Yöntemler için bağımsız değişkenler, virgülle ayrılmış bir bağımsız değişken listesindeki konuma göre belirtilebilir veya ad ve ardından bir eşittir işareti ve geçirilecek değer tarafından açıkça bir yönteme geçirilebilir. Ad sağlanarak belirtilmişse bildirimde kullanılan farklı bir sırada görünebilirler.

Adlandırılmış bağımsız değişkenler, API 'de yöntem parametrelerinin yeniden sıralanması gibi belirli değişiklik türlerine kod daha okunabilir ve daha uyumlu hale getirebilirsiniz.

Adlandırılmış bağımsız değişkenlere yalnızca, for let -bağlanmadı işlevleri, işlev değerleri veya lambda ifadeleri için izin verilir.

Aşağıdaki kod örneği adlandırılmış bağımsız değişkenlerin kullanımını gösterir.

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)

Bir sınıf oluşturucusuna yapılan çağrıda, adlandırılmış bağımsız değişkenlerden benzer bir sözdizimi kullanarak sınıfının özelliklerinin değerlerini ayarlayabilirsiniz. Aşağıdaki örnek bu söz dizimini gösterir.

 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)

Daha fazla bilgi için bkz. oluşturucular (F #).

İsteğe Bağlı Parametreler

Parametre adının önünde bir soru işareti kullanarak, bir yöntem için isteğe bağlı bir parametre belirtebilirsiniz. İsteğe bağlı parametreler F # seçenek türü olarak yorumlanır. bu nedenle, ve ile bir ifade kullanarak bunları seçenek türlerinin sorgulandığı normal şekilde sorgulayabilirsiniz match Some None . İsteğe bağlı parametrelere, bağlamalar kullanılarak oluşturulan işlevlerde değil, yalnızca üyelerde izin verilir let .

İsteğe bağlı değerleri, veya gibi parametre adına göre yönteme geçirebilirsiniz ?arg=None ?arg=Some(3) ?arg=arg . Bu, isteğe bağlı bağımsız değişkenleri başka bir yönteme geçiren bir yöntem oluştururken yararlı olabilir.

defaultArgİsteğe bağlı bir bağımsız değişkenin varsayılan değerini ayarlayan bir işlevi de kullanabilirsiniz. defaultArgİşlevi, isteğe bağlı parametreyi ilk bağımsız değişken olarak ve varsayılan değeri ikinci olarak alır.

Aşağıdaki örnek, isteğe bağlı parametrelerin kullanımını gösterir.

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)
let conn4 = Connection(?duplex0 = None)
let conn5 = Connection(?duplex0 = Some(Full))

let optionalDuplexValue : option<DuplexType> = Some(Half)
let conn6 = Connection(?duplex0 = optionalDuplexValue)

Çıktı aşağıdaki gibidir:

Baud Rate: 9600 Duplex: Full Parity: false
Baud Rate: 4800 Duplex: Half Parity: false
Baud Rate: 300 Duplex: Half Parity: true
Baud Rate: 9600 Duplex: Full Parity: false
Baud Rate: 9600 Duplex: Full Parity: false
Baud Rate: 4800 Duplex: Half Parity: false

C# ve Visual Basic birlikte çalışabilirliğine yönelik [<Optional; DefaultParameterValue<(...)>] olarak, F # içindeki öznitelikleri kullanarak çağıranların isteğe bağlı olarak bir bağımsız değişken görmesini sağlayabilirsiniz. Bu, bağımsız değişkeni C# ' de olduğu gibi isteğe bağlı olarak tanımlamaya eşdeğerdir MyMethod(int i = 3) .

open System
open System.Runtime.InteropServices
type C =
    static member Foo([<Optional; DefaultParameterValue("Hello world")>] message) =
        printfn $"{message}"

Ayrıca, varsayılan parametre değeri olarak yeni bir nesne belirtebilirsiniz. Örneğin, Foo üyenin CancellationToken bunun yerine giriş olarak isteğe bağlı olması olabilir:

open System.Threading
open System.Runtime.InteropServices
type C =
    static member Foo([<Optional; DefaultParameterValue(CancellationToken())>] ct: CancellationToken) =
        printfn $"{ct}"

Bağımsız değişkeni olarak verilen değerin DefaultParameterValue parametrenin türüyle eşleşmesi gerekir. Örneğin, aşağıdakilere izin verilmez:

type C =
    static member Wrong([<Optional; DefaultParameterValue("string")>] i:int) = ()

Bu durumda, derleyici bir uyarı oluşturur ve iki özniteliği de tamamen yoksayar. Diğer bir deyişle, null derleyici yanlış türü (ör.), aksi takdirde, varsayılan değerin tür-açıklama olması gerektiğini unutmayın [<Optional; DefaultParameterValue(null:obj)>] o:obj .

Başvuruya göre geçirme

Bir F # değerinin başvuruya geçirilmesi, yönetilen işaretçi türleri olan ByRef'ler ile ilgilidir. Kullanılacak tür ile ilgili kılavuz aşağıdaki gibidir:

• inref<'T>Yalnızca işaretçiyi okumanız gerekiyorsa kullanın.
• outref<'T>Yalnızca işaretçiye yazmanız gerekiyorsa kullanın.
• byref<'T>Hem okuma hem de işaretçiye yazma gerekiyorsa kullanın.

let example1 (x: inref<int>) = printfn $"It's %d{x}"

let example2 (x: outref<int>) = x <- x + 1

let example3 (x: byref<int>) =
    printfn $"It's %d{x}"
    x <- x + 1

let test () =
    // No need to make it mutable, since it's read-only
    let x = 1
    example1 &x

    // Needs to be mutable, since we write to it
    let mutable y = 2
    example2 &y
    example3 &y // Now 'y' is 3

Parametresi bir işaretçi olduğundan ve değer değişebilir olduğundan, değer üzerinde yapılan tüm değişiklikler işlevin yürütülmesinden sonra tutulur.

.NET kitaplığı yöntemlerinde herhangi bir parametreyi depolamak için bir kayıt düzeni değerini dönüş değeri olarak kullanabilirsiniz out . Alternatif olarak, out parametresini bir parametre olarak kabul edebilirsiniz byref . Aşağıdaki kod örneğinde her iki yol da gösterilmektedir.

// 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

Parametre Dizileri

Bazen heterojen türden rastgele sayıda parametre alan bir işlev tanımlanması gerekir. Tüm olası aşırı yüklenmiş yöntemlerin, kullanılabilecek tüm türlere yönelik olarak oluşturulması pratik değildir. .NET uygulamaları, parametre dizisi özelliği aracılığıyla bu tür yöntemler için destek sağlar. İmzasında parametre dizisi alan bir yöntem, rastgele sayıda parametre ile birlikte etkinleştirilebilir. Parametreler bir diziye konur. Dizi öğelerinin türü, işleve geçirilebilecek parametre türlerini belirler. Parametre dizisini System.Object öğesi türü olarak tanımlarsanız, istemci kodu herhangi bir türdeki değerleri geçirebilir.

F # içinde parametre dizileri yalnızca yöntemlerde tanımlanabilir. Bunlar tek başına işlevlerde veya modüllerde tanımlanmış işlevlerde kullanılamaz.

Özniteliğini kullanarak bir parametre dizisi tanımlarsınız ParamArray . ParamArrayÖzniteliği yalnızca son parametreye uygulanabilir.

Aşağıdaki kod, bir parametre dizisi alan bir .NET yöntemi ve bir parametre dizisi alan bir yöntemi olan F # içindeki bir tür tanımını gösterir.

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

Bir projede çalıştırıldığında, önceki kodun çıktısı aşağıdaki gibidir:

a 1 10 Hello world 1 True
"a"
1
10.0
"Hello world"
1u
true

Ayrıca bkz.

• Üyeler