language design - metodos - ¿Por qué no hay propiedades de tipos almacenados para clases en swift?

struct herencia

Question

Trabajando a través del lenguaje de programación Swift, me sorprendí al ver que, a diferencia de las estructuras y enumeraciones, las clases no admiten propiedades de tipos almacenados.

Esta es una característica común de otros lenguajes de OO, así que supongo que había una buena razón por la que decidieron no permitirlo. Pero no puedo adivinar cuál es esa razón, especialmente porque las estructuras (y enumeraciones) las tienen.

¿Es simplemente que es temprano para Swift y simplemente no se ha implementado todavía? ¿O hay una razón más profunda detrás de la decisión de diseño del lenguaje?

Por cierto, "propiedad de tipo almacenado" es la terminología de Swift. En otros idiomas, estas pueden llamarse variables de clase. Código de ejemplo:

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"

Editar:

Ahora me doy cuenta de que esta limitación es trivial, por ejemplo, al usar una estructura anidada con propiedades almacenadas:

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"

Eso parece impedir que sean una razón de diseño del lenguaje profundamente inescrutable para esta limitación.

Dado eso y la redacción del mensaje del compilador que Martin Gordon menciona, tengo que concluir que esto es simplemente algo (menor) omitido.

Answer 1

"Para tipos de valor (es decir, estructuras y enumeraciones), puede definir propiedades de tipo almacenadas y calculadas. Para las clases, puede definir propiedades de tipos computados solamente ".

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

Creo que es fácil para los ingenieros de Apple agregar propiedades de tipos almacenados a las clases, pero aún no lo sabemos, tal vez nunca en mi opinión. Y es por eso que hay etiquetas ( estáticas y de clase ) para distinguirlos.

La razón más importante puede ser:

Para evitar diferentes objetos, hemos compartido variables intercambiables

sabemos :

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

puede ser reemplazado por

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

pero

static var storedTypeProperty = "StringSample"

es más difícil ser reemplazado por la frase de clase en clase.

// Soy nuevo en Swift Programming Language en realidad y es mi primera respuesta en . Me alegra discutir con usted. ^^

Answer 2

El error del compilador es "Variables de clase aún no soportadas", así que parece que aún no lo han implementado.

Answer 3

Extendiendo el truco de estructura anidada de OP para simular propiedades de tipos almacenados , puede ir más allá y hacer que parezca una propiedad de tipo almacenado puro desde fuera de la clase.

Use un par getter calculado y setter como:

class ClassWithTypeProperty
{
struct StoredTypeProperties
{
static var aTypeProperty: String = "hello world"
}
class var aTypeProperty: String
{
get { return self.StoredTypeProperties.aTypeProperty }
set { self.StoredTypeProperties.aTypeProperty = newValue }
}
}

Entonces puedes hacer:

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