요즘 Swift에서는 간단히 입력 Set( yourArray )하여 배열을 고유하게 만듭니다. (또는 필요한 경우 주문 세트.)

그 전에는 어떻게 되었습니까?

다음과 같은 배열이있을 수 있습니다.

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

또는 실제로 같은 유형의 데이터 부분 시퀀스. 내가하고 싶은 것은 각각의 동일한 요소 중 하나만 있는지 확인하는 것입니다. 예를 들어 위의 배열은 다음과 같습니다.

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

2, 6 및 15의 복제본이 제거되어 동일한 각 요소 중 하나만 있음을 확인했습니다. Swift가이를 쉽게 수행 할 수있는 방법을 제공합니까, 아니면 직접해야합니까?

예를 들어 다음과 같이 직접 롤백 할 수 있습니다 ( Swift 1.2에서 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]

스위프트 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
}

그리고 다음의 확장으로 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
    }
}

집합으로 변환하고 다시 배열로 쉽게 다시 변환 할 수 있습니다.

let unique = Array(Set(originals))

어레이의 원래 순서를 유지한다고 보장 할 수는 없습니다.

여기에 많은 답변이 있지만 Swift 2 이상에 적합한이 간단한 확장을 놓쳤습니다.

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

매우 간단합니다. 다음과 같이 호출 할 수 있습니다.

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

속성을 기반으로 필터링

속성을 기준으로 배열을 필터링하려면이 방법을 사용할 수 있습니다.

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

다음과 같이 전화를 걸 수 있습니다.

let filteredElements = myElements.filterDuplicates { $0.PropertyOne == $1.PropertyOne && $0.PropertyTwo == $1.PropertyTwo }

스위프트 3.0

let uniqueUnordered = Array(Set(array))
let uniqueOrdered = Array(NSOrderedSet(array: array))

코드에 두 확장을 모두 넣으면 Hashable가능 하면 더 빠른 버전이 Equatable사용되며 대체 버전으로 사용됩니다.

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

순서가 중요하지 않은 경우 항상 이 Set initializer 만 사용할 수 있습니다 .

Swift 4 이상 편집 / 업데이트

또한 RangeReplaceableCollection프로토콜을 확장 하여 StringProtocol유형 에도 사용할 수 있습니다.

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"

돌연변이 방법 :

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

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

들어 스위프트 3 클릭 여기

스위프트 4

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

모든 시도 insert는 또한 튜플을 반환합니다 : (inserted: Bool, memberAfterInsert: Set.Element). 설명서를 참조하십시오 .

반환 된 값을 사용하면 루핑이나 다른 작업을 피할 수 있습니다.

스위프트 4

주문을 계속 보장합니다.

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

다음 SequenceType은 배열의 원래 순서를 유지하지만 a 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
    }
}

당신이 해쉬을 가지고 있지만하지 않는 경우 이제 있습니다 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: ==)
    }
}

마지막으로 다음과 같이 고유 한 키 경로 버전을 추가 할 수 있습니다.

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유형 에 따라 올바른 것을 선택합니다 .

https://www.swiftbysundell.com/posts/the-power-of-key-paths-in-swift에서 영감을 받음 에서 모든 keyPath에서 단일성을 필터링 할 수있는보다 강력한 도구를 선언 할 수 있습니다. 복잡성에 대한 다양한 답변에 대한 Alexander의 의견 덕분에 아래 솔루션은 거의 최적이어야합니다.

비 돌연변이 솔루션

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

대체 (최적이 아닌 경우)에서 용액 여기서 변수보다는 불변 유형을 사용 :

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
}

Jean-Pillippe의 명령 방식과 기능적 접근법을 대조하기 위해 포함되었습니다.

보너스 로이 기능은 문자열뿐만 아니라 배열에서도 작동합니다!

편집 : 이 답변은 2014 년 Swift 1.0 용으로 작성되었습니다 (Swift Set에서 사용 가능). Hashable 준수가 필요하지 않으며 2 차 시간에 실행됩니다.

스위프트 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

스위프트 5에서

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

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

출력은

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

어레이에서 중복을 제거하는 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]

이 코드는 inserton 에 대한 오퍼레이션에 의해 리턴 된 결과를 이용합니다 Set.O(1) 항목이 삽입되었는지 또는 세트에 이미 존재하는지 여부를 나타내는 튜플을 리턴합니다.

항목이 세트에 있으면 filter최종 결과에서 제외됩니다.

스위프트 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()

또는

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

스위프트 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의 방법은 순서를 유지하며 훨씬 빠릅니다. 따라서 요소 유형을 해시 할 수 없거나 빠른 라이너가 필요하지 않은 경우 해당 솔루션을 사용하는 것이 좋습니다.

릴리스 모드의 Xcode 11.3.1 (Swift 5.1)에서 MacBook Pro (2014)에 대한 몇 가지 테스트가 있습니다.

프로파일 러 기능과 비교할 두 가지 방법 :

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

요소가 해시 가능하거나 비교 가능하지 않은 배열 (예 : 복잡한 객체, 사전 또는 구조체)의 경우이 확장은 중복을 제거하는 일반적인 방법을 제공합니다.

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

값을 해시 가능하게 만들 필요가 없으며 고유성을 위해 서로 다른 필드 조합을 사용할 수 있습니다.

참고 :보다 강력한 접근 방법은 아래 설명에서 Coeur가 제안한 솔루션을 참조하십시오.

stackoverflow.com/a/55684308/1033581

[편집] 스위프트 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]

Airspeed Velocity의 원래 답변을 기반으로 표시되는 후행 폐쇄 및 속기 인수 이름을 사용하여 Daniel Krom의 Swift 2 answer의 간결한 구문 버전이 약간 간결 해졌습니다 .

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

정렬 된 값이 필요한 경우 작동합니다 (Swift 4)

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

해결책은 다음과 같습니다.

• 레거시 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")

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

이것은 매우 간단하고 편리한 구현입니다. 동일한 요소가있는 Array 확장에서 계산 된 속성입니다.

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)

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]

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

사전은 고유 한 값만 보유 할 수 있으므로 항상 사전을 사용할 수 있습니다. 예를 들면 다음과 같습니다.

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

.

가장 쉬운 방법은 고유 한 요소를 저장하고 요소 순서를 유지하는 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)