RealmSwift: Konvertieren Sie Ergebnisse in Swift Array

Was ich implementieren möchte:

class func getSomeObject() -> [SomeObject]? {
    let objects = Realm().objects(SomeObject)

    return objects.count > 0 ? objects : nil
}

Wie kann ich ein Objekt zurückgeben, als [SomeObject]ob Results?

Seltsam, die Antwort ist sehr einfach. So mache ich das:

let array = Array(results) // la fin

Wenn Sie unbedingt Ihre konvertieren ResultszuArray denken , dass es einen Leistungs- und Speicheraufwand gibt, da dieser Resultsfaul ist. Sie können dies jedoch in einer Zeile tun, wie results.map { $0 }in Swift 2.0 (oder map(results) { $0 }in 1.2).

Ich habe eine Lösung gefunden. Erweiterung für Ergebnisse erstellt.

extension Results {
    func toArray<T>(ofType: T.Type) -> [T] {
        var array = [T]()
        for i in 0 ..< count {
            if let result = self[i] as? T {
                array.append(result)
            }
        }

        return array
    }
}

und mit like

class func getSomeObject() -> [SomeObject]? {
    let objects = Realm().objects(SomeObject).toArray(SomeObject) as [SomeObject]

    return objects.count > 0 ? objects : nil
}

Mit Swift 4.2 ist es so einfach wie eine Erweiterung:

extension Results {
    func toArray() -> [Element] {
      return compactMap {
        $0
      }
    }
 }

Alle benötigten Generika-Informationen sind bereits ein Teil, Resultsden wir erweitern.

Dies ist eine weitere Möglichkeit, Resultsin Array mit einer Erweiterung mit Swift 3 in einer einzelnen Zeile zu konvertieren .

extension Results {
    func toArray() -> [T] {
        return self.map { $0 }
    }
}

Für Swift 4 und Xcode 9.2

extension Results {
    func toArray<T>(type: T.Type) -> [T] {
        return flatMap { $0 as? T }
    }
}

Mit Xcode 10 flatMap veraltet ist , können Sie verwenden compactMapfür die Zuordnung.

extension Results {
    func toArray<T>(type: T.Type) -> [T] {
        return compactMap { $0 as? T }
    }
}

Swift 3

extension Results {
    func toArray<T>(ofType: T.Type) -> [T] {
        var array = [T]()
        for i in 0 ..< count {
            if let result = self[i] as? T {
                array.append(result)
            }
        }

        return array
    }
}

Verwendung

class func getSomeObject() -> [SomeObject]? {
   let defaultRealm = try! Realm()
    let objects = defaultRealm.objects(SomeObject.self).toArray(ofType : SomeObject.self) as [SomeObject]

    return objects.count > 0 ? objects : nil
}

Alternative: Generika verwenden

class func getSomeObject() -> [T]? {
        let objects = Realm().objects(T.self as! Object.Type).toArray(ofType : T.self) as [T]

        return objects.count > 0 ? objects : nil
}

Es ist keine gute Idee, Ergebnisse in Array zu konvertieren, da Ergebnisse faul sind. Aber wenn Sie es brauchen, versuchen Sie Folgendes:

func toArray<T>(ofType: T.Type) -> [T] {
    return flatMap { $0 as? T }
}

Besser ist es jedoch, die Ergebnisse überall dort weiterzugeben, wo Sie sie benötigen. Sie können Ergebnisse auch in Liste anstelle von Array konvertieren.

List(realm.objects(class))

Wenn die erste Funktion nicht funktioniert, können Sie diese ausprobieren:

var refrenceBook:[RefrenceProtocol] = []
let faceTypes = Array(realm.objects(FaceType))
refrenceBook = faceTypes.map({$0 as FaceType})

Ich bin mir nicht sicher, ob es dafür einen effizienten Weg gibt.

Sie können dies jedoch tun, indem Sie ein Swift-Array erstellen und es in die Schleife einfügen.

class func getSomeObject() -> [SomeObject]? {
    var someObjects: [SomeObject] = []
    let objects = Realm().objects(SomeObject)
    for object in objects{
        someObjects += [object]
    }
    return objects.count > 0 ? someObjects : nil
}

Wenn Sie das Gefühl haben, dass es zu langsam ist. Ich empfehle Ihnen, das Realm- ResultsObjekt direkt weiterzugeben .

extension Results {
    var array: [Element]? {
        return self.count > 0 ? self.map { $0 } : nil
    }
}

Sie können also Folgendes verwenden:

Realm().objects(SomeClass.self).filter("someKey ENDSWITH %@", "sth").array

Lösung für Swift 4, Realm 3

extension Results {
    func toArray<T>(ofType: T.Type) -> [T] {
        let array = Array(self) as! [T]
        return array
    }
}

Jetzt kann die Konvertierung wie folgt durchgeführt werden

let array = Realm().objects(SomeClass).toArray(ofType: SomeClass.self)

extension Results {
    func materialize() -> [Element] {
        return Array(self)
    }
}