Ngày nay trong Swift bạn chỉ cần gõ Set( yourArray ) để tạo một mảng duy nhất. (Hoặc một bộ được đặt hàng nếu cần.)

Trước khi điều đó là có thể, nó đã được thực hiện như thế nào?

Tôi có thể có một mảng trông như sau:

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

Hoặc, thực sự, bất kỳ chuỗi các phần giống như dữ liệu được gõ. Điều tôi muốn làm là đảm bảo rằng chỉ có một trong mỗi yếu tố giống hệt nhau. Ví dụ, mảng trên sẽ trở thành:

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

Lưu ý rằng các bản sao của 2, 6 và 15 đã bị xóa để đảm bảo rằng chỉ có một trong mỗi phần tử giống hệt nhau. Swift có cung cấp một cách để làm điều này một cách dễ dàng, hoặc tôi sẽ phải tự làm điều đó?

Bạn có thể tự cuộn, ví dụ như thế này ( được cập nhật cho Swift 1.2 với 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]

Phiên bản 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
}

Và như một phần mở rộng cho 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
    }
}

Bạn có thể chuyển đổi thành một tập hợp và trở lại một mảng khá dễ dàng:

let unique = Array(Set(originals))

Điều này không được đảm bảo để duy trì thứ tự ban đầu của mảng.

Nhiều câu trả lời có sẵn ở đây, nhưng tôi đã bỏ lỡ tiện ích mở rộng đơn giản này, phù hợp với Swift 2 trở lên:

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

Làm cho nó siêu đơn giản. Có thể được gọi như thế này:

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

Lọc dựa trên các thuộc tính

Để lọc một mảng dựa trên các thuộc tính, bạn có thể sử dụng phương pháp này:

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

Mà bạn có thể gọi như sau:

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

Nếu bạn đặt cả hai phần mở rộng trong mã của mình, Hashablephiên bản nhanh hơn sẽ được sử dụng khi có thể và Equatablephiên bản sẽ được sử dụng làm dự phòng.

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

Nếu thứ tự không quan trọng, thì bạn luôn có thể sử dụng Bộ khởi tạo này .

chỉnh sửa / cập nhật Swift 4 trở lên

Chúng tôi cũng có thể mở rộng RangeReplaceableCollectiongiao thức để cho phép nó được sử dụng với StringProtocolcác loại:

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"

Phương pháp đột biến:

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

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

Đối với Swift 3 bấm vào đây

Swift 4

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

mọi nỗ lực insertcũng sẽ trả lại một tuple : (inserted: Bool, memberAfterInsert: Set.Element). Xem tài liệu .

Sử dụng giá trị trả về giúp chúng ta tránh lặp hoặc thực hiện bất kỳ thao tác nào khác.

Swift 4

Đảm bảo tiếp tục đặt hàng.

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

Đây là một danh mục SequenceTypeđể duy trì thứ tự ban đầu của mảng, nhưng sử dụng một thao Settác containstra cứu để tránh O(n)chi phí cho contains(_:)phương thức của 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 }
    }
}

Nếu bạn không Hashable hoặc Equitable, bạn có thể vượt qua một vị từ để thực hiện kiểm tra tính bằng:

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

Bây giờ, nếu bạn không có Hashable, nhưng có thể tương đương, bạn có thể sử dụng phương pháp này:

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

Cuối cùng, bạn có thể thêm một phiên bản đường dẫn chính của duy nhất như thế này:

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

Bạn có thể dán cả hai thứ này vào ứng dụng của mình, Swift sẽ chọn đúng tùy thuộc vào Iterator.Elementloại trình tự của bạn .

Lấy cảm hứng từ https://www.swiftbysundell.com/posts/the-power-of-key-paths-in-swift , chúng tôi có thể tuyên bố một công cụ mạnh hơn có thể lọc tính đơn nhất trên bất kỳ keyPath nào. Nhờ nhận xét của Alexander về các câu trả lời khác nhau về độ phức tạp, các giải pháp dưới đây sẽ gần tối ưu.

Giải pháp không đột biến

Chúng tôi mở rộng với một chức năng có thể lọc tính đơn nhất trên bất kỳ keyPath nào:

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

Lưu ý: trong trường hợp đối tượng của bạn không tuân thủ RangeReplacizableCollection, nhưng không tuân thủ Trình tự, bạn có thể có tiện ích mở rộng bổ sung này, nhưng kiểu trả về sẽ luôn là Mảng:

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

Sử dụng

Nếu chúng ta muốn duy nhất cho các thành phần, như trong câu hỏi, chúng ta sử dụng 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] */

Nếu chúng ta muốn duy nhất cho một cái gì đó khác (như cho idmột bộ sưu tập các đối tượng) thì chúng ta sử dụng keyPath theo lựa chọn của chúng ta:

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

Giải pháp đột biến

Chúng tôi mở rộng với chức năng đột biến có thể lọc tính đơn nhất trên bất kỳ keyPath nào:

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

Sử dụng

Nếu chúng ta muốn duy nhất cho các thành phần, như trong câu hỏi, chúng ta sử dụng 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] */

Nếu chúng ta muốn duy nhất cho một cái gì đó khác (như cho idmột bộ sưu tập các đối tượng) thì chúng ta sử dụng keyPath theo lựa chọn của chúng ta:

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

Một giải pháp thay thế (nếu không tối ưu) từ đây sử dụng các loại không thay đổi thay vì các biến:

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
}

Bao gồm để tương phản cách tiếp cận bắt buộc của Jean-Pillippe với một cách tiếp cận chức năng.

Là một phần thưởng, chức năng này hoạt động với các chuỗi cũng như các mảng!

Chỉnh sửa: Câu trả lời này được viết vào năm 2014 cho Swift 1.0 (trước đây Setđã có trong Swift). Nó không yêu cầu tuân thủ Hashable và chạy trong thời gian bậc hai.

nhanh 2

với hàm uniq trả lời:

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

sử dụng:

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

Trong Swift 5

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

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

Đầu ra sẽ là

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

Thêm một giải pháp Swift 3.0 để loại bỏ các bản sao khỏi một mảng. Giải pháp này cải thiện trên nhiều giải pháp khác đã được đề xuất bởi:

• Giữ nguyên thứ tự của các phần tử trong mảng đầu vào
• Độ phức tạp tuyến tính O (n): bộ lọc thông đơn O (n) + bộ chèn O (1)

Cho mảng số nguyên:

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]

Mã chức năng:

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]

Mã mở rộng mảng:

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]

Mã này lợi dụng kết quả được trả về bởi insertthao tác trên Set, thực thi trên O(1)và trả về một tuple cho biết liệu mục đó đã được chèn hay nếu nó đã tồn tại trong tập hợp.

Nếu mục nằm trong tập hợp, filtersẽ loại trừ nó khỏi kết quả cuối cùng.

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

sử dụng:

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

hoặc là

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

Swift 5

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

Hãy suy nghĩ như một lập trình viên chức năng :)

Để lọc danh sách dựa trên việc phần tử đã xảy ra chưa, bạn cần chỉ mục. Bạn có thể sử dụng enumeratedđể lấy chỉ mục và maptrở về danh sách các giá trị.

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

Điều này đảm bảo trật tự. Nếu bạn không quan tâm đến thứ tự thì câu trả lời hiện tại Array(Set(myArray))đơn giản hơn và có thể hiệu quả hơn.

CẬP NHẬT: Một số lưu ý về hiệu quả và tính chính xác

Một vài người đã nhận xét về hiệu quả. Tôi chắc chắn trong trường viết mã chính xác và đơn giản trước và sau đó tìm ra các nút thắt sau đó, mặc dù tôi đánh giá cao việc tranh cãi liệu điều này có rõ ràng hơn không Array(Set(array)).

Phương pháp này chậm hơn rất nhiều Array(Set(array)). Như đã lưu ý trong các bình luận, nó bảo toàn trật tự và hoạt động trên các yếu tố không Hashable.

Tuy nhiên, phương pháp của @Alain T cũng giữ trật tự và cũng nhanh hơn rất nhiều. Vì vậy, trừ khi loại phần tử của bạn không thể băm được, hoặc bạn chỉ cần một lớp lót nhanh, thì tôi khuyên bạn nên đi với giải pháp của họ.

Dưới đây là một vài thử nghiệm trên MacBook Pro (2014) trên Xcode 11.3.1 (Swift 5.1) ở chế độ Phát hành.

Hàm profiler và hai phương thức để so sánh:

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

Và một loạt các đầu vào thử nghiệm:

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

Cung cấp như đầu ra:

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

Đối với các mảng trong đó các phần tử không phải là Hashable hay so sánh (ví dụ: các đối tượng phức tạp, từ điển hoặc cấu trúc), phần mở rộng này cung cấp một cách tổng quát để loại bỏ trùng lặp:

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

Bạn không phải bận tâm với việc tạo các giá trị Hashable và nó cho phép bạn sử dụng các kết hợp các trường khác nhau để duy nhất.

Lưu ý: để có cách tiếp cận mạnh mẽ hơn, vui lòng xem giải pháp do Coeur đề xuất trong các bình luận bên dưới.

stackoverflow.com/a/55684308/1033581

[EDIT] Swift 4 thay thế

Với Swift 4.2, bạn có thể sử dụng lớp Hasher để xây dựng hàm băm dễ dàng hơn nhiều. Phần mở rộng trên có thể được thay đổi để tận dụng điều này:

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

Cú pháp gọi hơi khác một chút vì bao đóng nhận được một tham số bổ sung có chứa hàm để băm một số lượng giá trị thay đổi (phải là Hashable riêng lẻ)

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

Nó cũng sẽ hoạt động với một giá trị duy nhất (sử dụng $ 1 và bỏ qua $ 0).

peopleArray = peopleArray.filterDuplicate{ $1.name } 

Bạn có thể sử dụng trực tiếp một bộ sưu tập để loại bỏ trùng lặp, sau đó chuyển nó trở lại một mảng

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]

Sau đó, bạn có thể đặt hàng mảng của bạn như bạn muốn

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

Phiên bản cú pháp ngắn gọn hơn của câu trả lời Swift 2 của Daniel Krom , sử dụng tên đóng cửa và tên đối số tốc ký, dường như được dựa trên câu trả lời ban đầu của 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 }
}

Ví dụ về việc triển khai một loại tùy chỉnh có thể được sử dụng với uniq(_:)(phải phù hợp với Hashable, và do đó Equatable, vì Hashablemở rộng 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
  }

}

Trong đoạn mã trên ...

id, như được sử dụng trong quá tải ==, có thể là bất kỳ Equatableloại (hoặc phương thức nào trả về một Equatableloại, ví dụ someMethodThatReturnsAnEquatableType():). Mã nhận xét thể hiện việc mở rộng kiểm tra tính bằng, trong đó someOtherEquatablePropertymột thuộc tính khác của một Equatableloại (nhưng cũng có thể là một phương thức trả về một Equatableloại).

id, như được sử dụng trong thuộc hashValuetính được tính toán (bắt buộc phải tuân theo Hashable), có thể là bất kỳ thuộc tính Hashable(và do đó Equatable) (hoặc phương thức trả về mộtHashable loại).

Ví dụ về việc sử dụng 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

Trong trường hợp bạn cần các giá trị được sắp xếp, điều này hoạt động (Swift 4)

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

Đây là một giải pháp mà

• Sử dụng không có NSloại di sản
• Là hợp lý nhanh chóng với O(n)
• Là súc tích
• Giữ nguyên thứ tự

extension Array where Element: Hashable {

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

Ở đây tôi đã thực hiện một số giải pháp O (n) cho các đối tượng. Không phải giải pháp vài dòng, nhưng ...

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

Tôi đã sử dụng câu trả lời của @ Jean-Philippe Pellet và thực hiện một phần mở rộng Array thực hiện các thao tác giống như thiết lập trên các mảng, trong khi vẫn duy trì thứ tự các phần tử.

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

Đây chỉ là một thực hiện rất đơn giản và thuận tiện. Một thuộc tính được tính toán trong phần mở rộng của Mảng có các phần tử tương đương.

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
}

Sử dụng:

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

1. Đầu tiên, thêm tất cả các phần tử của một mảng vào NSOrderedset.
2. Điều này sẽ loại bỏ tất cả các bản sao trong mảng của bạn.
3. Một lần nữa chuyển đổi tập lệnh này thành một mảng.

Làm xong....

Thí dụ

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

đầu ra của mảngWithoutD repeatates - [1,2,4,6,8]

Một phiên bản rút gọn hoàn toàn dựa trên câu trả lời mở rộng mảng của @ 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)
        }
    }
}

Bạn luôn có thể sử dụng Từ điển, vì Từ điển chỉ có thể chứa các giá trị duy nhất. Ví dụ:

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

Như bạn có thể thấy, mảng kết quả sẽ không phải luôn luôn theo thứ tự '. Nếu bạn muốn sắp xếp / đặt hàng Array, hãy thêm cái này:

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

.

Cách dễ nhất là sử dụng NSOrderedset, lưu trữ các phần tử duy nhất và giữ nguyên thứ tự các phần tử. Giống:

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)