Properti vs fungsi properti baca-saja di Swift

Dalam sesi Pengenalan ke Swift WWDC, properti hanya-baca descriptionditunjukkan:

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

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

Apakah ada implikasi untuk memilih pendekatan di atas daripada menggunakan metode sebagai gantinya:

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

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

Menurut saya, alasan paling jelas mengapa Anda memilih properti hitung hanya-baca adalah:

• Semantik - dalam contoh ini masuk akal untuk descriptionmenjadi properti kelas, daripada tindakan yang dilakukannya.
• Singkat / Kejelasan - mencegah kebutuhan untuk menggunakan tanda kurung kosong saat mendapatkan nilainya.

Jelas sekali contoh di atas terlalu sederhana, tetapi adakah alasan bagus lainnya untuk memilih salah satu dari yang lain? Misalnya, apakah ada beberapa fitur dari fungsi atau properti yang akan memandu keputusan Anda untuk menggunakan?

NB Sekilas ini tampak seperti pertanyaan OOP yang cukup umum, tetapi saya ingin mengetahui fitur khusus Swift yang akan memandu praktik terbaik saat menggunakan bahasa ini.

Bagi saya ini sebagian besar adalah masalah gaya: Saya sangat suka menggunakan properti hanya untuk: properti; artinya nilai-nilai sederhana yang bisa Anda dapatkan dan / atau atur. Saya menggunakan fungsi (atau metode) saat pekerjaan sebenarnya sedang dilakukan. Mungkin sesuatu harus dihitung atau dibaca dari disk atau dari database: Dalam hal ini saya menggunakan fungsi, bahkan ketika hanya nilai sederhana yang dikembalikan. Dengan cara itu saya dapat dengan mudah melihat apakah panggilan itu murah (properti) atau mungkin mahal (fungsi).

Kami mungkin akan mendapatkan lebih banyak kejelasan ketika Apple menerbitkan beberapa konvensi pengkodean Swift.

Nah, Anda bisa menerapkan saran Kotlin https://kotlinlang.org/docs/reference/coding-conventions.html#functions-vs-properties .

Dalam beberapa kasus, fungsi tanpa argumen mungkin dapat dipertukarkan dengan properti hanya-baca. Meskipun semantiknya serupa, ada beberapa ketentuan gaya tentang kapan harus memilih satu sama lain.

Lebih memilih properti daripada fungsi ketika algoritma yang mendasari:

• tidak melempar
• kompleksitas itu murah untuk dihitung (atau direkam saat dijalankan pertama kali)
• mengembalikan hasil yang sama atas pemanggilan

Sementara pertanyaan tentang properti yang dihitung vs metode secara umum sulit dan subjektif, saat ini ada satu argumen penting dalam kasus Swift untuk lebih memilih metode daripada properti. Anda dapat menggunakan metode di Swift sebagai fungsi murni yang tidak berlaku untuk properti (mulai Swift 2.0 beta). Ini membuat metode jauh lebih kuat dan berguna karena mereka dapat berpartisipasi dalam komposisi fungsional.

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

Karena waktu prosesnya sama, pertanyaan ini juga berlaku untuk Objective-C. Menurut saya, dengan properti yang Anda dapatkan

• kemungkinan menambahkan setter dalam subclass, membuat properti readwrite
• kemampuan untuk menggunakan KVO / didSetuntuk pemberitahuan perubahan
• secara lebih umum, Anda bisa meneruskan properti ke metode yang mengharapkan jalur kunci, misalnya penyortiran permintaan pengambilan

Mengenai sesuatu yang spesifik untuk Swift, satu-satunya contoh yang saya miliki adalah yang dapat Anda gunakan @lazyuntuk sebuah properti.

Ada perbedaan: Jika Anda menggunakan properti, Anda akhirnya dapat menimpanya dan membuatnya menjadi baca / tulis dalam subclass.

Dalam kasus hanya-baca, properti yang dihitung tidak boleh dianggap ekuivalen secara semantik dengan suatu metode, bahkan ketika mereka berperilaku identik, karena menghapus funcdeklarasi mengaburkan perbedaan antara kuantitas yang menyusun keadaan instance dan kuantitas yang hanya merupakan fungsi dari negara. Anda tidak perlu mengetik ()di situs panggilan, tetapi berisiko kehilangan kejelasan dalam kode Anda.

Sebagai contoh sepele, pertimbangkan jenis vektor berikut:

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

Dengan mendeklarasikan panjangnya sebagai metode, jelas bahwa itu adalah fungsi dari status, yang hanya bergantung pada xdan y.

Di sisi lain, jika Anda mengekspresikan lengthsebagai properti yang dihitung

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

maka ketika Anda dot-tab-lengkap dalam IDE Anda pada sebuah contoh dari VectorWithLengthAsProperty, itu akan terlihat seolah-olah x, y, lengthadalah sifat pada pijakan yang sama, yang secara konseptual tidak benar.

Ada situasi di mana Anda lebih memilih properti yang dihitung daripada fungsi normal. Seperti: mengembalikan nama lengkap seseorang. Anda sudah tahu nama depan dan nama belakangnya. Jadi sebenarnya fullNameproperti adalah properti, bukan fungsi. Dalam hal ini, ini adalah properti yang dihitung (karena Anda tidak dapat mengatur nama lengkap, Anda bisa mengekstraknya menggunakan nama depan dan nama belakang)

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

Dari segi kinerja, sepertinya tidak ada perbedaan. Seperti yang Anda lihat di hasil benchmark.

inti

main.swift potongan kode:

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)

Keluaran:

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

Dalam Bagan:

Berbicara secara semantik, properti yang dihitung harus digabungkan erat dengan keadaan intrinsik objek - jika properti lain tidak berubah, maka menanyakan properti yang dihitung pada waktu yang berbeda akan memberikan output yang sama (sebanding melalui == atau ===) - serupa untuk memanggil fungsi murni pada objek itu.

Metode di sisi lain keluar dari kotak dengan asumsi bahwa kita mungkin tidak selalu mendapatkan hasil yang sama, karena Swift tidak memiliki cara untuk menandai fungsi sebagai murni. Juga, metode dalam OOP dianggap tindakan, yang berarti bahwa menjalankannya dapat mengakibatkan efek samping. Jika metode tersebut tidak memiliki efek samping, maka metode tersebut dapat dengan aman diubah menjadi properti yang dihitung.

Perhatikan bahwa kedua pernyataan di atas murni dari perspektif semantik, karena mungkin saja properti yang dihitung memiliki efek samping yang tidak diharapkan, dan metode menjadi murni.

Secara historis, deskripsi adalah properti di NSObject dan banyak yang berharap bahwa itu terus sama di Swift. Menambahkan tanda kurung setelah itu hanya akan menambah kebingungan.

EDIT: Setelah downvoting besar-besaran saya harus mengklarifikasi sesuatu - jika diakses melalui sintaks titik, itu dapat dianggap sebagai properti. Tidak peduli apa yang ada di bawah tenda. Anda tidak dapat mengakses metode biasa dengan sintaks titik.

Selain itu, memanggil properti ini tidak memerlukan orang tua tambahan, seperti dalam kasus Swift, yang dapat menyebabkan kebingungan.