ios - library - ¿Por qué no puedo usar el protocolo let in en Swift?

swift libraries

Question

Tengo una duda sobre los protocolos en Swift sobre el uso de var y las palabras clave {get set} .

De la documentación de Apple :

Si un protocolo requiere que una propiedad sea obtenible y configurable, ese requisito de propiedad no puede cumplirse mediante una propiedad almacenada constante o una propiedad calculada de solo lectura. Si el protocolo solo requiere que una propiedad sea obtenible, el requisito puede cumplirse mediante cualquier tipo de propiedad, y es válido que la propiedad también sea configurable si esto es útil para su propio código.

Los requisitos de propiedad siempre se declaran como propiedades variables, prefijadas con la palabra clave var. Las propiedades gettable y settable se indican escribiendo {get set} después de su declaración de tipo, y las propiedades gettable se indican escribiendo {get}.

No puedo entender por qué no puedo usar let . ¿Una var en un protocolo con solo get no es solo un let ?

Algo como esto:

protocol someProtocol
{
var someProperty: String { get }
}

no sería solo:

protocol someProtocol
{
let someProperty: String
}

Me estoy perdiendo algo?

Answer 1

La diferencia es entre

protocol MyProtocol {
let someProperty: String
}

lo cual no tiene sentido: no se supone que un protocolo dicte cómo se define / almacena alguna propiedad, solo que está disponible como una propiedad. Podría ser una propiedad calculada o almacenada, pero eso es para que el implementador decida, no el protocolo en sí.

y

protocol MyProtocol {
var someProperty: String { get } // abstract interface
}
struct MyStruct: MyProtocol {
let someProperty: String // concrete implementation: stored property
}
struct OtherStruct: MyProtocol {
let i: Int
var someProperty: String { return "/(i)" } // concrete implementation: computed property
}

que está perfectamente permitido!

Answer 2

"¿Una var en un protocolo con solo get no es solo un let?" No. Un let indica una constante. Pero ese no es el caso aquí. Considera lo siguiente:

protocol SomeProtocol {
var someProperty: String { get }
}
class SomeClass : SomeProtocol {
var someProperty: String = ""
func cla () {
someProperty = "asd"
}
}
let someInstance = SomeClass()
print(someInstance.someProperty) // outputs ""
someInstance.cla()
print(someInstance.someProperty) // outputs "asd"

El protocolo especifica lo que la clase conforme muestra al exterior: alguna propiedad de tipo String llamada someProperty que al menos puede obtener.

Si el protocolo especifica { get } su clase puede elegir conformarse mediante let someProperty: String = "" pero de manera similar puede elegir conformarse mediante el código anterior. Si, por otro lado, el protocolo especifica { get set } no puede usar let en la implementación, sino que también debe hacerlo configurable.

Un protocolo simplemente no puede definir que un valor tiene que ser constante; tampoco debería hacerlo, es un detalle de implementación que debe ser cuidado (o decidido) por la clase / estructura que lo implementa.