ios - programar - swift tutorial español

¿Sabes cuándo una var débil se vuelve nula en Swift?

Question

Digamos que tengo una weak var view: UIView? en mi class Button {} . ¿Hay alguna forma de saber cuándo la view pierde su referencia y se vuelve nil ?

Traté de usar weak var view: UIView? {} weak var view: UIView? {} (también conocida como una propiedad computada) para anular el set {} , pero eso no funcionó porque ahora es una propiedad computada y no puede almacenar una referencia débil (¡qué molesto!).

Editar:

La respuesta de @fqdn no funcionó con este código ... Pruébelo en un patio de Xcode

import UIKit

class Test {
  weak var target: UIView? {
    willSet {
      if !newValue { println("target set to nil") }
      else { println("target set to view") }
    }
  }
}

class Button {
  var view: UIView? = UIView()
}

var t = Test()
var b = Button()
t.target = b.view
b.view = nil // t.target''s willSet should be fired here

Su consola de salida debe mostrar:

target set to view
target set to nil

Mi consola muestra

target set to view

b.view es la referencia fuerte para la instancia UIView. t.target es la referencia débil. Por lo tanto, si b.view se establece en nil , la instancia de UIView se desasigna y t.target será igual a nil.

Answer 1

Si su botón contiene una referencia a otra vista, debe ser un propietario de esa vista (es decir, debe tener una referencia fuerte) o no debe importarle cuándo esa vista se va (es decir, su referencia débil a ella se vuelve nula). .) No hay notificación cuando las referencias débiles se vuelven nulas, y eso es por diseño.

En particular, no se llama a los observadores de la propiedad Swift cuando las referencias débiles se vuelven nulas, como lo demuestra el siguiente código:

class A : CustomStringConvertible {
    var s: String?

    init(s: String) {
        self.s = s;
        print("/(self) init")
    }

    deinit {
        print("/(self) deinit")
    }

    var description: String {
        get { return "[A s:/(s ?? "nil")]" }
    }
}

class B : CustomStringConvertible {
    weak var a:A? {
        willSet {
            print("/(self) willSet a")
        }
        didSet {
            print("/(self) didSet a")
        }
    }

    init(a: A?) {
        self.a = a
        print("/(self) init")
    }

    deinit {
        print("/(self) deinit")
    }

    var description: String {
        get { return "[B a:/(a == nil ? "nil" : String(describing: a!))]" }
    }
}

func work() {
    var a: A? = A(s: "Hello")
    var b = B(a: a)
    print("/(b)")
    a = nil
    print("/(b)")
    b.a = A(s: "Goodbye")
}

work()

Cuando se llama a work() , la consola da el siguiente resultado:

[A s:Hello] init
[B a:[A s:Hello]] init
[B a:[A s:Hello]]
[A s:Hello] deinit
[B a:nil]
[A s:Goodbye] init
[B a:nil] willSet a
[B a:[A s:Goodbye]] didSet a
[A s:Goodbye] deinit
[B a:nil] deinit

Observe que en ningún caso de la instancia de A desasignada y su referencia débil en el caso de que B sea nula, se llama a los observadores de propiedad. Sólo en el caso directo de asignación a Ba se llaman.