На основе https://www.swiftbysundell.com/posts/the-power-of-key-paths-in-swift, мы можем объявить более мощный инструмент, который может фильтровать уникальность по любому ключевому пути. Благодаря комментариям Александра к различным ответам относительно сложности, приведенные ниже решения должны быть близки к оптимальным.

Не мутирующее решение

Мы расширяем его функцией, которая может фильтровать уникальность по любому 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 }
    }
}

Примечание: в случае, если ваш объект не соответствует RangeReplaceableCollection, но соответствует Sequence, у вас может быть это дополнительное расширение, но возвращаемый тип всегда будет массивом:

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

использование

Если мы хотим уникальности для самих элементов, как в вопросе, мы используем 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] */

Если мы хотим уникальности для чего-то еще (например, для id коллекции объектов), мы используем keyPath по нашему выбору:

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

Мутирующее решение

Мы расширяем мутирующую функцию, которая может фильтровать уникальность по любому 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 }
    }
}

использование

Если мы хотим уникальности для самих элементов, как в вопросе, мы используем 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] */

Если нам нужна уникальность для чего-то еще (например, для id коллекции объектов), мы используем keyPath по нашему выбору:

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

Вот категория на SequenceType, которая сохраняет исходный порядок массива, но использует Set для поиска contains, чтобы избежать O(n) затрат на метод contains(_:) массива.

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

Если вы не Hashable или Equatable, вы можете передать предикат для проверки равенства:

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

Теперь, если у вас нет Hashable, но Equatable, вы можете использовать этот метод:

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

Наконец, вы можете добавить версию uniqued по ключевому пути следующим образом:

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

Вы можете вставить оба из них в свое приложение, Swift выберет правильный вариант в зависимости от Iterator.Element типа вашей последовательности.

Альтернативное (если не оптимальное) решение от здесь с использованием неизменяемых типов, а не переменных:

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
}

Включено, чтобы противопоставить императивный подход Жана-Пиллиппа функциональному подходу.

В качестве бонуса эта функция работает как со строками, так и с массивами!

Изменить: этот ответ был написан в 2014 году для Swift 1.0 (до того, как Set был доступен в Swift). Он не требует соответствия Hashable и работает за квадратичное время.

быстрый 2

с ответом функции 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
    })
}

использовать:

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

Еще одно решение Swift 3.0 для удаления дубликатов из массива. Это решение улучшает многие другие решения, уже предложенные:

• Сохранение порядка элементов во входном массиве
• Линейная сложность O (n): однопроходный фильтр O (n) + вставка набора O (1)

Учитывая целочисленный массив:

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]

Функциональный код:

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]

Код расширения массива:

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]

Этот код использует результат, возвращаемый операцией insert на Set, которая выполняется на O(1), и возвращает кортеж, указывающий, был ли элемент вставлен или уже существовал в наборе.

Если элемент был в наборе, filter исключит его из окончательного результата.

Swift 5

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

Думайте как функциональный программист :)

Чтобы отфильтровать список на основе того, появился ли элемент уже, вам нужен индекс. Вы можете использовать enumerated для получения индекса и map для возврата к списку значений.

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

Это гарантирует порядок. Если вас не волнует порядок, то существующий ответ Array(Set(myArray)) проще и, вероятно, более эффективен.

ОБНОВЛЕНИЕ: несколько замечаний по эффективности и правильности

Несколько человек прокомментировали эффективность. Я определенно учусь сначала писать правильный и простой код, а потом выяснять узкие места, хотя я понимаю, что это спорный вопрос, яснее ли это, чем Array(Set(array)).

Этот метод намного медленнее, чем Array(Set(array)). Как отмечено в комментариях, он сохраняет порядок и работает с элементами, которые не являются хэшируемыми.

Однако метод @Alain T также сохраняет порядок и работает намного быстрее. Поэтому, если ваш тип элемента не является хешируемым или вам просто нужен быстрый лайнер, я бы предложил использовать их решение.

Вот несколько тестов на MacBook Pro (2014 г.) на Xcode 11.3.1 (Swift 5.1) в режиме выпуска.

Функция профилировщика и два метода для сравнения:

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

И небольшое разнообразие тестовых входов:

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

Выдает в качестве вывода:

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

В Swift 5

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

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

Выход будет

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

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

использование:

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

or

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

Для массивов, элементы которых не являются ни хэшируемыми, ни сопоставимыми (например, сложные объекты, словари или структуры), это расширение предоставляет обобщенный способ удаления дубликатов:

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

Вам не нужно беспокоиться о создании значений Hashable, и он позволяет вам использовать различные комбинации полей для уникальности.

Примечание. Для более надежного подхода см. решение, предложенное Coeur, в комментариях ниже.

stackoverflow.com/a/55684308/1033581

[EDIT] альтернатива Swift 4

В Swift 4.2 вы можете использовать класс Hasher для более простого создания хеша. Вышеупомянутое расширение можно изменить, чтобы использовать это:

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

Синтаксис вызова немного отличается, потому что закрытие получает дополнительный параметр, содержащий функцию для хеширования переменного количества значений (которые должны быть хэшируемыми индивидуально)

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

Он также будет работать с одним значением уникальности (используя $ 1 и игнорируя $ 0).

peopleArray = peopleArray.filterDuplicate{ $1.name } 

Вы можете использовать непосредственно набор наборов для удаления дубликатов, а затем вернуть их в массив

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]

Затем вы можете заказать свой массив по своему усмотрению

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

Если вам нужны отсортированные значения, это работает (Swift 4)

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

Чуть более сжатая синтаксическая версия ответа Даниэля Крома Swift 2, использующая завершающее закрытие и сокращенное имя аргумента, которое, похоже, основано на на исходном ответе 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 }
}

Пример реализации настраиваемого типа, который может использоваться с uniq(_:) (который должен соответствовать Hashable и, следовательно, Equatable, потому что Hashable расширяет 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
  }

}

В приведенном выше коде ...

id, используемый в перегрузке ==, может быть любым Equatable типом (или методом, возвращающим тип Equatable, например, someMethodThatReturnsAnEquatableType()). Закомментированный код демонстрирует расширение проверки на равенство, где someOtherEquatableProperty - другое свойство типа Equatable (но также может быть методом, возвращающим тип Equatable).

id, используемый в вычисляемом свойстве hashValue (требуется для соответствия Hashable), может быть любым Hashable (и, следовательно, Equatable) свойством (или методом, возвращающим тип Hashable).

Пример использования 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

1. Сначала добавьте все элементы массива в NSOrderedSet.
2. Это удалит все дубликаты в вашем массиве.
3. Снова преобразуйте этот упорядоченный набор в массив.

Выполнено....

Пример

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

вывод arrayWithoutDuplicates - [1,2,4,6,8]

Вот решение, которое

• Не использует устаревшие NS типы
• Достаточно быстро с O(n)
• Кратко
• Сохраняет порядок элементов

extension Array where Element: Hashable {

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

здесь я сделал решение O (n) для объектов. Не многострочное решение, но ...

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

Я использовал ответ @Jan-Philippe Pellet и сделал расширение Array, которое выполняет операции, подобные множеству, с массивами, сохраняя при этом порядок элементов.

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

Это просто очень простая и удобная реализация. Вычисляемое свойство в расширении массива, которое имеет равноправные элементы.

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
}

Использование:

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

Swift 3 / Swift 4 / Swift 5

Всего одна строка кода, чтобы исключить дубликаты массива без изменения порядка:

let filteredArr = Array(NSOrderedSet(array: yourArray))

Самый простой способ - использовать NSOrderedSet, который хранит уникальные элементы и сохраняет порядок элементов. Нравиться:

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)

Я думаю, что это лучший способ знать саму логику

var arrayOfInts = [2, 2, 4, 4]
var mainArray = [Int]()

for value in arrayOfInts {

if mainArray.contains(value) != true  {
    
    mainArray.append(value)
    print("mainArray:\(mainArray)")
}}

Как было отмечено на WWDC 2021, Swift имеет разработанные сообществом алгоритмы, коллекции и числовые пакеты. Пакет Algorithms содержит алгоритм uniqued().

Они еще не входят в стандартную библиотеку Swift. В настоящее время вы можете загрузить их со страницы Apple на Github и / или установить через Swift Package Manager.

Видео WWDC:

https://developer.apple.com/videos/play/wwdc2021/10256/ < / а>

https://github.com/apple/swift-algorithms

uniqued() и uniqued(on:) документация:

https://github.com/apple/swift-algorithms/blob/main/Guides/Unique.md

Вы всегда можете использовать Словарь, потому что Словарь может содержать только уникальные значения. Например:

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

Как видите, результирующий массив не всегда будет в «порядке». Если вы хотите отсортировать / упорядочить массив, добавьте это:

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

.

Я считаю, что было бы хорошо предложить функции uniq() и uniqInPlace() для изменения массива путем удаления его значений. Это работает аналогично функциям sort() и sortInPlace(), предоставляемым Swift. Кроме того, поскольку это массив, он должен сохранять исходный порядок элементов.

extension Array where Element: Equatable {

    public func uniq() -> [Element] {
        var arrayCopy = self
        arrayCopy.uniqInPlace()
        return arrayCopy
    }

    mutating public func uniqInPlace() {
        var seen = [Element]()
        var index = 0
        for element in self {
            if seen.contains(element) {
                removeAtIndex(index)
            } else {
                seen.append(element)
                index++
            }
        }
    }
}

Вы можете использовать uniqInPlace() только в массиве переменных (т. Е. var), поскольку вы не можете изменять постоянный массив (т. Е. let).

Некоторые примеры использования:

var numbers = [1, 6, 2, 2, 4, 1, 5]
numbers.uniqInPlace() // array is now [1, 6, 2, 4, 5]

let strings = ["Y", "Z", "A", "Y", "B", "Y", "Z"]
let uniqStrings = strings.uniq() // uniqStrings is now ["Y", "Z", "A", "B"]

Позвольте мне предложить ответ, аналогичный ответу Скотта Гарднера, но с более лаконичным синтаксисом с использованием сокращения. Это решение удаляет дубликаты из массива настраиваемых объектов (сохраняя исходный порядок)

// Custom Struct. Can be also class. 
// Need to be `equitable` in order to use `contains` method below
struct CustomStruct : Equatable {
      let name: String
      let lastName : String
    }

// conform to Equatable protocol. feel free to change the logic of "equality"
func ==(lhs: CustomStruct, rhs: CustomStruct) -> Bool {
  return (lhs.name == rhs.name && lhs.lastName == rhs.lastName)
}

let categories = [CustomStruct(name: "name1", lastName: "lastName1"),
                  CustomStruct(name: "name2", lastName: "lastName1"),
                  CustomStruct(name: "name1", lastName: "lastName1")]
print(categories.count) // prints 3

// remove duplicates (and keep initial order of elements)
let uniq1 : [CustomStruct] = categories.reduce([]) { $0.contains($1) ? $0 : $0 + [$1] }
print(uniq1.count) // prints 2 - third element has removed

И просто, если вам интересно, как работает эта магия сокращения - здесь точно то же самое, но с использованием более расширенного синтаксиса сокращения

let uniq2 : [CustomStruct] = categories.reduce([]) { (result, category) in
  var newResult = result
  if (newResult.contains(category)) {}
  else {
    newResult.append(category)
  }
  return newResult
}
uniq2.count // prints 2 - third element has removed

Вы можете просто скопировать и вставить этот код в Swift Playground и поэкспериментировать.

В Swift 3.0 я нашел самое простое и быстрое решение для устранения повторяющихся элементов при сохранении порядка:

extension Array where Element:Hashable {
    var unique: [Element] {
        var set = Set<Element>() //the unique list kept in a Set for fast retrieval
        var arrayOrdered = [Element]() //keeping the unique list of elements but ordered
        for value in self {
            if !set.contains(value) {
                set.insert(value)
                arrayOrdered.append(value)
            }
        }

        return arrayOrdered
    }
}

Вот более гибкий способ сделать последовательность уникальной с помощью настраиваемой функции сопоставления.

extension Sequence where Iterator.Element: Hashable {

    func unique(matching: (Iterator.Element, Iterator.Element) -> Bool) -> [Iterator.Element] {

        var uniqueArray: [Iterator.Element] = []
        forEach { element in
            let isUnique = uniqueArray.reduce(true, { (result, item) -> Bool in
                return result && matching(element, item)
            })
            if isUnique {
                uniqueArray.append(element)
            }
        }
        return uniqueArray
    }
}

это самый простой способ в Swift 4.2 и далее код, как показано ниже

let keyarray:NSMutableArray = NSMutableArray()

for  object in dataArr
{
    if !keysArray.contains(object){
        keysArray.add(object)
    }
}

print(keysArray)

Xcode 10.1 - Простое и мощное решение Swift 4.2

func removeDuplicates(_ nums: inout [Int]) -> Int {
    nums = Set(nums).sorted()
    return nums.count
}

Пример

var arr = [1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9]
removeDuplicates(&arr)

print(arr) // [1,2,3,4,5,6,7,8,9]

Мое решение, кажется, может быть в O (n) времени, поскольку доступ к хэш-карте - O (1), а фильтр - O (n). Он также использует закрытие для выбора свойства, по которому следует различать элементы в последовательности.

extension Sequence {

    func distinct<T: Hashable>(by: (Element) -> T) -> [Element] {
        var seen: [T: Bool] = [:]
        return self.filter { seen.updateValue(true, forKey: by($0)) == nil }
    }
}

Я создал функцию высшего порядка с временной сложностью o (n). Кроме того, такая возможность, как карта, возвращать любой тип, который вы хотите.

extension Sequence {
    func distinct<T,U>(_ provider: (Element) -> (U, T)) -> [T] where U: Hashable {
        var uniqueKeys = Set<U>()
        var distintValues = [T]()
        for object in self {
            let transformed = provider(object)
            if !uniqueKeys.contains(transformed.0) {
                distintValues.append(transformed.1)
                uniqueKeys.insert(transformed.0)
            }
        }
        return distintValues
    }
}

если вы хотите сохранить порядок, используйте это

let fruits = ["apple", "pear", "pear", "banana", "apple"] 
let orderedNoDuplicates = Array(NSOrderedSet(array: fruits).map({ $0 as! String }))

Сохранять уникальные значения и сохранять сортировку в массиве.

(с использованием Swift 3)

    var top3score: [Int] = []


    outerLoop: for i in 0..<top10score.count {
        dlog(message: String(top10score[i]))

        if top3score.count == 3 {
            break
        }

        for aTop3score in top3score {
            if aTop3score == top10score[i] {
                continue outerLoop
            }
        }

        top3score.append(top10score[i])

    }

    print("top10score is \(top10score)")  //[14, 5, 5, 5, 3, 3, 2, 2, 2, 2]
    print("top3score is \(top3score)")   //[14, 5, 3]

Для этой цели я сделал максимально простое расширение.

extension Array where Element: Equatable {

    func containsHowMany(_ elem: Element) -> Int {
        return reduce(0) { $1 == elem ? $0 + 1 : $0 }
    }

    func duplicatesRemoved() -> Array {
        return self.filter { self.containsHowMany($0) == 1 }
    }

    mutating func removeDuplicates() {
        self = self.duplicatesRemoved(()
    }
}

Вы можете использовать duplicatesRemoved(), чтобы получить новый массив, повторяющиеся элементы которого удалены, или removeDuplicates(), чтобы изменить себя. Видеть:

let arr = [1, 1, 1, 2, 2, 3, 4, 5, 6, 6, 6, 6, 6, 7, 8]

let noDuplicates = arr.duplicatesRemoved()
print(arr) // [1, 1, 1, 2, 2, 3, 4, 5, 6, 6, 6, 6, 6, 7, 8]
print(noDuplicates) // [1, 2, 3, 4, 5, 6, 7, 8]

arr.removeDuplicates()
print(arr) // [1, 2, 3, 4, 5, 6, 7, 8]

var numbers = [1,2,3,4,5,10,10, 12, 12, 6,6,6,7,8,8, 8, 8, 8 , 7 , 1 , 1, 2 , 9]

var newArr : [Int] = []
for n in numbers {
    if !newArr.contains(n) {
        newArr.append(n)
    }
}

вывод - [1, 2, 3, 4, 5, 10, 12, 6, 7, 8, 9]

Приведенное выше решение поддерживает порядок, но очень медленно, поскольку .contains повторяется снова и снова. Таким образом используйте заказанный набор.

Это напечатает упорядоченный массив.

Array(NSOrderedSet.init(array: numbers))

вывод - [1, 2, 3, 4, 5, 10, 12, 6, 7, 8, 9]

Это напечатает неупорядоченный массив.

let uniqueUnordered = Array(Set(numbers))

вывод - [4, 2, 1, 9, 10, 3, 5, 6, 8, 12, 7]

Это работает в Swift 4, если вы не хотите / не должны преобразовывать результат в массив, но можете сделать это с помощью Set. По умолчанию результат не сортируется, но вы можете сделать это с помощью sorted (), который возвращает массив, как показано в операторе печати.

let array = [1, 4, 2, 2, 6, 24, 15, 2, 60, 15, 6]

var result = Set<Int>()
_ = array.map{ result.insert($0) }

print(result.sorted())  // [1, 2, 4, 6, 15, 24, 60]