Limiter les résultats d'un filtre tableau Swift à X pour les performances

Question

J'ai environ 2000 éléments dans ma matrice, et quand il est filtré, je voudrais mettre fin au filtrage dès que j'ai 5 éléments dans mon tableau filtré.

Actuellement, il est:

providerArray.filter({($0.lowercased().range(of:((row.value as? String)?.lowercased())!) != nil)}) 

qui peut revenir jusqu'à 2000 des résultats qui est une perte de traitement, et le temps.

Pour être plus clair, je besoin d'une solution qui est équivalente à limiter les résultats du filtre comme je peux avec CoreData va chercher [request setFetchLimit:5];

Answer 1

La solution la plus rapide en termes de temps d'exécution semble être une boucle explicite qui ajoute des éléments correspondant jusqu'à ce que la limite est atteinte:

extension Sequence { 
    public func filter(where isIncluded: (Iterator.Element) -> Bool, limit: Int) -> [Iterator.Element] { 
     var result : [Iterator.Element] = [] 
     result.reserveCapacity(limit) 
     var count = 0 
     var it = makeIterator() 

     // While limit not reached and there are more elements ... 
     while count < limit, let element = it.next() { 
      if isIncluded(element) { 
       result.append(element) 
       count += 1 
      } 
     } 
     return result 
    } 
} 

Exemple d'utilisation:

let numbers = Array(0 ..< 2000) 
let result = numbers.filter(where: { $0 % 3 == 0 }, limit: 5) 
print(result) // [0, 3, 6, 9, 12] 

Answer 2

Vous pouvez utiliser .lazy stimuler aussi la performance un peu:

let numbers: [Int] = Array(0 ..< 2000) 

let result: AnySequence = numbers 
    .lazy 
    .filter { 
     print("Calling filter for: \($0)") 
     return ($0 % 3) == 0 
    } 
    .prefix(5) 

print(Array(result)) 

Cela appellera la fonction filter seulement pour les 15 premières valeurs (jusqu'à ce qu'il trouve 5 qui passent le filtre).

Maintenant vous pouvez vous concentrer sur l'amélioration des performances du filter lui-même. Par exemple. en mettant en cache des valeurs. Vous n'avez pas à le faire, mais si certaines valeurs ne cessent de se répéter, cela peut améliorer considérablement les performances.

let numbers: [Int] = Array(0 ..< 2000) 
var filterCache: [Int: Bool] = [:] 

let result: AnySequence = numbers 
    .lazy 
    .filter { 
     if let cachedResult = filterCache[$0] { 
      return cachedResult 
     } 

     print("Calling filter for: \($0)") 
     let result = (($0 % 3) == 0) 

     filterCache[$0] = result 

     return result 
    } 
    .prefix(5) 

print(Array(result)) 

Vous pouvez appliquer cette méthode directement à votre fonction.

Notez également que pour améliorer les performances, vous devez soit:

• sauver ((row.value as? String)?.lowercased())! dans une variable locale, car il est exécuté plusieurs fois

• simplifier l'expression à l'aide des options:

let result: AnySequence = providerArray 
    .lazy 
    .filter { 
     $0.range(of: row.value as! String, options: [.caseInsensitive]) != nil 
    } 
    .prefix(5)