Berechnete schreibgeschützte Eigenschaft vs. Funktion in Swift

In der Einführung in die Swift WWDC-Sitzung wird eine schreibgeschützte Eigenschaft descriptiondemonstriert:

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

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

Gibt es irgendwelche Auswirkungen, wenn Sie stattdessen den oben genannten Ansatz anstelle einer Methode wählen:

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

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

Es scheint mir, dass die offensichtlichsten Gründe, warum Sie sich für eine schreibgeschützte berechnete Eigenschaft entscheiden würden, folgende sind:

• Semantik - In diesem Beispiel ist es sinnvoll description, eine Eigenschaft der Klasse zu sein und keine Aktion, die sie ausführt.
• Kürze / Klarheit - verhindert, dass beim Abrufen des Werts leere Klammern verwendet werden müssen.

Das obige Beispiel ist natürlich zu einfach, aber gibt es andere gute Gründe, sich für eines zu entscheiden? Gibt es beispielsweise einige Merkmale von Funktionen oder Eigenschaften, die Sie bei Ihrer Entscheidung für eine Verwendung unterstützen?

NB Auf den ersten Blick scheint dies eine häufig gestellte OOP-Frage zu sein, aber ich bin gespannt auf alle Swift-spezifischen Funktionen, die als Best Practice bei der Verwendung dieser Sprache dienen.

Es scheint mir, dass es hauptsächlich eine Frage des Stils ist: Ich bevorzuge es stark, Eigenschaften dafür zu verwenden: Eigenschaften; Dies bedeutet einfache Werte, die Sie erhalten und / oder festlegen können. Ich benutze Funktionen (oder Methoden), wenn die eigentliche Arbeit erledigt wird. Möglicherweise muss etwas von der Festplatte oder aus einer Datenbank berechnet oder gelesen werden: In diesem Fall verwende ich eine Funktion, auch wenn nur ein einfacher Wert zurückgegeben wird. Auf diese Weise kann ich leicht erkennen, ob ein Anruf billig (Eigenschaften) oder möglicherweise teuer (Funktionen) ist.

Wir werden wahrscheinlich mehr Klarheit bekommen, wenn Apple einige Swift-Codierungskonventionen veröffentlicht.

Nun, Sie können die Ratschläge von Kotlin unter https://kotlinlang.org/docs/reference/coding-conventions.html#functions-vs-properties anwenden .

In einigen Fällen können Funktionen ohne Argumente durch schreibgeschützte Eigenschaften ausgetauscht werden. Obwohl die Semantik ähnlich ist, gibt es einige stilistische Konventionen, wann man einander vorziehen soll.

Ziehen Sie eine Eigenschaft einer Funktion vor, wenn der zugrunde liegende Algorithmus:

• wirft nicht
• Komplexität ist billig zu berechnen (oder beim ersten Durchlauf zu berechnen)
• Gibt das gleiche Ergebnis über Aufrufe zurück

Während eine Frage der berechneten Eigenschaften gegenüber Methoden im Allgemeinen schwierig und subjektiv ist, gibt es derzeit ein wichtiges Argument im Fall von Swift, um Methoden gegenüber Eigenschaften vorzuziehen. Sie können Methoden in Swift als reine Funktionen verwenden, was für Eigenschaften nicht gilt (ab Swift 2.0 Beta). Dies macht Methoden viel leistungsfähiger und nützlicher, da sie an der funktionellen Zusammensetzung teilnehmen können.

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

Da die Laufzeit gleich ist, gilt diese Frage auch für Objective-C. Ich würde sagen, mit Eigenschaften, die Sie bekommen

• eine Möglichkeit, einen Setter in eine Unterklasse einzufügen, wodurch die Eigenschaft erstellt wird readwrite
• eine Fähigkeit, KVO / zu verwendendidSet für Änderungsbenachrichtigungen zu verwenden
• Im Allgemeinen können Sie Eigenschaften an Methoden übergeben, die Schlüsselpfade erwarten, z. B. das Sortieren von Abrufanforderungen

Was Swift betrifft, ist das einzige Beispiel, das ich habe, dass Sie es @lazyfür eine Eigenschaft verwenden können.

Es gibt einen Unterschied: Wenn Sie eine Eigenschaft verwenden, können Sie sie eventuell überschreiben und in einer Unterklasse lesen / schreiben.

Im schreibgeschützten Fall sollte eine berechnete Eigenschaft nicht als semantisch äquivalent zu einer Methode betrachtet werden, selbst wenn sie sich identisch verhält, da durch das Löschen der funcDeklaration die Unterscheidung zwischen Mengen, die den Status einer Instanz umfassen, und Mengen, die lediglich Funktionen der sind, verwischt wird Zustand. Sie sparen die Eingabe ()an der Anrufstelle, riskieren jedoch, die Klarheit Ihres Codes zu verlieren.

Betrachten Sie als triviales Beispiel den folgenden Vektortyp:

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

Durch die Deklaration der Länge als Methode wird deutlich, dass es sich um eine Funktion des Zustands handelt, die nur von xund abhängt y.

Auf der anderen Seite, wenn Sie lengthals berechnete Eigenschaft ausdrücken würden

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

Wenn Sie dann in Ihrer IDE auf einer Instanz von einen Punkt-Tab-Vervollständigen ausführen VectorWithLengthAsProperty, sieht es so aus, als obx , y, lengthEigenschaften auf gleiche Augenhöhe waren, die konzeptionell falsch ist.

Es gibt Situationen, in denen Sie berechnete Eigenschaften normalen Funktionen vorziehen würden. Zum Beispiel: Rückgabe des vollständigen Namens einer Person. Sie kennen bereits den Vor- und Nachnamen. Also wirklich diefullName Eigenschaft ist eine Eigenschaft, keine Funktion. In diesem Fall handelt es sich um eine berechnete Eigenschaft (da Sie den vollständigen Namen nicht festlegen können, können Sie ihn einfach mit dem Vor- und Nachnamen extrahieren).

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

Aus Sicht der Leistung scheint es keinen Unterschied zu geben. Wie Sie im Benchmark-Ergebnis sehen können.

Kern

main.swift Code-Auszug:

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)

Ausgabe:

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

In der Tabelle:

Semantisch gesehen sollten berechnete Eigenschaften eng mit dem inneren Zustand des Objekts gekoppelt sein. Wenn sich andere Eigenschaften nicht ändern, sollte die Abfrage der berechneten Eigenschaft zu unterschiedlichen Zeiten dieselbe Ausgabe ergeben (vergleichbar über == oder ===) - ähnlich eine reine Funktion für dieses Objekt aufzurufen.

Methoden hingegen werden mit der Annahme ausgeliefert, dass wir möglicherweise nicht immer die gleichen Ergebnisse erzielen, da Swift keine Möglichkeit hat, Funktionen als rein zu kennzeichnen. Außerdem werden Methoden in OOP als Aktionen betrachtet, was bedeutet, dass ihre Ausführung zu Nebenwirkungen führen kann. Wenn die Methode keine Nebenwirkungen hat, kann sie sicher in eine berechnete Eigenschaft konvertiert werden.

Beachten Sie, dass beide obigen Aussagen rein semantisch sind, da es durchaus vorkommen kann, dass berechnete Eigenschaften Nebenwirkungen haben, die wir nicht erwarten, und Methoden rein sind.

Historisch gesehen ist die Beschreibung eine Eigenschaft von NSObject und viele würden erwarten, dass sie in Swift dieselbe bleibt. Das Hinzufügen von Parens nach dem Hinzufügen führt nur zu Verwirrung.

EDIT: Nach heftigem Downvoting muss ich etwas klarstellen - wenn über die Punktsyntax darauf zugegriffen wird, kann es als Eigenschaft betrachtet werden. Es ist egal, was sich unter der Haube befindet. Mit der Punktsyntax können Sie nicht auf übliche Methoden zugreifen.

Außerdem erforderte das Aufrufen dieser Eigenschaft keine zusätzlichen Parens, wie im Fall von Swift, was zu Verwirrung führen kann.