如何比较两个对象数组？

Question

我有一个A级：

一个实例

class A { 
    var identifier: String? 
    var quantity: Int = 0 
} 

两个数组：

var array1: [A] = [a1, a2, a3, a4] 
var array2: [A] = [a5, a6, a7, a8] 

我不知道这是检查的最佳方式： array1==array2 if a1.identifier == a5.identifier, a2.identifier == a6.identifier, a3.identifier==a7.identifier, a4.identifier==a8.identifier斯威夫特。

请帮我...

Answer 1

假设你的数据那样：

struct Person 
    { 
     let name: String 
     let id: Int 
    } 

    var people1 = [ 
     Person(name: "Quang Hà", id: 42), 
     Person(name: "Lý Hải", id: 23), 
     Person(name: "Maria", id: 99) 
    ] 

    var people2 = [ 
     Person(name: "Maria yyy", id: 99), 
     Person(name: "Billy", id: 42), 
     Person(name: "David", id: 23) 
    ] 

这是人的两个数组比较ID的方法：

func areArrayPeopleEqual(people1:[Person], people2: [Person]) -> Bool { 
    var array1 = people1 
    var array2 = people2 

    // Don't equal size => false 
    if array1.count != array2.count { 
     return false 
    } 

    // sort two arrays 
    array1.sortInPlace() { $0.id > $1.id } 
    array2.sortInPlace() {$0.id > $1.id } 

    // get count of the matched items 
    let result = zip(array1, array2).enumerate().filter() { 
     $1.0.id == $1.1.id 
     }.count 

    if result == array1.count { 
     return true 
    } 

    return false 
} 

Answer 2

你可以尝试这样的：

let result = zip(array1, array2).enumerate().filter() { 
    $1.0 == $1.1 
}.map{$0.0} 

Answer 3

试试这个代码，让我知道，如果它

func toDictionary<E, K, V>(
    array:  [E], 
    transformer: (element: E) -> (key: K, value: V)?) 
    -> Dictionary<K, V> 
{ 
    return array.reduce([:]) { 
     (var dict, e) in 
     if let (key, value) = transformer(element: e) 
     { 
      dict[key] = value 
     } 
     return dict 
    } 
} 

则可以执行检查像下面一样

let areEqual = array1.count == array2.count; 
if areEqual { 
    let dict1 = toDictionary(array1) { ($0.identifier, $0.quantity) } 
    let dict2 = toDictionary(array2) { ($0.identifier, $0.quantity) } 
    areEqual = NSDictionary(dictionary: dict1).isEqualToDictionary(dict2) 
} 
print(areEqual) 

声明：功能toDictionary已经采取了形式here

Answer 4

首先我们延伸Equatable类，具有DRY代码，比如果2个阵列具有相同的尺寸的始终，或者如果至少第一个是< =比第二个你可以用这个解决方案。

请注意，您正在使用可选项，您可能必须先拆开它们。

class A { 
    var identifier: String? 
    var quantity: Int = 0 

    init(identifier: String, quantity: Int) { 
     self.identifier = identifier 
     self.quantity = quantity 
    } 
} 

let a1: A = A(identifier: "1", quantity: 1) 
let a2: A = A(identifier: "2", quantity: 2) 
let a3: A = A(identifier: "3", quantity: 3) 
let a4: A = A(identifier: "4", quantity: 4) 

let a5: A = A(identifier: "1", quantity: 1) 
let a6: A = A(identifier: "2", quantity: 2) 
let a7: A = A(identifier: "3", quantity: 3) 
let a8: A = A(identifier: "4", quantity: 4) 

var array1: [A] = [a1, a2, a3, a4] 
var array2: [A] = [a5, a6, a7, a8] 

func areEquals(array1: [A], array2: [A]) -> Bool { 
    if array1.count < array2.count { 
     return false 
    } 
    for i in 0...array2.count - 1 { 
     if array1[i] != array2[i] { 
      return false 
     } 
    } 
    return true 
} 


extension A: Equatable { 
    static func ==(lhs: A, rhs: A) -> Bool { 
     //you can choose how and when they should be equals 
     return lhs.identifier == rhs.identifier 
    } 
}