Vraag Waarom geen opgeslagen typeeigenschappen voor klassen in snel?


Toen ik via de Swift-programmeertaal aan het werk was, was ik verrast dat, in tegenstelling tot structuren en opsommingen, klassen geen eigenschappen van opgeslagen typen ondersteunen.

Dit is een standaardkenmerk van andere OO-talen, dus ik neem aan dat er een goede reden is waarom ze hebben besloten het niet toe te staan. Maar ik kan niet raden wat die reden is, vooral omdat structuren (en opsommingen) ze hebben.

Is het eenvoudig dat het vroege tijden zijn voor Swift en het is gewoon nog niet geïmplementeerd? Of is er een diepere reden achter het ontwerp van een taalontwerp?

Trouwens, "stored type property" is Swift-terminologie. In andere talen kunnen dit klassenvariabelen worden genoemd. Voorbeeldcode:

struct FooStruct {
    static var storedTypeProp = "struct stored property is OK"
}

FooStruct.storedTypeProp // evaluates to "struct stored property is OK"

class FooClass {
    class var computedClassProp: String { return "computed class property is OK" }

    // class var storedClassProp = "class property not OK" // this won't compile
}

FooClass.computedClassProp // evaluates to "computed class property is OK"

Bewerk:

Ik besef nu dat deze beperking triviaal is om mee te werken, bijvoorbeeld door een geneste structuur met opgeslagen eigenschappen te gebruiken:

class Foo {
    struct Stored {
        static var prop1 = "a stored prop"
    }
}

Foo.Stored.prop1 // evaluates to "a stored prop"
Foo.Stored.prop1 = "new value"
Foo.Stored.prop1 // evaluates to "new value"

Dat lijkt te voorkomen dat ze een reden hebben waarom deze beperking zo ondoorgrondelijk is.

Gegeven dat en de formulering van de compilerboodschap die Martin Gordon noemt, moet ik concluderen dat dit gewoon iets (minder belangrijks) is.


37
2018-06-04 05:19


oorsprong


antwoorden:


De compileerfout is "Klassenvariabelen nog niet ondersteund", dus het lijkt erop dat ze het nog niet hebben geïmplementeerd.


27
2018-06-04 05:31



De OP's uitbreiden geneste struct-truc voor simuleren opgeslagen type eigenschappen, je kunt verder gaan en het laten lijken alsof het puur is opgeslagen type eigenschap van buiten de klas.

Gebruik een berekend verkrijger en setter paar zoals:

class ClassWithTypeProperty
{
    struct StoredTypeProperties
    {
        static var aTypeProperty: String = "hello world"
    }

    class var aTypeProperty: String
    {
        get { return self.StoredTypeProperties.aTypeProperty }
        set { self.StoredTypeProperties.aTypeProperty = newValue }
    }
}

Dan kunt u doen:

println(ClassWithTypeProperty.aTypeProperty)
// Prints "hello world"

ClassWithTypeProperty.aTypeProperty = "goodbye cruel world"

println(ClassWithTypeProperty.aTypeProperty)
// Prints "goodbye cruel world"

14
2017-11-11 14:46



"Voor waardetypen (dat wil zeggen, structuren en opsommingen), kunt u opgeslagen en berekende type-eigenschappen definiëren. Voor klassen kunt u alleen eigenschappen van het computertype definiëren. "

Fragment van: Apple Inc. "The Swift Programming Language." IBooks. https://itun.es/cn/jEUH0.l

Ik denk dat het voor Apple's Engineers gemakkelijk is om toe te voegen opgeslagen type eigenschappen naar klassen, maar nog niet weten we, misschien nooit naar mijn mening. En daarom zijn er labels ( statisch en klasse ) om ze te onderscheiden.

De belangrijkste reden kan het zijn:

Om te voorkomen dat verschillende objecten een gedeelde veranderbare variabele hebben

wij weten :

static let storedTypeProperty = "StringSample"  // in struct or enum ...

kan worden vervangen door

class var storedTypeProperty:String {return "StringSample" }  // in class

maar

static var storedTypeProperty = "StringSample"  

is moeilijker te vervangen door klasse zin in de klas.

// Ik ben eigenlijk nieuw bij Swift Programming Language en het is mijn eerste antwoord in Stack OverFlow. Leuk om met je te praten. ^^


4
2017-08-19 12:38