Swift'de hesaplanmış salt okunur özellik ve işlev

Swift WWDC'ye Giriş oturumunda, salt okunur bir özellik descriptiongösterilmektedir:

class Vehicle {
    var numberOfWheels = 0
    var description: String {
        return "\(numberOfWheels) wheels"
    }
}

let vehicle = Vehicle()
println(vehicle.description)

Bunun yerine bir yöntemi kullanmak yerine yukarıdaki yaklaşımı seçmenin herhangi bir etkisi var mı?

class Vehicle {
    var numberOfWheels = 0
    func description() -> String {
        return "\(numberOfWheels) wheels"
    }
}

let vehicle = Vehicle()
println(vehicle.description())

Bana öyle geliyor ki, salt okunur bir hesaplanmış özelliği seçmenizin en bariz nedenleri:

• Anlambilim - bu örnekte description, gerçekleştirdiği bir eylemden ziyade sınıfın bir özelliği olması mantıklıdır .
• Kısalık / Netlik - değeri alırken boş parantez kullanma ihtiyacını önler.

Açıkça yukarıdaki örnek fazlasıyla basit, ancak birini diğerine tercih etmek için başka iyi nedenler var mı? Örneğin, hangisini kullanacağınıza karar vermenize yol gösterecek işlevlerin veya özelliklerin bazı özellikleri var mı?

NB İlk bakışta bu oldukça yaygın bir OOP sorusu gibi görünüyor, ancak bu dili kullanırken en iyi uygulamayı yönlendirecek Swift'e özgü özellikleri bilmek istiyorum.

Bana öyle geliyor ki bu çoğunlukla bir stil meselesi: Sadece bunun için özellikleri kullanmayı kesinlikle tercih ediyorum : özellikler; elde edebileceğiniz ve / veya ayarlayabileceğiniz basit değerler anlamına gelir. Fiili iş yapılırken işlevleri (veya yöntemleri) kullanıyorum . Belki bir şeyin hesaplanması veya diskten veya bir veritabanından okunması gerekir: Bu durumda, yalnızca basit bir değer döndürüldüğünde bile bir işlev kullanıyorum. Bu şekilde, bir aramanın ucuz (özellikler) veya muhtemelen pahalı (işlevler) olup olmadığını kolayca görebilirim.

Apple bazı Swift kodlama kurallarını yayınladığında muhtemelen daha fazla netlik elde edeceğiz.

Eh, Kotlin'in tavsiyelerini https://kotlinlang.org/docs/reference/coding-conventions.html#functions-vs-properties uygulayabilirsiniz .

Bazı durumlarda, bağımsız değişkeni olmayan işlevler salt okunur özelliklerle değiştirilebilir. Anlambilim benzer olsa da, birini diğerine ne zaman tercih edeceğine dair bazı stil kuralları vardır.

Altta yatan algoritma aşağıdaki durumlarda işlev yerine bir özelliği tercih eder:

• atmaz
• karmaşıklığın hesaplanması ucuzdur (veya ilk çalıştırmada hesaplanır)
• çağrılarda aynı sonucu döndürür

Genel olarak hesaplanmış özelliklere karşı yöntemler sorusu zor ve öznel olsa da, şu anda Swift'in durumunda, yöntemleri özelliklere tercih etme konusunda önemli bir argüman var. Swift'deki yöntemleri, özellikler için doğru olmayan saf işlevler olarak kullanabilirsiniz (Swift 2.0 beta'dan itibaren). Bu, fonksiyonel bileşime katılabildikleri için yöntemleri çok daha güçlü ve kullanışlı hale getirir.

func fflat<A, R>(f: (A) -> () -> (R)) -> (A) -> (R) {
    return { f($0)() }
}

func fnot<A>(f: (A) -> Bool) -> (A) -> (Bool) {
    return { !f($0) }
}

extension String {
    func isEmptyAsFunc() -> Bool {
        return isEmpty
    }
}

let strings = ["Hello", "", "world"]

strings.filter(fnot(fflat(String.isEmptyAsFunc)))

Çalışma zamanı aynı olduğundan, bu soru aynı zamanda Objective-C için de geçerlidir. Diyorum ki, aldığınız mülklerle

• özelliği oluşturan bir alt sınıfa bir ayarlayıcı ekleme imkanı readwrite
• KVO / didSetdeğişiklik bildirimleri için kullanma yeteneği
• daha genel olarak, özelliği anahtar yolları bekleyen yöntemlere aktarabilirsiniz, örneğin getirme isteği sıralaması

Swift'e özgü bir şeye gelince, sahip olduğum tek örnek @lazy, bir mülk için kullanabileceğinizdir .

Bir fark var: Bir özelliği kullanırsanız, sonunda onu geçersiz kılabilir ve bir alt sınıfta okumasını / yazmasını sağlayabilirsiniz.

Salt okunur durumda, hesaplanan bir özellik, aynı şekilde davransalar bile, anlamsal olarak bir yönteme eşdeğer kabul edilmemelidir , çünkü funcbildirimi kaldırmak, bir örneğin durumunu oluşturan miktarlar ile yalnızca işlevin işlevleri olan miktarlar arasındaki ayrımı bulanıklaştırır . durum. ()Çağrı sitesinde yazmaktan tasarruf edersiniz , ancak kodunuzun netliğini kaybetme riskiyle karşı karşıya kalırsınız.

Önemsiz bir örnek olarak, aşağıdaki vektör türünü düşünün:

struct Vector {
    let x, y: Double
    func length() -> Double {
        return sqrt(x*x + y*y)
    }
}

Bir yöntem olarak uzunluğunu ilan ederek, bunun sadece bağlıdır devlet, bir fonksiyonu var olduğu açıktır xve y.

Öte yandan, lengthhesaplanmış bir mülk olarak ifade edecekseniz

struct VectorWithLengthAsProperty {
    let x, y: Double
    var length: Double {
        return sqrt(x*x + y*y)
    }
}

Eğer örneğinde IDE'nizde sekme tamamlama dot zaman sonra VectorWithLengthAsProperty, o sanki olmazdı x, y, lengthkavramsal olarak yanlıştır eşit, üzerinde özellikleri idi.

Normal işlevler yerine hesaplanmış özelliği tercih edeceğiniz durumlar vardır. Örneğin: bir kişinin tam adını döndürmek. İlk adı ve soyadını zaten biliyorsunuz. Yani gerçekten fullNameözellik bir özelliktir, işlev değil. Bu durumda, hesaplanan özelliktir (tam adı belirleyemediğiniz için, sadece adı ve soyadı kullanarak onu çıkarabilirsiniz)

class Person{
    let firstName: String
    let lastName: String
    init(firstName: String, lastName: String){
        self.firstName = firstName
        self.lastName = lastName
    }
    var fullName :String{
        return firstName+" "+lastName
    }
}
let william = Person(firstName: "William", lastName: "Kinaan")
william.fullName //William Kinaan

Performans açısından bakıldığında hiçbir fark görünmüyor. Kıyaslama sonucunda görebileceğiniz gibi.

ana fikir

main.swift kod pasajı:

import Foundation

class MyClass {
    var prop: Int {
        return 88
    }

    func foo() -> Int {
        return 88
    }
}

func test(times: u_long) {
    func testProp(times: u_long) -> TimeInterval {
        let myClass = MyClass()
        let starting = Date()
        for _ in 0...times {
            _ = myClass.prop
        }
        let ending = Date()
        return ending.timeIntervalSince(starting)
    }


    func testFunc(times: u_long) -> TimeInterval {
        let myClass = MyClass()
        let starting = Date()
        for _ in 0...times {
            _ = myClass.prop
        }
        let ending = Date()
        return ending.timeIntervalSince(starting)
    }

    print("prop: \(testProp(times: times))")
    print("func: \(testFunc(times: times))")
}

test(times: 100000)
test(times: 1000000)
test(times: 10000000)
test(times: 100000000)

Çıktı:

prop: 0.0380070209503174 func: 0.0350250005722046 prop: 0.371925950050354 func: 0.363085985183716 prop: 3.4023300409317 func: 3.38373708724976 prop: 33.5842199325562 func: 34.8433820009232 Program ended with exit code: 0

Tabloda:

Anlamsal olarak konuşursak, hesaplanan özellikler nesnenin içsel durumu ile sıkı bir şekilde birleştirilmelidir - diğer özellikler değişmezse, o zaman hesaplanan özelliği farklı zamanlarda sorgulamak aynı çıktıyı vermelidir (== veya === ile karşılaştırılabilir) - benzer o nesnede saf bir işlev çağırmak.

Öte yandan yöntemler, her zaman aynı sonuçları alamayacağımız varsayımıyla kutudan çıkar, çünkü Swift'in işlevleri saf olarak işaretlemenin bir yolu yoktur. Ayrıca, OOP'deki yöntemler eylemler olarak kabul edilir, bu da onları yürütmenin yan etkilere neden olabileceği anlamına gelir. Yöntemin herhangi bir yan etkisi yoksa, güvenli bir şekilde hesaplanan bir özelliğe dönüştürülebilir.

Yukarıdaki ifadelerin her ikisinin de tamamen anlamsal bir perspektiften olduğuna dikkat edin, çünkü hesaplanan özelliklerin beklemediğimiz yan etkilere sahip olması ve yöntemlerin saf olması da mümkündür.

Tarihsel olarak açıklama NSObject üzerindeki bir özelliktir ve çoğu kişi Swift'de aynı şekilde devam etmesini bekler. Bundan sonra parantez eklemek sadece kafa karışıklığı yaratacaktır.

DÜZENLEME: Öfkeli olumsuz oylamadan sonra bir şeyi açıklığa kavuşturmam gerekiyor - eğer nokta sözdizimi ile erişiliyorsa, bir özellik olarak kabul edilebilir. Kaputun altında ne olduğu önemli değil. Nokta sözdizimi ile olağan yöntemlere erişemezsiniz.

Ayrıca, bu özelliği çağırmak, Swift örneğinde olduğu gibi fazladan parantez gerektirmedi, bu da kafa karışıklığına yol açabilir.