Oggi in Swift digiti semplicemente Set( yourArray ) per rendere un array unico. (O un set ordinato, se necessario.)

Prima che fosse possibile, come è stato fatto?

Potrei avere un array che assomiglia al seguente:

[1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6]

O, in realtà, qualsiasi sequenza di porzioni di dati tipizzate in modo simile. Quello che voglio fare è assicurarmi che ci sia solo uno di ciascun elemento identico. Ad esempio, l'array sopra diventa:

[1, 4, 2, 6, 24, 15, 60]

Si noti che i duplicati di 2, 6 e 15 sono stati rimossi per garantire che esistesse solo uno per ogni elemento identico. Swift fornisce un modo per farlo facilmente o dovrò farlo da solo?

Puoi farlo tu stesso, ad esempio in questo modo ( aggiornato per Swift 1.2 con Set ):

func uniq<S : SequenceType, T : Hashable where S.Generator.Element == T>(source: S) -> [T] {
    var buffer = [T]()
    var added = Set<T>()
    for elem in source {
        if !added.contains(elem) {
            buffer.append(elem)
            added.insert(elem)
        }
    }
    return buffer
}

let vals = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6]
let uniqueVals = uniq(vals) // [1, 4, 2, 6, 24, 15, 60]

Versione Swift 3:

func uniq<S : Sequence, T : Hashable>(source: S) -> [T] where S.Iterator.Element == T {
    var buffer = [T]()
    var added = Set<T>()
    for elem in source {
        if !added.contains(elem) {
            buffer.append(elem)
            added.insert(elem)
        }
    }
    return buffer
}

E come estensione per Array:

extension Array where Element: Hashable {
    var uniques: Array {
        var buffer = Array()
        var added = Set<Element>()
        for elem in self {
            if !added.contains(elem) {
                buffer.append(elem)
                added.insert(elem)
            }
        }
        return buffer
    }
}

È possibile convertire in un set e tornare nuovamente in un array abbastanza facilmente:

let unique = Array(Set(originals))

Questo non è garantito per mantenere l'ordine originale dell'array.

Molte risposte disponibili qui, ma ho perso questa semplice estensione, adatta per Swift 2 e versioni successive:

extension Array where Element:Equatable {
    func removeDuplicates() -> [Element] {
        var result = [Element]()

        for value in self {
            if result.contains(value) == false {
                result.append(value)
            }
        }

        return result
    }
}

Lo rende super semplice. Può essere chiamato così:

let arrayOfInts = [2, 2, 4, 4]
print(arrayOfInts.removeDuplicates()) // Prints: [2, 4]

Filtro basato su proprietà

Per filtrare un array in base alle proprietà, è possibile utilizzare questo metodo:

extension Array {

    func filterDuplicates(@noescape includeElement: (lhs:Element, rhs:Element) -> Bool) -> [Element]{
        var results = [Element]()

        forEach { (element) in
            let existingElements = results.filter {
                return includeElement(lhs: element, rhs: $0)
            }
            if existingElements.count == 0 {
                results.append(element)
            }
        }

        return results
    }
}

Che puoi chiamare come segue:

let filteredElements = myElements.filterDuplicates { $0.PropertyOne == $1.PropertyOne && $0.PropertyTwo == $1.PropertyTwo }

Swift 3.0

let uniqueUnordered = Array(Set(array))
let uniqueOrdered = Array(NSOrderedSet(array: array))

Se si inseriscono entrambe le estensioni nel codice, Hashablequando possibile verrà utilizzata la versione più veloce e la Equatableversione verrà utilizzata come fallback.

public extension Sequence where Element: Hashable {
  var firstUniqueElements: [Element] {
    var set: Set<Element> = []
    return filter { set.insert($0).inserted }
  }
}

public extension Sequence where Element: Equatable {
  var firstUniqueElements: [Element] {
    reduce(into: []) { uniqueElements, element in
      if !uniqueElements.contains(element) {
        uniqueElements.append(element)
      }
    }
  }
}

Se l'ordine non è importante, puoi sempre utilizzare questo inizializzatore Set .

modifica / aggiorna Swift 4 o successivo

Possiamo anche estendere il RangeReplaceableCollectionprotocollo per consentirne l'utilizzo anche con StringProtocoltipi:

extension RangeReplaceableCollection where Element: Hashable {
    var orderedSet: Self {
        var set = Set<Element>()
        return filter { set.insert($0).inserted }
    }
    mutating func removeDuplicates() {
        var set = Set<Element>()
        removeAll { !set.insert($0).inserted }
    }
}

let integers = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6]
let integersOrderedSet = integers.orderedSet // [1, 4, 2, 6, 24, 15, 60]

"abcdefabcghi".orderedSet  // "abcdefghi"
"abcdefabcghi".dropFirst(3).orderedSet // "defabcghi"

Metodo di mutazione:

var string = "abcdefabcghi"
string.removeDuplicates() 
string  //  "abcdefghi"

var substring = "abcdefabcdefghi".dropFirst(3)  // "defabcdefghi"
substring.removeDuplicates()
substring   // "defabcghi"

Per Swift 3 fai clic qui

Swift 4

public extension Array where Element: Hashable {
    func uniqued() -> [Element] {
        var seen = Set<Element>()
        return filter{ seen.insert($0).inserted }
    }
}

ogni tentativo di insertsarà anche restituire una tupla: (inserted: Bool, memberAfterInsert: Set.Element). Vedere la documentazione .

L'uso del valore restituito ci aiuta a evitare il loop o qualsiasi altra operazione.

Swift 4

Garantito per continuare a ordinare.

extension Array where Element: Equatable {
    func removingDuplicates() -> Array {
        return reduce(into: []) { result, element in
            if !result.contains(element) {
                result.append(element)
            }
        }
    }
}

Ecco una categoria in SequenceTypecui viene preservato l'ordine originale dell'array, ma che utilizza a Setper eseguire le containsricerche per evitare il O(n)costo del contains(_:)metodo dell'array .

public extension Sequence where Element: Hashable {

    /// Return the sequence with all duplicates removed.
    ///
    /// i.e. `[ 1, 2, 3, 1, 2 ].uniqued() == [ 1, 2, 3 ]`
    ///
    /// - note: Taken from stackoverflow.com/a/46354989/3141234, as 
    ///         per @Alexander's comment.
    func uniqued() -> [Element] {
        var seen = Set<Element>()
        return self.filter { seen.insert($0).inserted }
    }
}

Se non sei Hashable o Equatable, puoi passare un predicato per fare il controllo di uguaglianza:

extension Sequence {

    /// Return the sequence with all duplicates removed.
    ///
    /// Duplicate, in this case, is defined as returning `true` from `comparator`.
    ///
    /// - note: Taken from stackoverflow.com/a/46354989/3141234
    func uniqued(comparator: @escaping (Element, Element) throws -> Bool) rethrows -> [Element] {
        var buffer: [Element] = []

        for element in self {
            // If element is already in buffer, skip to the next element
            if try buffer.contains(where: { try comparator(element, $0) }) {
                continue
            }

            buffer.append(element)
        }

        return buffer
    }
}

Ora, se non hai Hashable, ma sei Equatable, puoi usare questo metodo:

extension Sequence where Element: Equatable {

    /// Return the sequence with all duplicates removed.
    ///
    /// i.e. `[ 1, 2, 3, 1, 2 ].uniqued() == [ 1, 2, 3 ]`
    ///
    /// - note: Taken from stackoverflow.com/a/46354989/3141234
    func uniqued() -> [Element] {
        return self.uniqued(comparator: ==)
    }
}

Infine, puoi aggiungere una versione del percorso chiave di uniqued in questo modo:

extension Sequence {

    /// Returns the sequence with duplicate elements removed, performing the comparison usinig the property at
    /// the supplied keypath.
    ///
    /// i.e.
    ///
    /// ```
    /// [
    ///   MyStruct(value: "Hello"),
    ///   MyStruct(value: "Hello"),
    ///   MyStruct(value: "World")
    ///  ].uniqued(\.value)
    /// ```
    /// would result in
    ///
    /// ```
    /// [
    ///   MyStruct(value: "Hello"),
    ///   MyStruct(value: "World")
    /// ]
    /// ```
    ///
    /// - note: Taken from stackoverflow.com/a/46354989/3141234
    ///
    func uniqued<T: Equatable>(_ keyPath: KeyPath<Element, T>) -> [Element] {
        self.uniqued { $0[keyPath: keyPath] == $1[keyPath: keyPath] }
    }
}

Puoi inserirli entrambi nella tua app, Swift sceglierà quello giusto in base al Iterator.Elementtipo di sequenza .

Ispirato da https://www.swiftbysundell.com/posts/the-power-of-key-paths-in-swift , possiamo dichiarare uno strumento più potente che è in grado di filtrare per unicità su qualsiasi keyPath. Grazie ai commenti di Alexander su varie risposte riguardanti la complessità, le soluzioni seguenti dovrebbero essere quasi ottimali.

Soluzione non mutante

Estendiamo con una funzione che è in grado di filtrare per unicità su qualsiasi keyPath:

extension RangeReplaceableCollection {
    /// Returns a collection containing, in order, the first instances of
    /// elements of the sequence that compare equally for the keyPath.
    func unique<T: Hashable>(for keyPath: KeyPath<Element, T>) -> Self {
        var unique = Set<T>()
        return filter { unique.insert($0[keyPath: keyPath]).inserted }
    }
}

Nota: nel caso in cui il tuo oggetto non sia conforme a RangeReplaceableCollection, ma sia conforme a Sequence, puoi avere questa estensione aggiuntiva, ma il tipo restituito sarà sempre un array:

extension Sequence {
    /// Returns an array containing, in order, the first instances of
    /// elements of the sequence that compare equally for the keyPath.
    func unique<T: Hashable>(for keyPath: KeyPath<Element, T>) -> [Element] {
        var unique = Set<T>()
        return filter { unique.insert($0[keyPath: keyPath]).inserted }
    }
}

uso

Se vogliamo l'unicità per gli elementi stessi, come nella domanda, usiamo keyPath \.self:

let a = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6]
let b = a.unique(for: \.self)
/* b is [1, 4, 2, 6, 24, 15, 60] */

Se vogliamo unicità per qualcos'altro (come per la idraccolta di oggetti), utilizziamo il keyPath di nostra scelta:

let a = [CGPoint(x: 1, y: 1), CGPoint(x: 2, y: 1), CGPoint(x: 1, y: 2)]
let b = a.unique(for: \.y)
/* b is [{x 1 y 1}, {x 1 y 2}] */

Soluzione mutante

Estendiamo con una funzione mutante in grado di filtrare l'unicità su qualsiasi keyPath:

extension RangeReplaceableCollection {
    /// Keeps only, in order, the first instances of
    /// elements of the collection that compare equally for the keyPath.
    mutating func uniqueInPlace<T: Hashable>(for keyPath: KeyPath<Element, T>) {
        var unique = Set<T>()
        removeAll { !unique.insert($0[keyPath: keyPath]).inserted }
    }
}

uso

Se vogliamo l'unicità per gli elementi stessi, come nella domanda, usiamo keyPath \.self:

var a = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6]
a.uniqueInPlace(for: \.self)
/* a is [1, 4, 2, 6, 24, 15, 60] */

Se vogliamo unicità per qualcos'altro (come per la idraccolta di oggetti), utilizziamo il keyPath di nostra scelta:

var a = [CGPoint(x: 1, y: 1), CGPoint(x: 2, y: 1), CGPoint(x: 1, y: 2)]
a.uniqueInPlace(for: \.y)
/* a is [{x 1 y 1}, {x 1 y 2}] */

Una soluzione alternativa (se non ottimale) da qui utilizzando tipi immutabili anziché variabili:

func deleteDuplicates<S: ExtensibleCollectionType where S.Generator.Element: Equatable>(seq:S)-> S {
    let s = reduce(seq, S()){
        ac, x in contains(ac,x) ? ac : ac + [x]
    }
    return s
}

Incluso per contrastare l'approccio imperativo di Jean-Pillippe con un approccio funzionale.

Come bonus questa funzione funziona con stringhe e array!

Modifica: questa risposta è stata scritta nel 2014 per Swift 1.0 (prima Setera disponibile in Swift). Non richiede conformità Hashable e corre in tempo quadratico.

veloce 2

con risposta della funzione uniq :

func uniq<S: SequenceType, E: Hashable where E==S.Generator.Element>(source: S) -> [E] {
    var seen: [E:Bool] = [:]
    return source.filter({ (v) -> Bool in
        return seen.updateValue(true, forKey: v) == nil
    })
}

uso:

var test = [1,2,3,4,5,6,7,8,9,9,9,9,9,9]
print(uniq(test)) //1,2,3,4,5,6,7,8,9

In Swift 5

 var array: [String] =  ["Aman", "Sumit", "Aman", "Sumit", "Mohan", "Mohan", "Amit"]

 let uniq = Array(Set(array))
 print(uniq)

L'output sarà

 ["Sumit", "Mohan", "Amit", "Aman"]

Un'altra soluzione Swift 3.0 per rimuovere i duplicati da un array. Questa soluzione migliora su molte altre soluzioni già proposte da:

• Preservare l'ordine degli elementi nell'array di input
• Complessità lineare O (n): filtro a passaggio singolo O (n) + imposta inserzione O (1)

Dato l'array intero:

let numberArray = [10, 1, 2, 3, 2, 1, 15, 4, 5, 6, 7, 3, 2, 12, 2, 5, 5, 6, 10, 7, 8, 3, 3, 45, 5, 15, 6, 7, 8, 7]

Codice funzionale:

func orderedSet<T: Hashable>(array: Array<T>) -> Array<T> {
    var unique = Set<T>()
    return array.filter { element in
        return unique.insert(element).inserted
    }
}

orderedSet(array: numberArray)  // [10, 1, 2, 3, 15, 4, 5, 6, 7, 12, 8, 45]

Codice estensione array:

extension Array where Element:Hashable {
    var orderedSet: Array {
        var unique = Set<Element>()
        return filter { element in
            return unique.insert(element).inserted
        }
    }
}

numberArray.orderedSet // [10, 1, 2, 3, 15, 4, 5, 6, 7, 12, 8, 45]

Questo codice sfrutta il risultato restituito insertdall'operazione on Set, che viene eseguita on O(1), e restituisce una tupla che indica se l'elemento è stato inserito o se esiste già nel set.

Se l'articolo era nel set, filterlo escluderà dal risultato finale.

Swift 4.x:

extension Sequence where Iterator.Element: Hashable {
  func unique() -> [Iterator.Element] {
    return Array(Set<Iterator.Element>(self))
  }

  func uniqueOrdered() -> [Iterator.Element] {
    return reduce([Iterator.Element]()) { $0.contains($1) ? $0 : $0 + [$1] }
  }
}

utilizzo:

["Ljubljana", "London", "Los Angeles", "Ljubljana"].unique()

o

["Ljubljana", "London", "Los Angeles", "Ljubljana"].uniqueOrdered()

Swift 5

extension Sequence where Element: Hashable {
    func unique() -> [Element] {
        NSOrderedSet(array: self as! [Any]).array as! [Element]
    }
}

Pensa come un programmatore funzionale :)

Per filtrare l'elenco in base alla presenza dell'elemento, è necessario l'indice. È possibile utilizzare enumeratedper ottenere l'indice e mapper tornare all'elenco dei valori.

let unique = myArray
    .enumerated()
    .filter{ myArray.firstIndex(of: $0.1) == $0.0 }
    .map{ $0.1 }

Questo garantisce l'ordine. Se non ti dispiace per l'ordine, la risposta esistente di Array(Set(myArray))è più semplice e probabilmente più efficiente.

AGGIORNAMENTO: Alcune note su efficienza e correttezza

Alcune persone hanno commentato l'efficienza. Sono sicuramente nella scuola di scrivere prima il codice corretto e semplice e poi di capire i colli di bottiglia in seguito, anche se apprezzo che sia discutibile se questo sia più chiaro di Array(Set(array)).

Questo metodo è molto più lento di Array(Set(array)). Come notato nei commenti, mantiene l'ordine e funziona su elementi che non sono Hashable.

Tuttavia, il metodo di @Alain T preserva anche l'ordine ed è anche molto più veloce. Quindi, a meno che il tuo tipo di elemento non sia hash o non ti serva solo una fodera veloce, ti suggerirei di andare con la loro soluzione.

Ecco alcuni test su un MacBook Pro (2014) su Xcode 11.3.1 (Swift 5.1) in modalità di rilascio.

La funzione profiler e due metodi per confrontare:

func printTimeElapsed(title:String, operation:()->()) {
    var totalTime = 0.0
    for _ in (0..<1000) {
        let startTime = CFAbsoluteTimeGetCurrent()
        operation()
        let timeElapsed = CFAbsoluteTimeGetCurrent() - startTime
        totalTime += timeElapsed
    }
    let meanTime = totalTime / 1000
    print("Mean time for \(title): \(meanTime) s")
}

func method1<T: Hashable>(_ array: Array<T>) -> Array<T> {
    return Array(Set(array))
}

func method2<T: Equatable>(_ array: Array<T>) -> Array<T>{
    return array
    .enumerated()
    .filter{ array.firstIndex(of: $0.1) == $0.0 }
    .map{ $0.1 }
}

// Alain T.'s answer (adapted)
func method3<T: Hashable>(_ array: Array<T>) -> Array<T> {
    var uniqueKeys = Set<T>()
    return array.filter{uniqueKeys.insert($0).inserted}
}

E una piccola varietà di input di test:

func randomString(_ length: Int) -> String {
  let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
  return String((0..<length).map{ _ in letters.randomElement()! })
}

let shortIntList = (0..<100).map{_ in Int.random(in: 0..<100) }
let longIntList = (0..<10000).map{_ in Int.random(in: 0..<10000) }
let longIntListManyRepetitions = (0..<10000).map{_ in Int.random(in: 0..<100) }
let longStringList = (0..<10000).map{_ in randomString(1000)}
let longMegaStringList = (0..<10000).map{_ in randomString(10000)}

Fornisce come output:

Mean time for method1 on shortIntList: 2.7358531951904296e-06 s
Mean time for method2 on shortIntList: 4.910230636596679e-06 s
Mean time for method3 on shortIntList: 6.417632102966309e-06 s
Mean time for method1 on longIntList: 0.0002518167495727539 s
Mean time for method2 on longIntList: 0.021718120217323302 s
Mean time for method3 on longIntList: 0.0005312927961349487 s
Mean time for method1 on longIntListManyRepetitions: 0.00014377200603485108 s
Mean time for method2 on longIntListManyRepetitions: 0.0007293639183044434 s
Mean time for method3 on longIntListManyRepetitions: 0.0001843773126602173 s
Mean time for method1 on longStringList: 0.007168249964714051 s
Mean time for method2 on longStringList: 0.9114790915250778 s
Mean time for method3 on longStringList: 0.015888616919517515 s
Mean time for method1 on longMegaStringList: 0.0525397013425827 s
Mean time for method2 on longMegaStringList: 1.111266262292862 s
Mean time for method3 on longMegaStringList: 0.11214958941936493 s

Per le matrici in cui gli elementi non sono né Hashable né Comparable (ad esempio oggetti complessi, dizionari o strutture), questa estensione fornisce un modo generalizzato per rimuovere i duplicati:

extension Array
{
   func filterDuplicate<T:Hashable>(_ keyValue:(Element)->T) -> [Element]
   {
      var uniqueKeys = Set<T>()
      return filter{uniqueKeys.insert(keyValue($0)).inserted}
   }

   func filterDuplicate<T>(_ keyValue:(Element)->T) -> [Element]
   { 
      return filterDuplicate{"\(keyValue($0))"}
   }
}

// example usage: (for a unique combination of attributes):

peopleArray = peopleArray.filterDuplicate{ ($0.name, $0.age, $0.sex) }

or...

peopleArray = peopleArray.filterDuplicate{ "\(($0.name, $0.age, $0.sex))" }

Non devi preoccuparti di creare valori Hashable e ti permette di usare diverse combinazioni di campi per unicità.

Nota: per un approccio più solido, consultare la soluzione proposta da Coeur nei commenti seguenti.

stackoverflow.com/a/55684308/1033581

[EDIT] Alternativa di Swift 4

Con Swift 4.2 puoi usare la classe Hasher per creare un hash molto più semplice. L'estensione sopra potrebbe essere modificata per sfruttare questo:

extension Array
{
    func filterDuplicate(_ keyValue:((AnyHashable...)->AnyHashable,Element)->AnyHashable) -> [Element]
    {
        func makeHash(_ params:AnyHashable ...) -> AnyHashable
        { 
           var hash = Hasher()
           params.forEach{ hash.combine($0) }
           return hash.finalize()
        }  
        var uniqueKeys = Set<AnyHashable>()
        return filter{uniqueKeys.insert(keyValue(makeHash,$0)).inserted}     
    }
}

La sintassi chiamante è leggermente diversa perché la chiusura riceve un parametro aggiuntivo contenente una funzione per eseguire l'hashing di un numero variabile di valori (che deve essere Hashable singolarmente)

peopleArray = peopleArray.filterDuplicate{ $0($1.name, $1.age, $1.sex) } 

Funzionerà anche con un singolo valore di unicità (usando $ 1 e ignorando $ 0).

peopleArray = peopleArray.filterDuplicate{ $1.name } 

È possibile utilizzare direttamente una raccolta di set per rimuovere i duplicati, quindi eseguirne il cast su un array

var myArray = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6]
var mySet = Set<Int>(myArray)

myArray = Array(mySet) // [2, 4, 60, 6, 15, 24, 1]

Quindi puoi ordinare l'array come desideri

myArray.sort{$0 < $1} // [1, 2, 4, 6, 15, 24, 60]

Versione della sintassi leggermente più sintetica della risposta Swift 2 di Daniel Krom , usando una chiusura finale e un nome di argomento abbreviato, che sembra essere basato sulla risposta originale di Airspeed Velocity :

func uniq<S: SequenceType, E: Hashable where E == S.Generator.Element>(source: S) -> [E] {
  var seen = [E: Bool]()
  return source.filter { seen.updateValue(true, forKey: $0) == nil }
}

Esempio di implementazione di un tipo personalizzato che può essere utilizzato con uniq(_:)(che deve essere conforme Hashable, e quindi Equatable, poiché si Hashableestende Equatable):

func ==(lhs: SomeCustomType, rhs: SomeCustomType) -> Bool {
  return lhs.id == rhs.id // && lhs.someOtherEquatableProperty == rhs.someOtherEquatableProperty
}

struct SomeCustomType {

  let id: Int

  // ...

}

extension SomeCustomType: Hashable {

  var hashValue: Int {
    return id
  }

}

Nel codice sopra ...

id, come utilizzato nel sovraccarico di ==, potrebbe essere qualsiasi Equatabletipo (o metodo che restituisce un Equatabletipo, ad es someMethodThatReturnsAnEquatableType().). Il codice commentato dimostra l'estensione del controllo per l'uguaglianza, dove someOtherEquatablePropertyè un'altra proprietà di un Equatabletipo (ma potrebbe anche essere un metodo che restituisce un Equatabletipo).

id, come usato nella hashValueproprietà calcolata (richiesta per conformarsi a Hashable), potrebbe essere qualsiasi Hashable(e quindi Equatable) proprietà (o metodo che restituisce un Hashabletipo).

Esempio di utilizzo uniq(_:):

var someCustomTypes = [SomeCustomType(id: 1), SomeCustomType(id: 2), SomeCustomType(id: 3), SomeCustomType(id: 1)]

print(someCustomTypes.count) // 4

someCustomTypes = uniq(someCustomTypes)

print(someCustomTypes.count) // 3

Nel caso abbiate bisogno di valori ordinati, questo funziona (Swift 4)

let sortedValues = Array(Set(array)).sorted()

Ecco una soluzione che

• Non utilizza NStipi legacy
• È ragionevolmente veloce con O(n)
• È conciso
• Conserva l'ordine degli elementi

extension Array where Element: Hashable {

    var uniqueValues: [Element] {
        var allowed = Set(self)
        return compactMap { allowed.remove($0) }
    }
}

qui ho fatto una soluzione O (n) per gli oggetti. Soluzione non di poche righe, ma ...

struct DistinctWrapper <T>: Hashable {
    var underlyingObject: T
    var distinctAttribute: String
    var hashValue: Int {
        return distinctAttribute.hashValue
    }
}
func distinct<S : SequenceType, T where S.Generator.Element == T>(source: S,
                                                                distinctAttribute: (T) -> String,
                                                                resolution: (T, T) -> T) -> [T] {
    let wrappers: [DistinctWrapper<T>] = source.map({
        return DistinctWrapper(underlyingObject: $0, distinctAttribute: distinctAttribute($0))
    })
    var added = Set<DistinctWrapper<T>>()
    for wrapper in wrappers {
        if let indexOfExisting = added.indexOf(wrapper) {
            let old = added[indexOfExisting]
            let winner = resolution(old.underlyingObject, wrapper.underlyingObject)
            added.insert(DistinctWrapper(underlyingObject: winner, distinctAttribute: distinctAttribute(winner)))
        } else {
            added.insert(wrapper)
        }
    }
    return Array(added).map( { return $0.underlyingObject } )
}
func == <T>(lhs: DistinctWrapper<T>, rhs: DistinctWrapper<T>) -> Bool {
    return lhs.hashValue == rhs.hashValue
}

// tests
// case : perhaps we want to get distinct addressbook list which may contain duplicated contacts like Irma and Irma Burgess with same phone numbers
// solution : definitely we want to exclude Irma and keep Irma Burgess
class Person {
    var name: String
    var phoneNumber: String
    init(_ name: String, _ phoneNumber: String) {
        self.name = name
        self.phoneNumber = phoneNumber
    }
}

let persons: [Person] = [Person("Irma Burgess", "11-22-33"), Person("Lester Davidson", "44-66-22"), Person("Irma", "11-22-33")]
let distinctPersons = distinct(persons,
    distinctAttribute: { (person: Person) -> String in
        return person.phoneNumber
    },
    resolution:
    { (p1, p2) -> Person in
        return p1.name.characters.count > p2.name.characters.count ? p1 : p2
    }
)
// distinctPersons contains ("Irma Burgess", "11-22-33") and ("Lester Davidson", "44-66-22")

Ho usato la risposta di Jean-Philippe Pellet e ho realizzato un'estensione di array che esegue operazioni simili a array su array, mantenendo l'ordine degli elementi.

/// Extensions for performing set-like operations on lists, maintaining order
extension Array where Element: Hashable {
  func unique() -> [Element] {
    var seen: [Element:Bool] = [:]
    return self.filter({ seen.updateValue(true, forKey: $0) == nil })
  }

  func subtract(takeAway: [Element]) -> [Element] {
    let set = Set(takeAway)
    return self.filter({ !set.contains($0) })
  }

  func intersect(with: [Element]) -> [Element] {
    let set = Set(with)
    return self.filter({ set.contains($0) })
  }
}

Questa è solo un'implementazione molto semplice e conveniente. Una proprietà calcolata in un'estensione di un array con elementi equabili.

extension Array where Element: Equatable {
    /// Array containing only _unique_ elements.
    var unique: [Element] {
        var result: [Element] = []
        for element in self {
            if !result.contains(element) {
                result.append(element)
            }
        }

        return result
    }
}

func removeDublicate (ab: [Int]) -> [Int] {
var answer1:[Int] = []
for i in ab {
    if !answer1.contains(i) {
        answer1.append(i)
    }}
return answer1
}

Uso:

let f = removeDublicate(ab: [1,2,2])
print(f)

1. Per prima cosa aggiungi tutti gli elementi di un array a NSOrderedSet.
2. Ciò rimuoverà tutti i duplicati nell'array.
3. Converti di nuovo questo set ordinato in un array.

Fatto....

Esempio

let array = [1,1,1,1,2,2,2,2,4,6,8]

let orderedSet : NSOrderedSet = NSOrderedSet(array: array)

let arrayWithoutDuplicates : NSArray = orderedSet.array as NSArray

output di arrayWithoutDuplicates - [1,2,4,6,8]

Una versione leggermente abbreviata basata sulla risposta dell'estensione dell'array @ Jean-Philippe Pellet:

extension Array where Element: Hashable {

    var uniques: Array {
        var added = Set<Element>()
        return filter { element in
            defer { added.insert(element) }
            return !added.contains(element)
        }
    }
}

Puoi sempre utilizzare un dizionario, poiché un dizionario può contenere solo valori univoci. Per esempio:

var arrayOfDates: NSArray = ["15/04/01","15/04/01","15/04/02","15/04/02","15/04/03","15/04/03","15/04/03"]

var datesOnlyDict = NSMutableDictionary()
var x = Int()

for (x=0;x<(arrayOfDates.count);x++) {
    let date = arrayOfDates[x] as String
    datesOnlyDict.setValue("foo", forKey: date)
}

let uniqueDatesArray: NSArray = datesOnlyDict.allKeys // uniqueDatesArray = ["15/04/01", "15/04/03", "15/04/02"]

println(uniqueDatesArray.count)  // = 3

Come puoi vedere, l'array risultante non sarà sempre in 'ordine'. Se si desidera ordinare / ordinare l'array, aggiungere questo:

var sortedArray = sorted(datesOnlyArray) {
(obj1, obj2) in

    let p1 = obj1 as String
    let p2 = obj2 as String
    return p1 < p2
}

println(sortedArray) // = ["15/04/01", "15/04/02", "15/04/03"]

.

Il modo più semplice sarebbe utilizzare NSOrderedSet, che memorizza elementi unici e conserva l'ordine degli elementi. Piace:

func removeDuplicates(from items: [Int]) -> [Int] {
    let uniqueItems = NSOrderedSet(array: items)
    return (uniqueItems.array as? [Int]) ?? []
}

let arr = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6]
removeDuplicates(from: arr)