Sollen wir in Swift immer das [unbenannte Selbst] innerhalb des Verschlusses benutzen

In der WWDC 2014 session 403 Intermediate Swift und transcriptgab es die folgende Folie

Sollen wir in Swift immer das [unbenannte Selbst] innerhalb des Verschlusses benutzen

Der Sprecher sagte, in diesem Fall, wenn wir nicht verwenden [unowned self] es, es wird ein memory-leak. Bedeutet es, wir sollten immer [unowned self] innen Verschluss?

Auf Zeile 64 der ViewController.swift der Swift-Wetter-appich glaube nicht, verwenden [unowned self]. Aber ich update die Benutzeroberfläche mit einigen @IBOutlets wie self.temperature und self.loadingIndicator. Es kann OK sein, weil alle @IBOutlets I definiert sind weak. Aber zur Sicherheit sollten wir immer [unowned self]?

class TempNotifier {
  var onChange: (Int) -> Void = {_ in }
  var currentTemp = 72
  init() {
    onChange = { [unowned self] temp in
      self.currentTemp = temp
    }
  }
}

InformationsquelleAutor der Frage Jake Lin | 2014-06-20

  1. 677

    Nein, es gibt definitiv Zeiten, in denen Sie nicht wollen, zu verwenden [unowned self]. Manchmal möchte man die Schließung zu erfassen, selbst in, um sich zu vergewissern, dass es noch rund um die Zeit der Stilllegung genannt.

    Beispiel: einem asynchronen Netzwerk-Anfrage

    Wenn Sie eine asynchrone Netzwerk-Anfrage Sie tun wollen die Schließung zu bewahren self wenn die Anfrage beendet ist. Das Objekt kann sonst freigegeben, aber Sie wollen immer noch in der Lage, die Anforderung zu verarbeiten finishing.

    Wann unowned self oder weak self

    Das einzige mal, wo Sie wirklich wollen, verwenden Sie [unowned self] oder [weak self] ist, wenn Sie schaffen würde,starke Referenz-Zyklus. Eine starke Referenz-Zyklus ist, wenn es eine Schleife von Eigentum, wo die Objekte am Ende der Besitz jeder andere (vielleicht durch einen Dritten), und daher werden Sie nie freigegeben, weil Sie beide sicherstellen, dass jede andere Stock herum.

    In dem speziellen Fall, dass eine Schließung, die Sie gerade brauchen, um zu realisieren, dass jede variable, auf die verwiesen wird im inneren erhält "Besitz" von der Schließung. Solange der Verschluss ist rund, diese Objekte werden garantiert, um ringsherum zu sein. Der einzige Weg zu stoppen, dass das Eigentum, ist das [unowned self] oder [weak self]. Also, wenn eine Klasse besitzt einen Verschluss, so dass diese Schließung zeigt eine starke Referenz auf die Klasse, dann haben Sie eine starke Referenz-Zyklus zwischen dem Verschluss und der Klasse. Dies beinhaltet auch wenn die Klasse besitzt etwas, besitzt die Schließung.

    Speziell in dem Beispiel aus dem video

    In dem Beispiel auf der Folie TempNotifier besitzt die Schließung durch die onChange member-Variablen. Wenn Sie sich nicht erklären self als unowneddie Schließung würde auch die eigenen self Schaffung einer starken Referenz-Zyklus.

    Unterschied zwischen unowned und weak

    Den Unterschied zwischen unowned und weak ist, dass weak deklariert ist Optional, während unowned ist nicht. Durch deklarieren es weak bekommen Sie den Fall handhaben, dass es vielleicht der null innerhalb der Schließung an einem gewissen Punkt. Wenn Sie versuchen, Zugriff auf eine unowned variable, die passiert werden null, es stürzt das ganze Programm ab. So verwenden Sie nur unowned wenn Sie sind positiv, die variable wird immer um während der Schließung ist um

    InformationsquelleAutor der Antwort drewag

  2. 134

    Update 11/2016

    Schrieb ich einen Artikel über diese Ausweitung dieser Antwort (in SIL, um zu verstehen, was BOGEN bedeutet), check it out hier.

    Ursprüngliche Antwort

    Den bisherigen Antworten nicht wirklich geben klare Regeln auf, Wann eine über die andere und warum, so lassen Sie mich hinzufügen, ein paar Dinge.

    Den Besitzer oder schwache Diskussion läuft darauf hinaus, eine Frage der Lebensdauer der Variablen und die Schließung verweist.

    Sollen wir in Swift immer das [unbenannte Selbst] innerhalb des Verschlusses benutzen

    - Szenarien

    Können Sie haben zwei mögliche Szenarien:

    1. Schließung haben die gleiche Lebensdauer der Variablen, so dass die Schließung erreichbar sein wird nur solange, bis die variable erreichbar. Die variable und die Schließung haben die gleiche Lebensdauer. In diesem Fall sollten Sie erklären, die als Referenz Besitzer. Ein gängiges Beispiel ist die [unowned self] in vielen Beispiel von kleinen Verschlüssen, die etwas tun, im Rahmen Ihrer Eltern-und das nicht verwiesen wird, überall sonst nicht überleben Ihre Eltern.

    2. Verschluss-Lebensdauer ist unabhängig von der variable, der Verschluss könnte noch referenziert werden, wenn die variable nicht mehr erreichbar. In diesem Fall sollten Sie erklären, die als Referenz schwach und stellen Sie sicher, es ist nicht nil ist, bevor Sie ihn verwenden (nicht mit Gewalt packen). Ein typisches Beispiel HIERFÜR ist die [weak delegate] können Sie sehen einige Beispiele der Schließung, die auf einen nicht vollständig (lifetime-Weise) delegate-Objekt.

    Der Tatsächlichen Nutzung

    So, das wird/sollte Sie tatsächlich nutzen die meisten der Zeit?

    Zitieren Joe Groff aus twitter:

    Besitzer ist schneller und ermöglicht Unveränderlichkeit und nonoptionality.

    Wenn Sie nicht brauchen, schwachen, verwenden Sie es nicht.

    Finden Sie mehr über die Besitzer* Innenleben hier.

    * In der Regel auch bezeichnet als Besitzer(sicher), um anzuzeigen, dass die Prüfungen zur Laufzeit (, die zu einem Absturz führen nach ungültigen Referenzen) durchgeführt werden, bevor der Zugriff auf den Besitzer verweisen.

    InformationsquelleAutor der Antwort Umberto Raimondi

  3. 56

    Wenn selbst werden könnte-null in der Schließung verwenden [schwache selbst -].

    Wenn selbst wird nie null, die in der Schließung verwenden [Besitzer selbst].

    Apple Swift-Dokumentation hat einen großen Teil mit Bildern erklärt den Unterschied zwischen der Verwendung starkeschwachund Besitzer in Verschlüsse:

    https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html

    InformationsquelleAutor der Antwort TenaciousJay

  4. 42

    Hier ist brillante Zitate von Apple-Entwickler-Foren beschrieben köstliche details:

    unowned vs unowned(safe) vs unowned(unsafe)

    unowned(safe) ist eine nicht-Besitz-Verweis, der behauptet, über den Zugang, die
    das Objekt ist noch am Leben. Es ist irgendwie wie ein schwacher optionale Referenz
    das ist implizit unwrapped mit x! jedes mal, wenn auf Sie zugegriffen wird.
    unowned(unsafe) ist wie __unsafe_unretained im ARC—es ist ein nicht-besitzenden
    Referenz, aber es gibt keine runtime-überprüfen, dass das Objekt noch am Leben
    über den Zugang, so baumelnden Referenzen reach-in-garbage-Speicher.
    unowned ist immer ein synonym für unowned(safe) aktuell, aber die
    Absicht ist, dass es optimiert wird, um unowned(unsafe) im -Ofast
    baut, wenn Laufzeit-checks deaktiviert sind.

    unowned vs weak

    unowned tatsächlich verwendet eine viel einfachere Umsetzung als weak.
    Native Swift Objekte tragen zwei Referenzzähler, und unowned
    Referenzen stoßen die Besitzer reference count statt der starke
    reference count    . Das Objekt ist deinitialized, wenn seine starke Referenz
    Graf     null erreicht, ist es aber nicht tatsächlich freigegeben ist, bis die
    Besitzer reference count auch null schlägt. Dies bewirkt, dass die Speicher werden
    hielt etwas länger, wenn es unowned Hinweise, aber, dass
    ist normalerweise kein problem, wenn unowned verwendet wird, da die zugehörigen
    Objekte sollten in der Nähe-gleich Leben sowieso, und es ist viel einfacher
    und mit niedrigerem Aufwand als die Seite-Tabelle basierende Implementierung verwendet für
    Nullung schwachen Referenzen.

    Update: In der modernen Swift schwach intern verwendet den gleichen Mechanismus wie Besitzer . Also dieser Vergleich ist falsch, da es vergleicht Objective-C weak mit Swift unonwed.

    Gründen

    Was ist der Zweck, halten die Erinnerung lebendig nach Besitz Referenzen den Wert 0 erreichen? Was passiert, wenn code versucht, etwas zu tun mit
    das Objekt mit einem unowned Referenz nach deinitialized?

    Den
    Erinnerung ist lebendig gehalten, so dass seine behalten zählt die noch verfügbar sind.
    Diese Weise, wenn jemand versucht zu behalten einen starken Bezug auf die
    Besitzer-Objekt, der Laufzeit überprüfen kann, dass die starke Referenz zählen
    größer als null ist, um sicherzustellen, dass es sicher ist, zu behalten
    Objekt.

    Was passiert, Eigentümer oder Besitzer von Referenzen, die vom Objekt verwaltet? Ist Ihre Lebenszeit entkoppelt das Objekt, wenn es deinitialized oder
    ist Ihr Gedächtnis auch beibehalten, bis das Objekt freigegeben wird, nachdem
    der Letzte Besitzer Verweis freigegeben wird?

    Alle Ressourcen, die im Besitz durch das Objekt freigegeben werden, sobald das Objekt
    Letzte starke Referenz wird freigegeben, und seine deinit ausgeführt wird. Besitzer
    Verweise nur halten die Erinnerung am Leben—abgesehen von der Kopfzeile mit dem
    Referenz zählt, ist sein Inhalt ist Müll.

    Aufgeregt, nicht wahr?

    InformationsquelleAutor der Antwort Valentin Shergin

  5. 31

    Ich dachte, ich möchte hinzufügen, einige konkrete Beispiele, die speziell für einen view-controller. Viele der Erklärungen, nicht nur hier auf Stack Overflow sind wirklich gut, aber ich arbeite besser mit der realen Welt Beispiele (@drewag hatte einen guten start auf dieser):

    • Wenn Sie eine Schließung zu behandeln, eine Antwort von einem Netzwerk-Anforderungen verwenden weakweil Sie lange lebte. Der view-controller konnte in der Nähe vor
      die Anforderung abgeschlossen ist, so self nicht mehr Punkte auf ein gültiges Objekt, wenn die Schließung aufgerufen.

    • Wenn Sie Schließung, mit der ein Ereignis auf eine Schaltfläche. Dies kann unowned denn sobald der view-controller Weg geht, der button und alle anderen Elemente, es kann sein, Referenzierung von self geht Weg, zur gleichen Zeit. Die Schließung der block wird auch verschwinden zur gleichen Zeit. 

      class MyViewController: UIViewController {
      @IBOutlet weak var myButton: UIButton!
      let networkManager = NetworkManager()
      let buttonPressClosure: () -> Void //closure must be held in this class. 

      override func viewDidLoad() {
          //use unowned here
          buttonPressClosure = { [unowned self] in
              self.changeDisplayViewMode() //won't happen after vc closes. 
          }
          //use weak here
          networkManager.fetch(query: query) { [weak self] (results, error) in
              self?.updateUI() //could be called any time after vc closes
          }
      }
      @IBAction func buttonPress(self: Any) {
         buttonPressClosure()
      }

      //rest of class below.
 }

    InformationsquelleAutor der Antwort possen

  6. 17

    Gibt es einige gute Antworten hier. Aber die jüngsten änderungen wie Swift implementiert schwache Referenzen sollte sich ändern, jeder ist schwach, selbst gegen Besitzer selbst Verwendungsentscheid treffen. Vorher, wenn Sie gebraucht die beste Leistung mit Besitzer selbst überlegen war, zu schwach selbst, solange Sie sicher sein konnten, dass selbst würde nie null, da der Zugriff auf Besitzer selbst ist viel schneller als der Zugriff auf schwachen selbst.

    Aber Mike Ash hat dokumentiert, wie Swift aktualisiert hat, die Umsetzung schwach vars zu verwenden, Seite-Tabellen und wie diese verbessert spürbar schwache Leistung selbst.

    https://mikeash.com/pyblog/friday-qa-2017-09-22-swift-4-weak-references.html

    Nun, dass es nicht eine signifikante Einbußen bei der Leistung zu schwach selbst, ich glaube, wir sollten standardmäßig verwendet, es geht vorwärts. Der Vorteil der selbst schwach ist, dass es optional, die macht es viel einfacher, mehr zu schreiben richtigen code, es ist im Grunde der Grund Swift ist so eine tolle Sprache. Sie mögen denken, Sie wissen, die Situationen sind sicher für die Verwendung von Besitzer selbst, aber meine Erfahrung die Beurteilung von vielen anderen Entwicklern code ist, die meisten nicht. Habe ich behoben, viele crashes, wo die Besitzer selbst wurde aufgehoben, in der Regel in Situationen, in denen ein hintergrund-thread schließt, nachdem ein Domänencontroller freigegeben wird.

    Bugs und Abstürze sind die meisten zeitaufwendig, schmerzhaft und teuer Teile der Programmierung. Tun Sie Ihr bestes, richtigen code zu schreiben und Sie zu vermeiden. Ich empfehle, machen Sie es sich zur Regel, nie mit Gewalt packen Sie Optionen, und verwenden Sie niemals Besitzer selbst anstelle des schwachen selbst. Sie nichts verlieren, fehlt den Zeiten Kraft Ausgliedern und Besitzer selbst wirklich sicher sind. Aber Sie gewinnen eine Menge durch den Wegfall schwer zu finden und Debuggen von Abstürzen und bugs.

    InformationsquelleAutor der Antwort Randy Hill

  7. 2

    Laut Apple-doc

    • Schwache Referenzen sind immer von einem optionalen type, und automatisch
      werden null, wenn die Instanz, auf die Sie verweisen, ist die Zuordnung aufgehoben.

    • Wenn das aufgenommene Referenz wird nie zu null, es sollte immer erfasst werden, wie einem unowned Referenz, eher als eine schwache Referenz

    Beispiel - 

        //if my response can nil use  [weak self]
      resource.request().onComplete { [weak self] response in
      guard let strongSelf = self else {
        return
      }
      let model = strongSelf.updateModel(response)
      strongSelf.updateUI(model)
     }

    //Only use [unowned self] unowned if guarantees that response never nil  
      resource.request().onComplete { [unowned self] response in
      let model = self.updateModel(response)
      self.updateUI(model)
     }

    InformationsquelleAutor der Antwort Jack

Schreibe einen Kommentar