through - properties swift

Captadores y establecedores de propiedades

Question

Con esta clase simple recibo la advertencia del compilador "Intentando modificar / acceder a ''x'' dentro de su propio setter / getter" y cuando lo uso así:

var p: point = Point()
p.x = 12

Obtengo un EXC_BAD_ACCESS. ¿Cómo puedo hacer esto sin ivars de respaldo explícitos?

class Point {
var x: Int {
set {
x = newValue * 2 //Error
}
get {
return x / 2 //Error
}
}
// ...
}

Answer 1

Actualización: Swift 4

En el setter y getter de clase inferior se aplica a sideLength variable

class Triangle: {
var sideLength: Double = 0.0
init(sideLength: Double, name: String) { //initializer method
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 3
}
var perimeter: Double {
get { // getter
return 3.0 * sideLength
}
set { //setter
sideLength = newValue / 4.0
}
}

Creando un objeto

var triangle = Triangle(sideLength: 3.9, name: "a triangle")

Adquiridor

print(triangle.perimeter) // invoking getter

Setter

triangle.perimeter = 9.9 // invoking setter

Answer 2

Estás definiendo recursivamente x con x . Como si alguien te preguntara ¿cuántos años tienes? Y respondes "Tengo el doble de mi edad". Que no tiene sentido

Debes decir que tengo el doble de la edad de John o cualquier otra variable que no seas tú mismo.

las variables calculadas siempre dependen de otra variable.

Answer 3

Intenta usar esto:

var x:Int!
var xTimesTwo:Int {
get {
return x * 2
}
set {
x = newValue / 2
}
}

Esta es básicamente la respuesta de Jack Wu, pero la diferencia es que en la respuesta de Jack Wu su variable x es var x: Int , en el mío, mi variable x es así: var x: Int! , así que todo lo que hice fue convertirlo en un tipo opcional.

Answer 4

Para anular setter y getter para variables rápidas, use el siguiente código

var temX : Int?
var x: Int?{
set(newX){
temX = newX
}
get{
return temX
}
}

Necesitamos mantener el valor de la variable en una variable temporal, ya que intentar acceder a la misma variable cuyo getter / setter se está anulando dará como resultado bucles infinitos.

Podemos invocar al colocador simplemente así

x = 10

Getter se invocará al disparar debajo de la línea de código dada

var newVar = x

Answer 5

Para profundizar en la respuesta de GoZoner:

Su verdadero problema aquí es que está llamando recursivamente a su getter.

var x:Int
{
set
{
x = newValue * 2 // This isn''t a problem
}
get {
return x / 2 // Here is your real issue, you are recursively calling
// your x property''s getter
}
}

Al igual que el comentario del código sugiere más arriba, está llamando infinitamente al captador de la propiedad x, que continuará ejecutándose hasta que obtenga un código EXC_BAD_ACCESS (puede ver el rotador en la esquina inferior derecha del entorno de recreo de su Xcode).

Considere el ejemplo de la documentación de Swift :

struct Point {
var x = 0.0, y = 0.0
}
struct Size {
var width = 0.0, height = 0.0
}
struct AlternativeRect {
var origin = Point()
var size = Size()
var center: Point {
get {
let centerX = origin.x + (size.width / 2)
let centerY = origin.y + (size.height / 2)
return Point(x: centerX, y: centerY)
}
set {
origin.x = newValue.x - (size.width / 2)
origin.y = newValue.y - (size.height / 2)
}
}
}

Observe cómo la propiedad calculada del centro nunca se modifica o se devuelve en la declaración de la variable.

Answer 6

Puede personalizar el valor establecido utilizando el observador de propiedades. Para hacer esto, use ''didSet'' en lugar de ''set''.

class point {
var x:Int {
didSet {
x = x * 2
}
}
...

En cuanto a getter ...

class point {
var doubleX:Int {
get {
return x / 2
}
}
...

Answer 7

Setters y Getters se aplican a las computed properties ; tales propiedades no tienen almacenamiento en la instancia; el valor del captador debe calcularse a partir de otras propiedades de instancia. En su caso, no hay x para ser asignado.

Explícitamente: "¿Cómo puedo hacer esto sin ivars de respaldo explícitos". No puede: necesitará algo para hacer una copia de seguridad de la propiedad calculada. Prueba esto:

class Point {
private var _x: Int = 0 // _x -> backingX
var x: Int {
set { _x = 2 * newValue }
get { return _x / 2 }
}
}

Específicamente, en el REPL de Swift:

 15> var pt = Point()
pt: Point = {
_x = 0
}
16> pt.x = 10
17> pt
$R3: Point = {
_x = 20
}
18> pt.x
$R4: Int = 10

Answer 8

Setters y getters en Swift se aplican a las propiedades / variables calculadas. Estas propiedades / variables no se almacenan realmente en la memoria, sino que se calculan en función del valor de las propiedades / variables almacenadas.

Consulte la documentación de Apple sobre el tema Swift Variable Declarations .

Answer 9

EDITAR : Dado que esta respuesta es obtener algunos votos favorables, me gustaría aclarar que setters / getters en Swift son bastante diferentes a ObjC. La propiedad se convierte en una propiedad calculada, lo que significa que no tiene una variable de respaldo como _x como lo haría en ObjC. En el código de la solución a continuación, puede ver que xTimesTwo no almacena nada, sino que simplemente calcula el resultado de x .

Ver Documentos oficiales en propiedades calculadas .

La funcionalidad que desea también puede ser Property Observers .

Setters / getters son diferentes de lo que eran en Objective-C.

Lo que necesitas es:

var x:Int
var xTimesTwo:Int {
set {
x = newValue / 2
}
get {
return x * 2
}
}

Puede modificar otras propiedades dentro del setter / getters, que es para lo que están diseñadas.