Saat ini di Swift Anda cukup mengetik Set( yourArray )untuk membuat array unik. (Atau set memerintahkan jika diperlukan.)

Sebelum itu mungkin, bagaimana hal itu dilakukan?

Saya mungkin memiliki array yang terlihat seperti berikut:

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

Atau, sungguh, setiap urutan bagian data yang diketik seperti. Yang ingin saya lakukan adalah memastikan bahwa hanya ada satu dari setiap elemen yang identik. Misalnya, array di atas akan menjadi:

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

Perhatikan bahwa duplikat 2, 6, dan 15 telah dihapus untuk memastikan bahwa hanya ada satu dari setiap elemen yang identik. Apakah Swift menyediakan cara untuk melakukan ini dengan mudah, atau apakah saya harus melakukannya sendiri?

Anda dapat menggulung sendiri, misalnya seperti ini ( diperbarui untuk Swift 1.2 dengan 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]

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

Dan sebagai perpanjangan untuk 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
    }
}

Anda dapat mengonversi ke set dan kembali ke array dengan mudah:

let unique = Array(Set(originals))

Ini tidak dijamin untuk mempertahankan urutan asli array.

Banyak jawaban tersedia di sini, tetapi saya melewatkan ekstensi sederhana ini, cocok untuk Swift 2 dan lebih tinggi:

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

Jadikan super sederhana. Dapat disebut seperti ini:

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

Penyaringan berdasarkan properti

Untuk memfilter array berdasarkan properti, Anda dapat menggunakan metode ini:

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

Yang dapat Anda hubungi sebagai berikut:

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

Jika Anda memasukkan kedua ekstensi dalam kode Anda, Hashableversi yang lebih cepat akan digunakan bila memungkinkan, dan Equatableversi tersebut akan digunakan sebagai cadangan.

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

Jika pesanan tidak penting, maka Anda selalu dapat menggunakan Set initializer ini .

edit / perbarui Swift 4 atau lebih baru

Kami juga dapat memperluas RangeReplaceableCollectionprotokol untuk memungkinkannya digunakan dengan StringProtocoltipe juga:

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"

Metode bermutasi:

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

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

Untuk Swift 3 klik di sini

Cepat 4

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

setiap usaha untuk insertjuga akan kembali tupel: (inserted: Bool, memberAfterInsert: Set.Element). Lihat dokumentasi .

Menggunakan nilai yang dikembalikan membantu kita untuk menghindari perulangan atau melakukan operasi lainnya.

Cepat 4

Dijamin tetap memesan.

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

Berikut adalah kategori SequenceTypeyang mempertahankan urutan asli array, tetapi menggunakan a Setuntuk melakukan containspencarian untuk menghindari O(n)biaya pada contains(_:)metode 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 }
    }
}

Jika Anda tidak Hashable atau Equatable, Anda dapat memberikan predikat untuk melakukan pemeriksaan kesetaraan:

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

Sekarang, jika Anda tidak memiliki Hashable, tapi yang equatable, Anda dapat menggunakan metode ini:

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

Akhirnya, Anda dapat menambahkan versi jalur kunci unik seperti ini:

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

Anda dapat memasukkan keduanya ke dalam aplikasi Anda, Swift akan memilih yang tepat tergantung pada Iterator.Elementjenis urutan Anda .

Terinspirasi oleh https://www.swiftbysundell.com/posts/the-power-of-key-paths-in-swift , kita dapat mendeklarasikan alat yang lebih kuat yang mampu memfilter unicity pada keyPath apa pun. Berkat komentar Alexander tentang berbagai jawaban mengenai kompleksitas, solusi di bawah ini harus mendekati optimal.

Solusi non-mutasi

Kami memperluas dengan fungsi yang dapat memfilter untuk unicity pada keyPath apa pun:

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

Catatan: dalam kasus di mana objek Anda tidak sesuai dengan RangeReplaceableCollection, tetapi tidak sesuai dengan Sequence, Anda dapat memiliki ekstensi tambahan ini, tetapi tipe pengembalian akan selalu menjadi 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 }
    }
}

Pemakaian

Jika kita menginginkan kesatuan untuk elemen itu sendiri, seperti dalam pertanyaan, kita menggunakan 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] */

Jika kita menginginkan unicity untuk sesuatu yang lain (seperti untuk idkoleksi benda) maka kita menggunakan keyPath pilihan kita:

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

Solusi bermutasi

Kami memperluas dengan fungsi bermutasi yang dapat memfilter untuk unicity pada keyPath apa pun:

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

Pemakaian

Jika kita menginginkan kesatuan untuk elemen itu sendiri, seperti dalam pertanyaan, kita menggunakan 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] */

Jika kita menginginkan unicity untuk sesuatu yang lain (seperti untuk idkoleksi benda) maka kita menggunakan keyPath pilihan kita:

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

Solusi alternatif (jika tidak optimal) dari sini menggunakan tipe yang tidak berubah daripada variabel:

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
}

Termasuk kontras dengan pendekatan imperatif Jean-Pillippe dengan pendekatan fungsional.

Sebagai bonus, fungsi ini berfungsi dengan string dan juga array!

Sunting: Jawaban ini ditulis pada tahun 2014 untuk Swift 1.0 (sebelumnya Settersedia di Swift). Itu tidak memerlukan kepatuhan Hashable & berjalan dalam waktu kuadratik.

cepat 2

dengan jawaban fungsi 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
    })
}

menggunakan:

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

Dalam Swift 5

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

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

Output Akan

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

Satu lagi solusi Swift 3.0 untuk menghapus duplikat dari array. Solusi ini meningkat pada banyak solusi lain yang telah diusulkan oleh:

• Mempertahankan urutan elemen dalam larik input
• Kompleksitas linear O (n): filter single pass O (n) + set penyisipan O (1)

Diberikan bilangan bulat integer:

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]

Kode fungsional:

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]

Kode ekstensi 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]

Kode ini mengambil keuntungan dari hasil yang dikembalikan oleh insertoperasi aktif Set, yang dijalankan pada O(1), dan mengembalikan tupel yang menunjukkan apakah item telah dimasukkan atau jika sudah ada dalam set.

Jika item dalam set, filterakan mengecualikannya dari hasil akhir.

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

pemakaian:

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

atau

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

Cepat 5

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

Berpikir seperti programmer fungsional :)

Untuk memfilter daftar berdasarkan pada apakah elemen telah terjadi, Anda perlu indeks. Anda dapat menggunakan enumerateduntuk mendapatkan indeks dan mapkembali ke daftar nilai.

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

Ini menjamin pesanan. Jika Anda tidak keberatan dengan urutannya maka jawaban yang ada Array(Set(myArray))lebih sederhana dan mungkin lebih efisien.

PEMBARUAN: Beberapa catatan tentang efisiensi dan kebenaran

Beberapa orang berkomentar tentang efisiensi. Saya pasti di sekolah menulis kode yang benar dan sederhana pertama dan kemudian mencari tahu kemacetan kemudian, meskipun saya menghargai itu masih bisa diperdebatkan apakah ini lebih jelas daripada Array(Set(array)).

Metode ini jauh lebih lambat daripada Array(Set(array)). Seperti yang disebutkan dalam komentar, itu menjaga ketertiban dan bekerja pada elemen yang tidak Hashable.

Namun, metode @Alain T juga menjaga ketertiban dan juga jauh lebih cepat. Jadi kecuali tipe elemen Anda tidak dapat di hashable, atau Anda hanya perlu satu liner cepat, maka saya sarankan menggunakan solusi mereka.

Berikut adalah beberapa tes pada MacBook Pro (2014) pada Xcode 11.3.1 (Swift 5.1) dalam mode Rilis.

Fungsi profiler dan dua metode untuk membandingkan:

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

Dan sejumlah kecil input uji:

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

Memberikan sebagai 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

Untuk array yang elemennya tidak bisa Hashable atau Sebanding (mis. Objek kompleks, kamus atau struct), ekstensi ini menyediakan cara umum untuk menghapus duplikat:

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

Anda tidak perlu repot membuat nilai Hashable dan memungkinkan Anda menggunakan kombinasi bidang yang berbeda untuk keunikan.

Catatan: untuk pendekatan yang lebih kuat, silakan lihat solusi yang diusulkan oleh Coeur di komentar di bawah.

stackoverflow.com/a/55684308/1033581

[EDIT] Alternatif 4 cepat

Dengan Swift 4.2 Anda dapat menggunakan kelas Hasher untuk membangun hash lebih mudah. Ekstensi di atas dapat diubah untuk memanfaatkan ini:

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

Sintaks pemanggilan sedikit berbeda karena closure menerima parameter tambahan yang berisi fungsi untuk meng-hash sejumlah variabel nilai (yang harus Hashable secara individual)

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

Ini juga akan bekerja dengan nilai keunikan tunggal (menggunakan $ 1 dan mengabaikan $ 0).

peopleArray = peopleArray.filterDuplicate{ $1.name } 

Anda bisa menggunakan langsung kumpulan koleksi untuk menghapus duplikat, lalu melemparkannya kembali ke sebuah 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]

Kemudian Anda dapat memesan array seperti yang Anda inginkan

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

Versi sintaks yang sedikit lebih ringkas dari jawaban Swift 2 Daniel Krom , menggunakan trailing closure dan nama argumen steno, yang tampaknya didasarkan pada jawaban asli 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 }
}

Contoh penerapan tipe khusus yang dapat digunakan dengan uniq(_:)(yang harus sesuai dengan Hashable, dan karenanya Equatable, karena Hashablemeluas 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
  }

}

Dalam kode di atas ...

id, seperti yang digunakan dalam overload ==, bisa berupa Equatabletipe apa pun (atau metode yang mengembalikan Equatabletipe, misalnya, someMethodThatReturnsAnEquatableType()). Kode yang dikomentari menunjukkan perpanjangan pemeriksaan untuk kesetaraan, di mana someOtherEquatablePropertyproperti lain dari suatu Equatabletipe (tetapi juga bisa menjadi metode yang mengembalikan Equatabletipe).

id, seperti yang digunakan dalam hashValueproperti yang dihitung (diharuskan untuk menyesuaikan diri Hashable), bisa berupa properti apa pun Hashable(dan dengan demikian Equatable) (atau metode yang mengembalikan suatu Hashabletipe).

Contoh menggunakan 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

Jika Anda membutuhkan nilai yang diurutkan, ini berfungsi (Swift 4)

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

Ini solusinya

• Tidak menggunakan NSjenis warisan
• Cukup cepat dengan O(n)
• Ringkas
• Mempertahankan urutan elemen

extension Array where Element: Hashable {

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

di sini saya telah melakukan beberapa solusi O (n) untuk objek. Bukan solusi beberapa baris, tapi ...

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

Saya menggunakan jawaban @ Jean-Philippe Pellet dan membuat ekstensi Array yang melakukan operasi seperti set pada array, sambil mempertahankan urutan elemen.

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

Ini hanya implementasi yang sangat sederhana dan nyaman. Properti yang dihitung dalam perluasan Array yang memiliki elemen yang setara.

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
}

Pemakaian:

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

1. Pertama-tama tambahkan semua elemen array ke NSOrderedSet.
2. Ini akan menghapus semua duplikat dalam array Anda.
3. Sekali lagi konversikan set ini ke array.

Selesai ....

Contoh

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 dari arrayWithoutDuplicates - [1,2,4,6,8]

Versi singkat yang singkat berdasarkan pada jawaban ekstensi 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)
        }
    }
}

Anda selalu dapat menggunakan Kamus, karena Kamus hanya dapat menyimpan nilai unik. Sebagai contoh:

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

Seperti yang Anda lihat, array yang dihasilkan tidak selalu berada di 'urutan'. Jika Anda ingin mengurutkan / memesan Array, tambahkan ini:

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

.

Cara termudah adalah dengan menggunakan NSOrderedSet, yang menyimpan elemen unik dan mempertahankan urutan elemen. Suka:

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)