Как сравнить два массива объектов?

Ответ 1

Вы можете попробовать вот так:

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

Ответ 2

Предположим, что ваши данные:

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
}

Ответ 3

Swift 4

Следующий метод делает это намного проще.

Метод 1 - Использование Equatable Protocol

Шаг 1 - Сделайте ваш класс "А" уравновешенным следующим образом

extension A: Equatable {
    static func ==(lhs: A, rhs: A) -> Bool {
        // Using "identifier" property for comparison
        return lhs.identifier == rhs.identifier
    }
}

Step2 - сортируйте массивы в порядке возрастания или убывания

let lhsArray = array1.sorted(by: { $0.identifier < $1.identifier })
let rhsArray = array2.sorted(by: { $0.identifier < $1.identifier })

Шаг 3 - используйте == или elementsEqual Сравнение

let isEqual = lhsArray == rhsArray

ИЛИ

let isEqual = lhsArray.elementsEqual(rhsArray, by: { $0 == $1} )

Метод 2 (без равноправного протокола)

Шаг 1 - Сортировка массива, как описано в методе 1, шаг 2

Шаг 2 - Используйте elementsEqual

lhsArray.elementsEqual(rhsArray, by: { $0.identifier == $1.identifier })

Подробнее о сравнении массивов читайте здесь

Ответ 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
    }
}

Ответ 5

попробуйте этот код, дайте мне знать, если он работает

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

Ответ 6

Я нашел это действительно простое решение на https://www.hackingwithswift.com/example-code/language/how-to-find-the-difference-between-two-arrays

extension Array where Element: Hashable {
func difference(from other: [Element]) -> [Element] {
    let thisSet = Set(self)
    let otherSet = Set(other)
    return Array(thisSet.symmetricDifference(otherSet))
 }
}

let names1 = ["a1", "A4", "a3", "a4"]//["John", "Paul", "Ringo"]
let names2 = ["a1", "a5", "a4","a1.1"]//["Ringo", "George"]
let difference = names1.difference(from: names2)