Valori univoci dell'array in swift

Question

Sto costruendo un'app per iOS con swift e ho bisogno di ottenere tutti i valori univoci dell'array di stringhe.

Ho letto i documenti dello sviluppatore Apple ma non sembra avere una funzione per questo.

Qualcuno può darmi un suggerimento?

Answer 1

Utilizzare un dizionario come var unique = [<yourtype>:Bool]() e immettere valori come unique[<array value>] = true in un ciclo. Ora unique.keys ha ciò di cui hai bisogno.

Answer 2

Non c'è una funzione per fare questo nella libreria standard Swift, ma si potrebbe scrivere uno:

extension Sequence where Iterator.Element: Hashable { 
    func unique() -> [Iterator.Element] { 
     var seen: [Iterator.Element: Bool] = [:] 
     return self.filter { seen.updateValue(true, forKey: $0) == nil } 
    } 
} 

let a = ["four","one", "two", "one", "three","four", "four"] 
a.unique // ["four", "one", "two", "three"] 

Questo ha lo svantaggio di richiedere il contenuto della sequenza da hashable, non solo equatable , ma poi di nuovo le cose più equabili sono, comprese le stringhe.

Conserva anche l'ordinamento originale a differenza, ad esempio, inserendo il contenuto in un dizionario o in un set e quindi ripristinandoli di nuovo.

Answer 3

Un modo è quello di utilizzare un set:

let array = ["one", "one", "two", "two", "three", "three"] 
let unique = Array(Set(array)) 
// ["one", "two", "three"] 

Si potrebbe anche creare un'estensione che filtra attraverso la matrice più esplicitamente:

extension Array where Element : Equatable { 
    var unique: [Element] { 
     var uniqueValues: [Element] = [] 
     forEach { item in 
      if !uniqueValues.contains(item) { 
       uniqueValues += [item] 
      } 
     } 
     return uniqueValues 
    } 
} 

NOTA

La matrice unica sarà in un ordine non specificato e potrebbe essere necessario ordinarlo. A volte è meglio farlo da soli enumerando, potresti scrivere un'estensione.

Potrebbe essere buono per fare un prolungamento (Swift 2):

extension Array where Element : Hashable { 
    var unique: [Element] { 
     return Array(Set(self)) 
    } 
} 

Probabilmente ci sono modi più ottimizzato per fare ciò che si vuole, ma in questo modo è semplice e veloce.

Answer 4

Non so di un modo integrato. Questa funzione generica lo farebbe:

func distinct<S: SequenceType, E: Equatable where E==S.Generator.Element>(source: S) -> [E] 
{ 
    var unique = [E]() 

    for item in source 
    { 
     if !contains(unique, item) 
     { 
      unique.append(item) 
     } 
    } 
    return unique 
} 

Il rovescio della medaglia è che questa soluzione viene eseguito in O (n).