Wie deklariere ich ein Array von schwachen Referenzen in Swift?

Ich möchte das speichern einer Reihe von schwachen Referenzen in Swift. Das array selbst sollte nicht eine schwache Referenz - Elemente sein sollte. Ich denke, Kakao NSPointerArray bietet eine non-typesafe-version dieses.

InformationsquelleAutor der Frage Bill | 2014-06-09

130

Erstellen Sie eine generische wrapper:
```
class Weak<T: AnyObject> {
  weak var value : T?
  init (value: T) {
    self.value = value
  }
}
```
Hinzufügen von Instanzen dieser Klasse das array.
```
class Stuff {}
var weakly : [Weak<Stuff>] = [Weak(value: Stuff()), Weak(value: Stuff())]
```
Beim definieren Weak können Sie entweder struct oder class.

Auch, zu helfen, mit ernten array-Inhalt, Sie könnten etwas entlang der Linien von:
```
extension Array where Element:Weak<AnyObject> {
  mutating func reap () {
    self = self.filter { nil != $0.value }
  }
}
```
Den Einsatz von AnyObject oben sollte ersetzt werden, mit T - aber ich glaube nicht, dass die aktuelle Swift-Sprache ermöglicht eine Erweiterung definiert, die als solche.

InformationsquelleAutor der Antwort GoZoner
36

Können Sie die NSHashTable mit weakObjectsHashTable. NSHashTable.weakObjectsHashTable()

Für Swift 3: NSHashTable.weakObjects()

NSHashTable Klasse Referenz

Verfügbar in OS X v10.5 und höher.

Verfügbar in iOS 6.0 und höher.

InformationsquelleAutor der Antwort Thierry
10

Das ist nicht meine Lösung. Ich fand es auf der Apple-Developer-Foren.

@GoZoner hat eine gute Antwort, aber es stürzt der Swift-compiler.

Hier eine version von einem schwachen Objekt-container nicht Abstürzen, der Strom freigegeben compiler.
```
struct WeakContainer<T where T: AnyObject> {
    weak var _value : T?

    init (value: T) {
        _value = value
    }

    func get() -> T? {
        return _value
    }
}
```
Können Sie dann erstellen Sie ein array von diesen Containern:
```
let myArray: Array<WeakContainer<MyClass>> = [myObject1, myObject2]
```
InformationsquelleAutor der Antwort rjkaplan

Ist es irgendwie zu spät zur party, aber versuchen Sie mir. Ich habe implementiert als ein Satz und nicht ein Array.

WeakObjectSet

class WeakObject<T: AnyObject>: Equatable, Hashable {
    weak var object: T?
    init(object: T) {
        self.object = object
    }

    var hashValue: Int {
        if let object = self.object { return unsafeAddressOf(object).hashValue }
        else { return 0 }
    }
}

func == <T> (lhs: WeakObject<T>, rhs: WeakObject<T>) -> Bool {
    return lhs.object === rhs.object
}


class WeakObjectSet<T: AnyObject> {
    var objects: Set<WeakObject<T>>

    init() {
        self.objects = Set<WeakObject<T>>([])
    }

    init(objects: [T]) {
        self.objects = Set<WeakObject<T>>(objects.map { WeakObject(object: $0) })
    }

    var allObjects: [T] {
        return objects.flatMap { $0.object }
    }

    func contains(object: T) -> Bool {
        return self.objects.contains(WeakObject(object: object))
    }

    func addObject(object: T) {
        self.objects.unionInPlace([WeakObject(object: object)])
    }

    func addObjects(objects: [T]) {
        self.objects.unionInPlace(objects.map { WeakObject(object: $0) })
    }
}

Nutzung

var alice: NSString? = "Alice"
var bob: NSString? = "Bob"
var cathline: NSString? = "Cathline"

var persons = WeakObjectSet<NSString>()
persons.addObject(bob!)
print(persons.allObjects) //[Bob]

persons.addObject(bob!)
print(persons.allObjects) //[Bob]

persons.addObjects([alice!, cathline!])
print(persons.allObjects) //[Alice, Cathline, Bob]

alice = nil
print(persons.allObjects) //[Cathline, Bob]

bob = nil
print(persons.allObjects) //[Cathline]

Beachten Sie, dass WeakObjectSet nicht nehmen, String Typ, aber NSString. Weil, Typ String ist nicht ein AnyType. Mein swift version ist Apple Swift version 2.2 (swiftlang-703.0.18.1 clang-703.0.29).

Code können ergriffen werden, von Gist.
https://gist.github.com/codelynx/30d3c42a833321f17d39

** HINZUGEFÜGT IM NOV.2017

Ich aktualisierte den code Swift 4

//Swift 4, Xcode Version 9.1 (9B55)

class WeakObject<T: AnyObject>: Equatable, Hashable {
    weak var object: T?
    init(object: T) {
        self.object = object
    }

    var hashValue: Int {
        if var object = object { return UnsafeMutablePointer<T>(&object).hashValue }
        return 0
    }

    static func == (lhs: WeakObject<T>, rhs: WeakObject<T>) -> Bool {
        return lhs.object === rhs.object
    }
}

class WeakObjectSet<T: AnyObject> {
    var objects: Set<WeakObject<T>>

    init() {
        self.objects = Set<WeakObject<T>>([])
    }

    init(objects: [T]) {
        self.objects = Set<WeakObject<T>>(objects.map { WeakObject(object: $0) })
    }

    var allObjects: [T] {
        return objects.flatMap { $0.object }
    }

    func contains(_ object: T) -> Bool {
        return self.objects.contains(WeakObject(object: object))
    }

    func addObject(_ object: T) {
        self.objects.formUnion([WeakObject(object: object)])
    }

    func addObjects(_ objects: [T]) {
        self.objects.formUnion(objects.map { WeakObject(object: $0) })
    }
}

Als gokeji erwähnt, habe ich herausgefunden, NSString kommen die nicht freigegeben ist, basierend auf der code in Verwendung.
Ich kratzte mich am Kopf und ich schrieb MyString-Klasse wie folgt.

//typealias MyString = NSString
class MyString: CustomStringConvertible {
    var string: String
    init(string: String) {
        self.string = string
    }
    deinit {
        print("relasing: \(string)")
    }
    var description: String {
        return self.string
    }
}

Dann ersetzen NSString mit MyString wie diese. Dann seltsam zu sagen, dass es funktioniert.

var alice: MyString? = MyString(string: "Alice")
var bob: MyString? = MyString(string: "Bob")
var cathline: MyString? = MyString(string: "Cathline")

var persons = WeakObjectSet<MyString>()

persons.addObject(bob!)
print(persons.allObjects) //[Bob]

persons.addObject(bob!)
print(persons.allObjects) //[Bob]

persons.addObjects([alice!, cathline!])
print(persons.allObjects) //[Alice, Cathline, Bob]

alice = nil
print(persons.allObjects) //[Cathline, Bob]

bob = nil
print(persons.allObjects) //[Cathline]

Dann fand ich eine seltsame Seite möglicherweise mit diesem Problem.

Schwache Referenz behält freigegeben NSString (XC9 + iOS-Sim only)

https://bugs.swift.org/browse/SR-5511

Er sagt das Problem ist RESOLVED aber ich Frage mich, ob dies noch im Zusammenhang mit diesem Problem.
Trotzdem, die Unterschiede im Verhalten zwischen MyString oder NSString sind darüber hinaus in diesem Zusammenhang, aber ich wäre dankbar, wenn jemand dachte, dieses Problem aus.

InformationsquelleAutor der Antwort Kaz Yoshikawa

Können Sie dies tun, indem Sie ein wrapper-Objekt zu halten, eine schwache Zeiger.

struct WeakThing<T: AnyObject> {
  weak var value: T?
  init (value: T) {
    self.value = value
  }
}

Und dann diese in das array

var weakThings = WeakThing<Foo>[]()

InformationsquelleAutor der Antwort Joshua Weinberg

Hatte ich die gleiche Idee zu schaffen schwach container mit Generika.

Als Ergebnis habe ich erstellt wrapper für NSHashTable:

class WeakSet<ObjectType>: SequenceType {

    var count: Int {
        return weakStorage.count
    }

    private let weakStorage = NSHashTable.weakObjectsHashTable()

    func addObject(object: ObjectType) {
        guard object is AnyObject else { fatalError("Object (\(object)) should be subclass of AnyObject") }
        weakStorage.addObject(object as? AnyObject)
    }

    func removeObject(object: ObjectType) {
        guard object is AnyObject else { fatalError("Object (\(object)) should be subclass of AnyObject") }
        weakStorage.removeObject(object as? AnyObject)
    }

    func removeAllObjects() {
        weakStorage.removeAllObjects()
    }

    func containsObject(object: ObjectType) -> Bool {
        guard object is AnyObject else { fatalError("Object (\(object)) should be subclass of AnyObject") }
        return weakStorage.containsObject(object as? AnyObject)
    }

    func generate() -> AnyGenerator<ObjectType> {
        let enumerator = weakStorage.objectEnumerator()
        return anyGenerator {
            return enumerator.nextObject() as! ObjectType?
        }
    }
}

Verwendung:

protocol MyDelegate : AnyObject {
    func doWork()
}

class MyClass: AnyObject, MyDelegate {
    fun doWork() {
        //Do delegated work.
    }
}

var delegates = WeakSet<MyDelegate>()
delegates.addObject(MyClass())

for delegate in delegates {
    delegate.doWork()
}

Es ist nicht die beste Lösung, weil WeakSet kann initialisiert werden, mit welcher Art, und wenn dieser Typ nicht entsprechen AnyObject Protokoll dann app crash mit Ausführlicher Begründung. Aber ich sehe keine bessere Lösung jetzt.

Ursprüngliche Lösung war die Definition WeakSet auf diese Weise:

class WeakSet<ObjectType: AnyObject>: SequenceType {}

Aber in diesem Fall WeakSet kann nicht initialisiert werden, mit Protokoll:

protocol MyDelegate : AnyObject {
    func doWork()
}

let weakSet = WeakSet<MyDelegate>()

Derzeit obige code kann nicht kompiliert werden (Swift 2.1, Xcode 7.1).

Das ist, warum ich gelöscht gemäß AnyObject und zusätzliche Wachen mit fatalError() Behauptungen.

InformationsquelleAutor der Antwort Vlad Papko

Wie über funktionelle Stil-wrapper?

class Class1 {}

func captureWeakly<T> (_ target:T) -> (() -> T?) where T: AnyObject {
    return { [weak target] in
        return target
    }
}

let obj1 = Class1()
let obj2 = Class1()
let obj3 = Class1()
let captured1 = captureWeakly(obj1)
let captured2 = captureWeakly(obj2)
let captured3 = captureWeakly(obj3)

Rufen Sie einfach zurückgegeben Schließung zu überprüfen das Ziel ist immer noch lebendig.

let isAlive = captured1() != nil
let theValue = captured1()!

Und speichern Sie diese Verschlüsse in ein array.

let array1 = Array<() -> (Class1?)>([captured1, captured2, captured3])

Und Sie abrufen können, die schwach aufgenommenen Werte durch die Zuordnung von aufrufen der Verschlüsse.

let values = Array(array1.map({ $0() }))

InformationsquelleAutor der Antwort Eonil

Dem vorhandenen Beispiel der WeakContainer ist hilfreich, aber es hat nicht wirklich helfen, eine Verwendung schwacher Referenzen in bestehenden swift-Container wie Listen und Dictionaries.

Wenn Sie verwenden möchten Liste Methoden wie contains, dann die WeakContainer durchsetzen müssen Gleichsetzbar ist. Also habe ich den code Hinzugefügt, um zu ermöglichen, die WeakContainer werden gleichsetzbar.

In den Fall, Sie wollte die WeakContainer in Wörterbüchern habe ich es auch gemacht hashable so kann es verwendet werden als dictionary-Schlüssel.

Ich auch umbenannt, es zu WeakObject zu betonen, dass dies nur für Klasse Typen und es zu unterscheiden von der WeakContainer Beispiele:

struct WeakObject<TYPE where TYPE:AnyObject> : Equatable, Hashable
{
    weak var _value : TYPE?
    let _originalHashValue : Int

    init (value: TYPE)
    {
        _value = value

        //We keep around the original hash value so that we can return it to represent this
        //object even if the value became Nil out from under us because the object went away.
        _originalHashValue = ObjectIdentifier(value).hashValue
    }

    var value : TYPE?
    {
        return _value
    }

    var hashValue: Int
    {
        return _originalHashValue
    }
}

func ==<T>(lhs: WeakObject<T>, rhs: WeakObject<T>) -> Bool
{
    if lhs.value == nil  &&  rhs.value == nil {
        return true
    }
    else if lhs.value == nil  ||  rhs.value == nil {
        return false
    }

    //If the objects are the same, then we are good to go
    return lhs.value! === rhs.value!
}

Diese die Ihnen erlaubt, einige Coole Sachen wie ein Wörterbuch von schwachen Referenzen:

private var m_observerDict : Dictionary<WeakObject<AnyObject>,FLObservationBlock> = Dictionary()

func addObserver( observer:AnyObject, block:FLObservationBlock )
{
    let weakObserver = WeakObject(value:observer)
    m_observerDict[weakObserver] = block
}


func removeObserver( observer:AnyObject )
{
    let weakObserver = WeakObject(value:observer)
    m_observerDict.removeValueForKey(weakObserver)
}

InformationsquelleAutor der Antwort Tod Cunningham

Hier ist, wie zu machen @GoZoner tolle Antwort entsprechen Hashableso kann es indiziert sein, die in Container-Objekte wie: SetDictionaryArray usw.

private class Weak<T: AnyObject>: Hashable {
    weak var value : T!
    init (value: T) {
       self.value = value
    }

    var hashValue : Int {
       //ObjectIdentifier creates a unique hashvalue for objects.
       return ObjectIdentifier(self.value).hashValue
    }
}

//Need to override so we can conform to Equitable.
private func == <T>(lhs: Weak<T>, rhs: Weak<T>) -> Bool {
    return lhs.hashValue == rhs.hashValue
}

InformationsquelleAutor der Antwort Sakiboy

Basierend auf Kaz Yoshikawa Antwort

Details

xCode 9.1, Swift 4

Lösung

WeakObject

import Foundation

protocol WeakObjectProtocol {
    associatedtype WeakObjectType
    var value: WeakObjectType? {get set}
    init(object: WeakObjectType)
}

class WeakObject<T: AnyObject>: WeakObjectProtocol {
    typealias WeakObjectType = T
    weak var value: WeakObjectType?

    required init(object: WeakObjectType) {
        self.value = object
    }

    var referenceCount: Int {
        return CFGetRetainCount(value)
    }
}

extension WeakObject: Equatable {
    static func == (lhs: WeakObject<T>, rhs: WeakObject<T>) -> Bool {
        return lhs.value === rhs.value
    }
}

extension WeakObject: Hashable {
    var hashValue: Int {
        if var value = value { return UnsafeMutablePointer<T>(&value).hashValue }
        return 0
    }
}

extension WeakObject: CustomStringConvertible {

    var description: String {
        if let value = value  {
            let className = String(describing: type(of: value.self))
            return "{class: \(className); referenceCount: \(referenceCount)}"
        }
        return "nil"
    }
}

Erweiterung Array

import Foundation

extension Array where Element: AnyObject  {

    var weak: Array<WeakObject<Element>> {
        var weakArray = [WeakObject<Element>]()
        for item in self {
            let obj = WeakObject(object: item)
            weakArray.append(obj)
        }
        return weakArray
    }
}

extension Array where Element: WeakObjectProtocol {

    typealias EnumeratedWeakObjectClosure = (_ index: Int, _ value: Element.WeakObjectType?)->()
    typealias WeakObjectClosure = (_ value: Element.WeakObjectType?)->()

    mutating func removeNils() {
        self = self.flatMap{ (element) -> Element? in
            if element.value == nil {
                return nil
            }
            return element
        }
    }

    mutating func append(weakValue: Element.WeakObjectType) {
        append(Element(object: weakValue))
    }

    subscript(index: Int) -> Element.WeakObjectType? {
        get {
            return self[index].value
        }
    }

    func `for` (closure: WeakObjectClosure){
        for item in self {
            closure(item.value)
        }
    }

    func forEnumerated (closure: EnumeratedWeakObjectClosure) {
        for (index,item) in self.enumerated() {
            closure(index, item.value)
        }
    }

    mutating func remove(index: Int, closure: EnumeratedWeakObjectClosure) {
        closure(index, self[index].value)
        remove(at: index)
    }

    mutating func remove(index: Int, closure: WeakObjectClosure) {
        closure(self[index].value)
        remove(at: index)
    }
}

Nutzung

//Array of week objects
var weakArray = [WeakObject<UIView>]()

//Get array of week objects (transfom from [AnyObject])
//way 1
weakArray = view.subviews.weak
//way 2
weakArray = [view.subviews[0], view.subviews[1]].weak

//Add single element to the end of the array
weakArray.append(weakValue: UIView())

//For loop
weakArray.for { (element) in
    print("\(String(describing: element))")
}

//For loop with index (position number)
weakArray.forEnumerated { (index, element) in
    print("\(index) \(String(describing: element))")
}

Vollständige Probe

Vergessen Sie nicht, fügen Sie die Lösung hier den code

ViewController

import UIKit

class ViewController: UIViewController {

    var weakArray = [WeakObject<UIView>]()
    override func viewDidLoad() {
        super.viewDidLoad()
        addSubviews()

        weakArray = view.subviews.weak
        weakArray.append(weakValue: generateView())
        weakArray.remove(index: 0) { item in
            item?.removeFromSuperview()
        }
        weakArray.for { (element) in
            print("\(String(describing: element))")
        }

    }

    func printArray(title: String) {

        print("=============================\n\(title)\ncount: \(weakArray.count)")
        weakArray.forEnumerated { (index,element) in
            print("\(index) \(String(describing: element))")
        }
    }
}

//Creating views

extension ViewController {

    func generateView() -> UIView {
        let randomValue: ()->(CGFloat) = { return CGFloat(rand[50, 300]) }
        let view = UIView(frame: CGRect(x: randomValue(), y: randomValue(), width: randomValue(), height: randomValue()))
        view.backgroundColor = .blue
        let randomColorComponent: ()->(CGFloat) = { return CGFloat(rand[0, 255])/CGFloat(255) }
        let color = UIColor(red: randomColorComponent(), green: randomColorComponent(), blue: randomColorComponent(), alpha: 1)
        view.backgroundColor = color
        self.view.addSubview(view)
        return view
    }

    func addSubviews() {

        _ = generateView()
        _ = generateView()

        addButtons()
    }
}

//Buttons

extension ViewController {

    func addButtons() {
        var button = UIButton(frame: CGRect(x: 10, y: 20, width: 40, height: 40))
        button.setTitle("Add", for: .normal)
        button.addTarget(self, action: #selector(addView), for: .touchUpInside)
        button.setTitleColor(.blue, for: .normal)
        view.addSubview(button)

        button = UIButton(frame: CGRect(x: 60, y: 20, width: 60, height: 40))
        button.setTitle("Delete", for: .normal)
        button.addTarget(self, action: #selector(deleteView), for: .touchUpInside)
        button.setTitleColor(.blue, for: .normal)
        view.addSubview(button)

        button = UIButton(frame: CGRect(x: 120, y: 20, width: 100, height: 40))
        button.setTitle("Remove nil", for: .normal)
        button.addTarget(self, action: #selector(removeNils), for: .touchUpInside)
        button.setTitleColor(.blue, for: .normal)
        view.addSubview(button)
    }

    @objc func deleteView() {
        view.subviews.filter { view -> Bool in
            return !(view is UIButton)
            }.first?.removeFromSuperview()

        DispatchQueue.main.async {
            self.view.layoutIfNeeded()
            self.printArray(title: "First view deleted")
        }
    }

    @objc func addView() {
        weakArray.append(weakValue: generateView())
        printArray(title: "View addded")
    }

    @objc func removeNils() {
        weakArray.removeNils()
        printArray(title: "Remove all nil elements in weakArray")
    }
}

Rand func

class Random {

    subscript<T>(_ min: T, _ max: T) -> T where T : BinaryInteger {
        get {
            return rand(min-1, max+1)
        }
    }
}

let rand = Random()

func rand<T>(_ min: T, _ max: T) -> T where T : BinaryInteger {
    let _min = min + 1
    let difference = max - _min
    return T(arc4random_uniform(UInt32(difference))) + _min
}

Ergebnis

Wie deklariere ich ein Array von schwachen Referenzen in Swift?

InformationsquelleAutor der Antwort Vasily Bodnarchuk

Anderen Antworten haben die Generika-Winkel. Dachte, ich würde teilen einige einfache code-Abdeckung der nil Winkel.

Wollte ich ein statisches array Lesen (gelegentlich) alle Labels, die es derzeit in der app, aber nicht wollen, um zu sehen nil's, wo die alten verwendet werden.

Nichts Lust, das ist mein code...

public struct WeakLabel {
    public weak var label : Label?
    public init(_ label: Label?) {
        self.label = label
    }
}

public class Label : UILabel {
    static var _allLabels = [WeakLabel]()
    public static var allLabels:[WeakLabel] {
        get {
            _allLabels = _allLabels.filter{$0.label != nil}
            return _allLabels.filter{$0.label != nil}.map{$0.label!}
        }
    }
    public required init?(coder: NSCoder) {
        super.init(coder: coder)
        Label._allLabels.append(WeakLabel(self))
    }
    public override init(frame: CGRect) {
        super.init(frame: frame)
        Label._allLabels.append(WeakLabel(self))
    }
}

InformationsquelleAutor der Antwort wils

Noch eine andere Lösung für das gleiche problem... der Fokus ist auf die Speicherung einer schwachen Referenz auf ein Objekt, aber so dass Sie zum speichern eines struct zu.

[Ich bin mir nicht sicher, wie nützlich es ist, aber es hat eine Weile gedauert, um die syntax right]

class WeakWrapper : Equatable {
    var valueAny : Any?
    weak var value : AnyObject?

    init(value: Any) {
        if let valueObj = value as? AnyObject {
            self.value = valueObj
        } else {
            self.valueAny = value
        }
    }

    func recall() -> Any? {
        if let value = value {
            return value
        } else if let value = valueAny {
            return value
        }
        return nil
    }
}


func ==(lhs: WeakWrapper, rhs: WeakWrapper) -> Bool {
    return ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
}



class Stuff {}
var weakArray : [WeakWrapper] = [WeakWrapper(value: Stuff()), WeakWrapper(value: CGRectZero)]

extension Array where Element : WeakWrapper  {

    mutating func removeObject(object: Element) {
        if let index = self.indexOf(object) {
            self.removeAtIndex(index)
        }
    }

    mutating func compress() {
        for obj in self {
            if obj.recall() == nil {
                self.removeObject(obj)
            }
        }
    }


}

weakArray[0].recall()
weakArray[1].recall() == nil
weakArray.compress()
weakArray.count

InformationsquelleAutor der Antwort Dan Rosenstark

1

Können Sie wrapper Array. Oder verwenden Sie diese Bibliothek https://github.com/NickRybalko/WeakPointerArray
let array = WeakPointerArray<AnyObject>()
Typ ist es sicher.

InformationsquelleAutor der Antwort Nick Rybalko

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.