คุณสมบัติอ่านอย่างเดียวที่คำนวณเทียบกับฟังก์ชันใน Swift

ในเซสชัน Introduction to Swift WWDC คุณสมบัติอ่านอย่างเดียวdescriptionจะแสดง:

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

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

มีผลกระทบใด ๆ ในการเลือกแนวทางข้างต้นโดยใช้วิธีการแทน:

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

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

สำหรับฉันแล้วดูเหมือนว่าเหตุผลที่ชัดเจนที่สุดที่คุณจะเลือกคุณสมบัติที่คำนวณแบบอ่านอย่างเดียวคือ:

• ความหมาย - ในตัวอย่างนี้เหมาะสมdescriptionที่จะเป็นคุณสมบัติของคลาสแทนที่จะเป็นการกระทำ
• ความกะทัดรัด / ความชัดเจน - ป้องกันไม่ให้ต้องใช้วงเล็บว่างเมื่อได้รับค่า

เห็นได้ชัดว่าตัวอย่างข้างต้นเรียบง่ายเกินไป แต่มีเหตุผลที่ดีอื่น ๆ ในการเลือกอย่างใดอย่างหนึ่ง ตัวอย่างเช่นมีคุณสมบัติบางอย่างของฟังก์ชันหรือคุณสมบัติที่จะเป็นแนวทางในการตัดสินใจของคุณว่าจะใช้อะไร?

NB เมื่อมองแวบแรกดูเหมือนว่าคำถาม OOP ทั่วไป แต่ฉันอยากทราบคุณสมบัติเฉพาะของ Swift ที่จะแนะนำแนวทางปฏิบัติที่ดีที่สุดเมื่อใช้ภาษานี้

สำหรับฉันแล้วดูเหมือนว่าส่วนใหญ่จะเป็นเรื่องของรูปแบบ: ฉันชอบใช้คุณสมบัติเพียงอย่างเดียว: คุณสมบัติ; หมายถึงค่าง่ายๆที่คุณจะได้รับและ / หรือตั้งค่า ฉันใช้ฟังก์ชัน (หรือวิธีการ) เมื่อต้องทำงานจริง อาจจะต้องคำนวณหรืออ่านบางอย่างจากดิสก์หรือจากฐานข้อมูล: ในกรณีนี้ฉันใช้ฟังก์ชันแม้ว่าจะส่งคืนค่าธรรมดาเท่านั้น ด้วยวิธีนี้ฉันสามารถดูได้อย่างง่ายดายว่าการโทรนั้นถูก (คุณสมบัติ) หรืออาจแพง (ฟังก์ชัน)

เราอาจจะได้รับความชัดเจนมากขึ้นเมื่อ Apple เผยแพร่อนุสัญญาการเข้ารหัส Swift บางส่วน

ดีที่คุณสามารถนำไปใช้ Kotlin 's คำแนะนำhttps://kotlinlang.org/docs/reference/coding-conventions.html#functions-vs-properties

ในบางกรณีฟังก์ชันที่ไม่มีอาร์กิวเมนต์อาจใช้แทนกันได้กับคุณสมบัติอ่านอย่างเดียว แม้ว่าความหมายจะคล้ายกัน แต่ก็มีการประชุมโวหารบางประการเกี่ยวกับเวลาที่จะชอบอีกแบบหนึ่ง

ชอบคุณสมบัติมากกว่าฟังก์ชันเมื่ออัลกอริทึมพื้นฐาน:

• ไม่โยน
• ความซับซ้อนมีราคาถูกในการคำนวณ (หรือคำนวณในการวิ่งครั้งแรก)
• ส่งคืนผลลัพธ์เดียวกันในการเรียกใช้

ในขณะที่คำถามเกี่ยวกับคุณสมบัติที่คำนวณเทียบกับวิธีการโดยทั่วไปนั้นยากและเป็นอัตวิสัย แต่ปัจจุบันมีข้อโต้แย้งที่สำคัญอย่างหนึ่งในกรณีของ Swift สำหรับการเลือกวิธีการมากกว่าคุณสมบัติ คุณสามารถใช้วิธีการใน Swift เป็นฟังก์ชันบริสุทธิ์ซึ่งไม่เป็นความจริงสำหรับคุณสมบัติ (ณ Swift 2.0 เบต้า) ทำให้วิธีการนี้มีประสิทธิภาพและมีประโยชน์มากขึ้นเนื่องจากสามารถมีส่วนร่วมในองค์ประกอบการทำงานได้

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

เนื่องจากรันไทม์เหมือนกันคำถามนี้จึงใช้กับ Objective-C เช่นกัน ฉันจะบอกว่าด้วยคุณสมบัติที่คุณจะได้รับ

• ความเป็นไปได้ในการเพิ่มตัวเซ็ตในคลาสย่อยทำให้คุณสมบัติ readwrite
• ความสามารถในการใช้ KVO /didSetสำหรับการแจ้งเตือนการเปลี่ยนแปลง
• โดยทั่วไปคุณสามารถส่งคุณสมบัติไปยังเมธอดที่คาดว่าจะมีพา ธ หลักเช่นการจัดเรียงคำร้องขอดึงข้อมูล

สำหรับสิ่งที่เฉพาะเจาะจงสำหรับ Swift ตัวอย่างเดียวที่ฉันมีคือคุณสามารถใช้@lazyสำหรับคุณสมบัติ

มีความแตกต่าง: หากคุณใช้พร็อพเพอร์ตี้คุณสามารถแทนที่มันและทำให้มันอ่าน / เขียนในคลาสย่อยได้ในที่สุด

ในกรณีอ่านอย่างเดียวคุณสมบัติที่คำนวณไม่ควรถือว่ามีความหมายเทียบเท่ากับวิธีการแม้ว่าจะมีพฤติกรรมเหมือนกันก็ตามเนื่องจากการทิ้งการfuncประกาศทำให้ความแตกต่างระหว่างปริมาณที่ประกอบด้วยสถานะของอินสแตนซ์และปริมาณที่เป็นเพียงฟังก์ชันของ สถานะ. คุณบันทึกการพิมพ์()ที่ไซต์การโทร แต่เสี่ยงต่อการสูญเสียความชัดเจนในรหัสของคุณ

เป็นตัวอย่างเล็กน้อยให้พิจารณาประเภทเวกเตอร์ต่อไปนี้:

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

ด้วยการประกาศความยาวเป็นวิธีการเป็นที่ชัดเจนว่ามันเป็นหน้าที่ของสถานะซึ่งขึ้นอยู่กับxและyและ

ในทางกลับกันถ้าคุณแสดงlengthเป็นคุณสมบัติที่คำนวณได้

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

จากนั้นเมื่อคุณดอทแท็บสมบูรณ์ใน IDE ของคุณในตัวอย่างของVectorWithLengthAsPropertyมันจะดูราวกับว่าx, y, lengthมีคุณสมบัติที่เท่าเทียมซึ่งไม่ถูกต้องแนวคิด

มีสถานการณ์ที่คุณต้องการคุณสมบัติที่คำนวณมากกว่าฟังก์ชันปกติ เช่น: คืนชื่อเต็มของบุคคล คุณทราบชื่อและนามสกุลแล้ว ดังนั้นจริงๆfullNameคุณสมบัติเป็นที่พักไม่ได้ฟังก์ชั่น ในกรณีนี้เป็นคุณสมบัติที่คำนวณได้ (เนื่องจากคุณไม่สามารถตั้งชื่อเต็มได้คุณสามารถแยกออกโดยใช้ชื่อและนามสกุล)

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

จากมุมมองของประสิทธิภาพดูเหมือนจะไม่แตกต่างกัน ดังที่คุณเห็นในผลการเปรียบเทียบ

สาระสำคัญ

main.swift ข้อมูลโค้ด:

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)

เอาท์พุต:

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

ในแผนภูมิ:

คุณสมบัติที่คำนวณตามความหมายควรควบคู่ไปกับสถานะที่แท้จริงของวัตถุ - หากคุณสมบัติอื่น ๆ ไม่เปลี่ยนแปลงดังนั้นการสืบค้นคุณสมบัติที่คำนวณในเวลาที่ต่างกันควรให้ผลลัพธ์ที่เหมือนกัน (เทียบเคียงผ่าน == หรือ ===) - คล้ายกัน เพื่อเรียกใช้ฟังก์ชันบริสุทธิ์บนวัตถุนั้น

ในทางกลับกันวิธีการนั้นออกมานอกกรอบโดยมีข้อสันนิษฐานว่าเราอาจไม่ได้ผลลัพธ์เหมือนกันเสมอไปเพราะ Swift ไม่มีวิธีทำเครื่องหมายฟังก์ชันว่าบริสุทธิ์ นอกจากนี้วิธีการใน OOP ถือเป็นการกระทำซึ่งหมายความว่าการดำเนินการดังกล่าวอาจส่งผลข้างเคียง หากวิธีการนี้ไม่มีผลข้างเคียงก็สามารถแปลงเป็นคุณสมบัติที่คำนวณได้อย่างปลอดภัย

โปรดทราบว่าข้อความทั้งสองข้อข้างต้นล้วนมาจากมุมมองเชิงความหมายเนื่องจากคุณสมบัติที่คำนวณแล้วอาจมีผลข้างเคียงที่เราไม่คาดคิดและวิธีการจะบริสุทธิ์

คำอธิบายในอดีตเป็นคุณสมบัติของ NSObject และหลายคนคาดหวังว่าจะยังคงเหมือนเดิมใน Swift การเพิ่ม parens หลังจากนั้นจะเพิ่มความสับสนเท่านั้น

แก้ไข: หลังจากการลงคะแนนอย่างโกรธเกรี้ยวฉันต้องชี้แจงบางสิ่งบางอย่าง - หากมีการเข้าถึงผ่าน dot syntax ก็ถือได้ว่าเป็นคุณสมบัติ ไม่สำคัญว่ามีอะไรอยู่ใต้ฝากระโปรง คุณไม่สามารถเข้าถึงวิธีการปกติด้วยไวยากรณ์จุด

นอกจากนี้การเรียกคุณสมบัตินี้ไม่จำเป็นต้องมีค่าเบี้ยประกันพิเศษเช่นในกรณีของ Swift ซึ่งอาจทำให้เกิดความสับสน