De nos jours, dans Swift, vous tapez simplement Set( yourArray )pour rendre un tableau unique. (Ou un ensemble commandé si nécessaire.)

Avant que cela ne soit possible, comment cela se faisait-il?

Je pourrais avoir un tableau qui ressemble à ceci:

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

Ou, vraiment, n'importe quelle séquence de parties de données de type similaire. Ce que je veux faire, c'est m'assurer qu'il n'y a qu'un seul de chaque élément identique. Par exemple, le tableau ci-dessus deviendrait:

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

Notez que les doublons de 2, 6 et 15 ont été supprimés pour garantir qu'il n'y avait qu'un seul de chaque élément identique. Swift offre-t-il un moyen de le faire facilement ou devrai-je le faire moi-même?

Vous pouvez rouler le vôtre, par exemple comme ceci ( mis à jour pour Swift 1.2 avec 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]

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

Et comme extension pour 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
    }
}

Vous pouvez facilement convertir un ensemble et revenir à un tableau:

let unique = Array(Set(originals))

Il n'est pas garanti de conserver l'ordre d'origine de la baie.

Beaucoup de réponses disponibles ici, mais j'ai raté cette extension simple, adaptée à Swift 2 et plus:

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

Le rend super simple. Peut être appelé comme ceci:

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

Filtrage basé sur les propriétés

Pour filtrer un tableau en fonction des propriétés, vous pouvez utiliser cette méthode:

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

Que vous pouvez appeler comme suit:

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

Si vous mettez les deux extensions dans votre code, la Hashableversion la plus rapide sera utilisée lorsque cela sera possible et la Equatableversion sera utilisée comme solution de secours.

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

Si l'ordre n'est pas important, vous pouvez toujours simplement utiliser cet initialiseur Set .

modifier / mettre à jour Swift 4 ou version ultérieure

Nous pouvons également étendre le RangeReplaceableCollectionprotocole pour lui permettre d'être également utilisé avec des StringProtocoltypes:

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"

Méthode de mutation:

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

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

Pour Swift 3, cliquez ici

Swift 4

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

toute tentative de insertse retourner aussi un tuple: (inserted: Bool, memberAfterInsert: Set.Element). Voir documentation .

L'utilisation de la valeur renvoyée nous permet d'éviter de boucler ou d'effectuer toute autre opération.

Swift 4

Garanti pour continuer à commander.

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

Voici une catégorie sur SequenceTypelaquelle préserve l'ordre d'origine du tableau, mais utilise a Setpour effectuer les containsrecherches afin d'éviter le O(n)coût de la contains(_:)méthode 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 }
    }
}

Si vous n'êtes pas hashable ou equatable, vous pouvez passer un prédicat pour effectuer la vérification d'égalité:

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

Maintenant, si vous n'avez pas de hashable, mais que vous êtes équitable, vous pouvez utiliser cette méthode:

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

Enfin, vous pouvez ajouter une version de chemin d'accès clé unique comme ceci:

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

Vous pouvez coller les deux dans votre application, Swift choisira la bonne en fonction du Iterator.Elementtype de votre séquence .

Inspiré par https://www.swiftbysundell.com/posts/the-power-of-key-paths-in-swift , nous pouvons déclarer un outil plus puissant capable de filtrer pour l'unicité sur n'importe quel chemin de clé. Grâce aux commentaires d'Alexander sur diverses réponses concernant la complexité, les solutions ci-dessous devraient être presque optimales.

Solution non mutante

Nous étendons avec une fonction qui est capable de filtrer l'unicité sur n'importe quel 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 }
    }
}

Remarque: dans le cas où votre objet n'est pas conforme à RangeReplaceableCollection, mais est conforme à Sequence, vous pouvez avoir cette extension supplémentaire, mais le type de retour sera toujours un tableau:

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

Usage

Si nous voulons l'unicité pour les éléments eux-mêmes, comme dans la question, nous utilisons le 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] */

Si nous voulons l'unicité pour autre chose (comme pour idune collection d'objets) alors nous utilisons le chemin de clé de notre choix:

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

Solution de mutation

Nous étendons avec une fonction de mutation qui est capable de filtrer pour l'unicité sur n'importe quel 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 }
    }
}

Usage

Si nous voulons l'unicité pour les éléments eux-mêmes, comme dans la question, nous utilisons le 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] */

Si nous voulons l'unicité pour autre chose (comme pour idune collection d'objets) alors nous utilisons le chemin de clé de notre choix:

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

Une solution alternative (sinon optimale) d' ici utilisant des types immuables plutôt que des variables:

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
}

Inclus pour opposer l'approche impérative de Jean-Pillippe à une approche fonctionnelle.

En prime, cette fonction fonctionne aussi bien avec des chaînes qu'avec des tableaux!

Edit: Cette réponse a été écrite en 2014 pour Swift 1.0 (auparavant Setétait disponible dans Swift). Il ne nécessite pas de conformité Hashable et fonctionne en temps quadratique.

rapide 2

avec la fonction uniq réponse:

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

utilisation:

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

Dans Swift 5

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

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

La sortie sera

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

Encore une solution Swift 3.0 pour supprimer les doublons d'un tableau. Cette solution améliore de nombreuses autres solutions déjà proposées par:

• Préserver l'ordre des éléments dans le tableau d'entrée
• Complexité linéaire O (n): filtre passe unique O (n) + insertion de l'ensemble O (1)

Étant donné le tableau entier:

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]

Code fonctionnel:

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]

Code d'extension de tableau:

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]

Ce code tire parti du résultat renvoyé par l' insertopération on Set, qui s'exécute le O(1), et renvoie un tuple indiquant si l'élément a été inséré ou s'il existait déjà dans l'ensemble.

Si l'élément était dans l'ensemble, filterl'exclura du résultat final.

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

usage:

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

ou

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

Swift 5

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

Pensez comme un programmeur fonctionnel :)

Pour filtrer la liste selon que l'élément s'est déjà produit, vous avez besoin de l'index. Vous pouvez utiliser enumeratedpour obtenir l'index et maprevenir à la liste des valeurs.

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

Cela garantit la commande. Si la commande ne vous dérange pas, la réponse actuelle de Array(Set(myArray))est plus simple et probablement plus efficace.

MISE À JOUR: Quelques notes sur l'efficacité et l'exactitude

Quelques personnes ont commenté l'efficacité. Je suis définitivement à l'école d'écrire du code correct et simple d'abord, puis de trouver des goulots d'étranglement plus tard, bien que j'apprécie qu'il soit discutable que ce soit plus clair que Array(Set(array)).

Cette méthode est beaucoup plus lente que Array(Set(array)). Comme indiqué dans les commentaires, il préserve l'ordre et fonctionne sur les éléments qui ne sont pas hashable.

Cependant, la méthode de @Alain T préserve également l'ordre et est également beaucoup plus rapide. Donc, à moins que votre type d'élément ne soit pas lavable, ou que vous ayez simplement besoin d'une doublure rapide, je vous suggère d'aller avec leur solution.

Voici quelques tests sur un MacBook Pro (2014) sur Xcode 11.3.1 (Swift 5.1) en mode Release.

La fonction profileur et deux méthodes pour comparer:

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

Et une petite variété d'entrées de 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)}

Donne en sortie:

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

Pour les tableaux où les éléments ne sont ni hachables ni comparables (par exemple, des objets complexes, des dictionnaires ou des structures), cette extension fournit un moyen généralisé de supprimer les doublons:

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

Vous n'avez pas à vous soucier de rendre les valeurs Hashable et cela vous permet d'utiliser différentes combinaisons de champs pour l'unicité.

Remarque: pour une approche plus robuste, veuillez consulter la solution proposée par Coeur dans les commentaires ci-dessous.

stackoverflow.com/a/55684308/1033581

[MODIFIER] Alternative à Swift 4

Avec Swift 4.2, vous pouvez utiliser la classe Hasher pour créer un hachage beaucoup plus facilement. L'extension ci-dessus pourrait être modifiée pour en tirer parti:

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 syntaxe d'appel est un peu différente car la fermeture reçoit un paramètre supplémentaire contenant une fonction pour hacher un nombre variable de valeurs (qui doivent être hachables individuellement)

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

Il fonctionnera également avec une seule valeur d'unicité (en utilisant $ 1 et en ignorant $ 0).

peopleArray = peopleArray.filterDuplicate{ $1.name } 

Vous pouvez utiliser directement une collection de jeux pour supprimer les doublons, puis les reconstituer dans un tableau

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]

Ensuite, vous pouvez commander votre tableau comme vous le souhaitez

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

Version syntaxique un peu plus succincte de la réponse Swift 2 de Daniel Krom , utilisant une fermeture finale et un nom d'argument abrégé, qui semble être basé sur la réponse originale d'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 }
}

Exemple d'implémentation d'un type personnalisé qui peut être utilisé avec uniq(_:)(qui doit être conforme Hashable, et donc Equatable, parce Hashablequ'étend 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
  }

}

Dans le code ci-dessus ...

id, tel qu'il est utilisé dans la surcharge de ==, peut être n'importe quel Equatabletype (ou méthode qui renvoie un Equatabletype, par exemple, someMethodThatReturnsAnEquatableType()). Le code mis en commentaire montre l'extension de la vérification de l'égalité, où se someOtherEquatablePropertytrouve une autre propriété d'un Equatabletype (mais peut également être une méthode qui renvoie un Equatabletype).

id, tel qu'il est utilisé dans la hashValuepropriété calculée (requis pour se conformer à Hashable), peut être toute propriété ( Hashableet donc Equatable) (ou méthode qui renvoie un Hashabletype).

Exemple d'utilisation 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

Si vous avez besoin de trier les valeurs, cela fonctionne (Swift 4)

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

Voici une solution qui

• N'utilise aucun NStype hérité
• Est assez rapide avec O(n)
• Est concis
• Préserve l'ordre des éléments

extension Array where Element: Hashable {

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

ici, j'ai fait une solution O (n) pour les objets. Pas une solution en quelques lignes, mais ...

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

J'ai utilisé la réponse de @ Jean-Philippe Pellet et fait une extension Array qui effectue des opérations de type set sur des tableaux, tout en conservant l'ordre des éléments.

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

Ceci est juste une implémentation très simple et pratique. Une propriété calculée dans une extension d'un tableau qui a des éléments équables.

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
}

Usage:

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

1. Ajoutez d'abord tous les éléments d'un tableau à NSOrderedSet.
2. Cela supprimera tous les doublons de votre tableau.
3. Convertissez à nouveau cet ensemble ordonné en un tableau.

Terminé....

Exemple

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

sortie de arrayWithoutDuplicates - [1,2,4,6,8]

Une version légèrement raccourcie basée sur la réponse d'extension de tableau de @ 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)
        }
    }
}

Vous pouvez toujours utiliser un dictionnaire, car un dictionnaire ne peut contenir que des valeurs uniques. Par exemple:

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

Comme vous pouvez le voir, le tableau résultant ne sera pas toujours dans «l'ordre». Si vous souhaitez trier / commander le tableau, ajoutez ceci:

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

.

La façon la plus simple serait d'utiliser NSOrderedSet, qui stocke des éléments uniques et préserve l'ordre des éléments. Comme:

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)