Heutzutage geben Sie in Swift einfach ein Set( yourArray ), um ein Array einzigartig zu machen. (Oder ein bestelltes Set, falls erforderlich.)

Wie wurde es gemacht, bevor das möglich war?

Ich könnte ein Array haben, das wie folgt aussieht:

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

Oder wirklich jede Folge von gleichartigen Teilen von Daten. Ich möchte sicherstellen, dass es nur eines von jedem identischen Element gibt. Zum Beispiel würde das obige Array werden:

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

Beachten Sie, dass die Duplikate von 2, 6 und 15 entfernt wurden, um sicherzustellen, dass nur eines von jedem identischen Element vorhanden ist. Bietet Swift eine Möglichkeit, dies einfach zu tun, oder muss ich es selbst tun?

Sie können Ihre eigenen rollen, zB wie folgt ( aktualisiert für Swift 1.2 mit 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]

Swift 3 Version:

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
}

Und als Erweiterung für 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
    }
}

Sie können ganz einfach in ein Set und wieder in ein Array konvertieren:

let unique = Array(Set(originals))

Es wird nicht garantiert, dass die ursprüngliche Reihenfolge des Arrays beibehalten wird.

Viele Antworten finden Sie hier, aber ich habe diese einfache Erweiterung verpasst, die für Swift 2 und höher geeignet ist:

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

Macht es super einfach. Kann so genannt werden:

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

Filterung basierend auf Eigenschaften

Um ein Array basierend auf Eigenschaften zu filtern, können Sie folgende Methode verwenden:

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

Was Sie wie folgt anrufen können:

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

Wenn Sie beide Erweiterungen in Ihren Code einfügen, Hashablewird nach Möglichkeit die schnellere Version und die EquatableVersion als Fallback verwendet.

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

Wenn die Reihenfolge nicht wichtig ist, können Sie immer nur diesen Set-Initialisierer verwenden .

Swift 4 oder höher bearbeiten / aktualisieren

Wir können das RangeReplaceableCollectionProtokoll auch erweitern , damit es auch mit StringProtocolTypen verwendet werden kann:

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"

Mutationsmethode:

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

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

Für Swift 3 klicken Sie hier

Swift 4

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

Bei jedem Versuch insertwird auch ein Tupel zurückgegeben : (inserted: Bool, memberAfterInsert: Set.Element). Siehe Dokumentation .

Die Verwendung des zurückgegebenen Werts hilft uns, Schleifen oder andere Operationen zu vermeiden.

Swift 4

Garantiert weiterhin zu bestellen.

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

Hier ist eine Kategorie auf SequenceTypedem die ursprüngliche Reihenfolge der Anordnung bewahrt, sondern verwendet ein Setdie tun containsLookups das zu vermeiden , O(n)Kosten auf Array der contains(_:)Methode.

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

Wenn Sie nicht Hashable oder Equatable sind, können Sie ein Prädikat übergeben, um die Gleichheitsprüfung durchzuführen:

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

Nun, wenn Sie nicht Hashable haben, aber sind gleichzusetzen, können Sie diese Methode verwenden:

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: ==)
    }
}

Schließlich können Sie eine Schlüsselpfadversion von Uniqued wie folgt hinzufügen:

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

Sie können beide in Ihre App einfügen. Swift wählt je nach Sequenztyp die richtige aus Iterator.Element.

Inspiriert von https://www.swiftbysundell.com/posts/the-power-of-key-paths-in-swift können wir ein leistungsfähigeres Tool deklarieren, das auf jedem keyPath nach Einheitlichkeit filtern kann. Dank der Kommentare von Alexander zu verschiedenen Antworten bezüglich der Komplexität sollten die folgenden Lösungen nahezu optimal sein.

Nicht mutierende Lösung

Wir erweitern mit einer Funktion, die in der Lage ist, auf jedem keyPath nach Einigkeit zu filtern:

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

Hinweis: Wenn Ihr Objekt nicht RangeReplaceableCollection, sondern Sequence entspricht, können Sie diese zusätzliche Erweiterung verwenden. Der Rückgabetyp ist jedoch immer ein 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 }
    }
}

Verwendung

Wenn wir wie in der Frage eine Einheit für die Elemente selbst wünschen, verwenden wir den 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] */

Wenn wir Einheit für etwas anderes wollen (wie für die ideine Sammlung von Objekten), verwenden wir den Schlüsselpfad unserer Wahl:

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}] */

Mutierende Lösung

Wir erweitern mit einer Mutationsfunktion, die in der Lage ist, auf jedem keyPath nach Einigkeit zu filtern:

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

Verwendung

Wenn wir wie in der Frage eine Einheit für die Elemente selbst wünschen, verwenden wir den 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] */

Wenn wir die Einheitlichkeit für etwas anderes wollen (wie für ideine Sammlung von Objekten), verwenden wir den Schlüsselpfad unserer Wahl:

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}] */

Eine alternative (wenn nicht optimale) Lösung von hier aus , bei der unveränderliche Typen anstelle von Variablen verwendet werden:

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
}

Eingeschlossen, um Jean-Pillippes imperativen Ansatz einem funktionalen Ansatz gegenüberzustellen.

Als Bonus funktioniert diese Funktion sowohl mit Strings als auch mit Arrays!

Bearbeiten: Diese Antwort wurde 2014 für Swift 1.0 geschrieben (zuvor Setwar sie in Swift verfügbar). Es erfordert keine Hashable-Konformität und wird in quadratischer Zeit ausgeführt.

schnell 2

mit uniq funktion antwort :

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

verwenden:

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)

Ausgabe wird sein

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

Eine weitere Swift 3.0-Lösung zum Entfernen von Duplikaten aus einem Array. Diese Lösung verbessert viele andere Lösungen, die bereits vorgeschlagen wurden von:

• Beibehaltung der Reihenfolge der Elemente im Eingabearray
• Lineare Komplexität O (n): Single-Pass-Filter O (n) + Set Insertion O (1)

Angesichts des Integer-Arrays:

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]

Funktionscode:

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]

Array-Erweiterungscode:

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]

Dieser Code nutzt das Ergebnis, das von der insertOperation on zurückgegeben wird Set, die on ausgeführt wirdO(1) , und gibt ein Tupel zurück, das angibt, ob das Element eingefügt wurde oder ob es bereits in der Gruppe vorhanden war.

Wenn sich das Element im Set befand, filterwird es vom Endergebnis ausgeschlossen.

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

Verwendung:

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

oder

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

Swift 5

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

Denken Sie wie ein funktionierender Programmierer :)

Um die Liste danach zu filtern, ob das Element bereits aufgetreten ist, benötigen Sie den Index. Sie können verwenden enumerated, um den Index abzurufen und mapzur Werteliste zurückzukehren.

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

Dies garantiert die Bestellung. Wenn Ihnen die Reihenfolge nichts ausmacht, ist die vorhandene Antwort von Array(Set(myArray))einfacher und wahrscheinlich effizienter.

UPDATE: Einige Hinweise zu Effizienz und Korrektheit

Einige Leute haben die Effizienz kommentiert. Ich bin definitiv in der Schule, zuerst korrekten und einfachen Code zu schreiben und später Engpässe herauszufinden, obwohl ich es zu schätzen weiß, dass es fraglich ist, ob dies klarer ist alsArray(Set(array)) .

Diese Methode ist viel langsamer als Array(Set(array)) . Wie in den Kommentaren erwähnt, bleibt die Reihenfolge erhalten und es werden Elemente verarbeitet, die nicht haschbar sind.

Die Methode von @Alain T bewahrt jedoch auch die Ordnung und ist auch viel schneller. Wenn Ihr Elementtyp also nicht hashbar ist oder Sie nur einen schnellen Einzeiler benötigen, würde ich vorschlagen, mit ihrer Lösung fortzufahren.

Hier sind einige Tests auf einem MacBook Pro (2014) unter Xcode 11.3.1 (Swift 5.1) im Release-Modus.

Die Profiler-Funktion und zwei Methoden zum Vergleichen:

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

Und eine kleine Auswahl an Testeingaben:

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

Gibt als Ausgabe:

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

Für Arrays, in denen die Elemente weder Hashbar noch Vergleichbar sind (z. B. komplexe Objekte, Wörterbücher oder Strukturen), bietet diese Erweiterung eine allgemeine Möglichkeit, Duplikate zu entfernen:

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

Sie müssen sich nicht darum kümmern, Werte Hashable zu machen, und Sie können verschiedene Kombinationen von Feldern für die Eindeutigkeit verwenden.

Hinweis: Für einen robusteren Ansatz lesen Sie bitte die von Coeur vorgeschlagene Lösung in den Kommentaren unten.

stackoverflow.com/a/55684308/1033581

[EDIT] Swift 4 Alternative

Mit Swift 4.2 können Sie die Hasher-Klasse verwenden, um einen Hash viel einfacher zu erstellen. Die obige Erweiterung könnte geändert werden, um dies zu nutzen:

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

Die aufrufende Syntax ist etwas anders, da der Abschluss einen zusätzlichen Parameter erhält, der eine Funktion zum Hashing einer variablen Anzahl von Werten enthält (die einzeln Hash-fähig sein müssen).

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

Es funktioniert auch mit einem einzelnen Eindeutigkeitswert (unter Verwendung von $ 1 und Ignorieren von $ 0).

peopleArray = peopleArray.filterDuplicate{ $1.name } 

Sie können eine Set-Sammlung direkt verwenden, um Duplikate zu entfernen und sie dann wieder in ein Array umzuwandeln

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]

Dann können Sie Ihr Array bestellen, wie Sie möchten

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

Etwas prägnantere Syntaxversion von Daniel Kroms Swift 2-Antwort unter Verwendung eines abschließenden Verschlusses und eines Kurzargumentnamens, der anscheinend auf der ursprünglichen Antwort von Airspeed Velocity basiert :

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

Beispiel für einen benutzerdefinierten Typ implementieren, die mit verwendet werden können uniq(_:)(die entsprechen müssen Hashable, und damit Equatable, weil Hashablesich 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
  }

}

Im obigen Code ...

id, wie bei der Überladung von verwendet ==, kann ein beliebiger EquatableTyp sein (oder eine Methode, die einen EquatableTyp zurückgibt , z someMethodThatReturnsAnEquatableType(). B. ). Der auskommentierte Code demonstriert die Erweiterung der Prüfung auf Gleichheit, wobei someOtherEquatablePropertyes sich um eine andere Eigenschaft eines EquatableTyps handelt (es kann sich aber auch um eine Methode handeln, die einen EquatableTyp zurückgibt ).

id, wie in der hashValueberechneten Eigenschaft verwendet (erforderlich, um konform zu sein Hashable), kann eine beliebige Hashable(und damit Equatable) Eigenschaft (oder Methode, die einen HashableTyp zurückgibt ) sein.

Anwendungsbeispiel 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

Wenn Sie sortierte Werte benötigen, funktioniert dies (Swift 4)

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

Hier ist eine Lösung, die

• Verwendet kein Vermächtnis NS Typen
• Ist einigermaßen schnell mit O(n)
• Ist prägnant
• Erhält die Elementreihenfolge

extension Array where Element: Hashable {

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

Hier habe ich eine O (n) -Lösung für Objekte durchgeführt. Nicht wenige Zeilen Lösung, aber ...

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")

Ich habe die Antwort von @ Jean-Philippe Pellet verwendet und eine Array-Erweiterung erstellt, die satzartige Operationen für Arrays ausführt, während die Reihenfolge der Elemente beibehalten wird.

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

Dies ist nur eine sehr einfache und bequeme Implementierung. Eine berechnete Eigenschaft in einer Erweiterung eines Arrays mit gleichwertigen Elementen.

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
}

Verwendung:

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

1. Fügen Sie zunächst alle Elemente eines Arrays zu NSOrderedSet hinzu.
2. Dadurch werden alle Duplikate in Ihrem Array entfernt.
3. Konvertieren Sie diese geordnete Menge erneut in ein Array.

Getan....

Beispiel

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

Ausgabe von arrayWithoutDuplicates - [1,2,4,6,8]

Eine leicht verkürzte Version, die auf der Antwort der Array-Erweiterung von @ Jean-Philippe Pellet basiert:

extension Array where Element: Hashable {

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

Sie können immer ein Wörterbuch verwenden, da ein Wörterbuch nur eindeutige Werte enthalten kann. Beispielsweise:

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

Wie Sie sehen können, befindet sich das resultierende Array nicht immer in der richtigen Reihenfolge. Wenn Sie das Array sortieren / bestellen möchten, fügen Sie Folgendes hinzu:

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"]

.

Am einfachsten wäre es, NSOrderedSet zu verwenden, das eindeutige Elemente speichert und die Reihenfolge der Elemente beibehält. Mögen:

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)