RealmSwift: Converter resultados em matriz rápida

O que eu quero implementar:

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

    return objects.count > 0 ? objects : nil
}

Como posso retornar um objeto como [SomeObject]se Results?

Estranho, a resposta é muito direta. Aqui está como eu faço isso:

let array = Array(results) // la fin

Se você absolutamente precisa converter o seu Resultspara Array, lembre-se de que há uma sobrecarga de desempenho e memória, pois Resultsé preguiçoso. Mas você pode fazer isso em uma linha, como results.map { $0 }no swift 2.0 (ou map(results) { $0 }no 1.2).

Eu encontrei uma solução. Extensão criada em Resultados.

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
    }
}

e usando como

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

    return objects.count > 0 ? objects : nil
}

Com o Swift 4.2, é tão simples quanto uma extensão:

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

Todas as informações genéricas necessárias já fazem parte das Resultsquais estendemos.

Essa é outra maneira de converter Resultsem Array com uma extensão com o Swift 3 em uma única linha.

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

Para Swift 4 e Xcode 9.2

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

Com o Xcode 10 flatMap está obsoleto, você pode usar compactMappara mapear.

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
    }
}

Uso

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
}

Alternativa: Usando genéricos

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
}

não é uma boa ideia converter Resultados em Matriz, porque Resultados é preguiçoso. Mas se você precisar, tente o seguinte:

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

mas a melhor maneira é passar os Resultados sempre que precisar. Além disso, você pode converter Resultados em Lista em vez de Matriz.

List(realm.objects(class))

se a primeira função não estiver funcionando, você pode tentar esta:

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

Não tenho certeza, se existe alguma maneira eficiente de fazer isso.

Mas você pode fazer isso criando uma matriz Swift e anexando-a no loop.

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

Se você sentir que é muito lento. Eu recomendo que você passe Resultsdiretamente o objeto Realm .

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

Então, você pode usar como:

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

Solução para Swift 4, Domínio 3

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

Agora a conversão pode ser feita como abaixo

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

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