Comment comparer deux tableau d'objets?

J'ai une classe A:

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

Deux tableaux de l'Une des instances:

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

Je ne sais pas qui est le meilleur moyen de vérifier:
array1==array2 if a1.identifier == a5.identifier, a2.identifier == a6.identifier, a3.identifier==a7.identifier, a4.identifier==a8.identifier en Swift.

Merci de m'aider...

matrice1 et matrice2 sera toujours de la même taille? afficher la matrice de comptage faut vérifier aussi? ou chèque doit être sur les propriétés de chaque élément dans les tableaux?
désolé, leurs résultats sont aléatoires
donc, si ils ont des densités différentes, ils devraient être classés comme inégales, droit?
Que considérez-vous de l'égalité? Si elles ont la même longueur? Si ils ont les mêmes éléments? Faire les éléments ont tous à être le même indice?
ya... je l'ai eu, mais comment parler d'un autre cas @-@

OriginalL'auteur Quang Hà | 2016-08-26

20

Vous pouvez essayer comme ceci:
```
let result = zip(array1, array2).enumerate().filter() {
    $1.0 == $1.1
}.map{$0.0}
```
wow. Je suis devenu un fan de la vôtre.
Tripathi, chers Rahul Tripathi pouvez-vous nous expliquer votre code. C'est intéressant, mais je ne peux pas compris.C'est mon code de laisser tableau1: [Int] = [1, 2, 3, 4] laissez tableau2: [Int] = [5, 6, 7, 8] laissez résultat = zip(matrice1, matrice2).énumérés().filtre() { $1.0 == $1.1 }.map{$0.0} print(suite)
Cas si cela fonctionne, il ressemble à un copier coller du code à partir de quelque part, sans aucune explication du code!.@Rahul Tripathi

OriginalL'auteur Rahul Tripathi

Assumer vos données comme ça:

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

C'est la méthode pour comparer deux tableaux de gens avec l'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
}

Il n'y a pas de raison d'utiliser .enumerate() pour obtenir le comte de la correspondance des éléments, mais ensuite, le filtre ressemble { $0.0.id == $0.1.id }

OriginalL'auteur t4nhpt

Nous avons d'abord étendre Equatable de classe, d'avoir un SEC code, que si les 2 tableaux sont toujours de la même taille, ou si au moins la première est <= que la deuxième, vous pouvez aller avec cette solution.

Faire attention à ce que vous travaillez avec des options, vous pouvez avoir à déballer avant.

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

Comment comparer deux tableau d'objets?

OriginalL'auteur Miotz

essayer ce code, laissez-moi savoir si cela fonctionne

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

ensuite, vous pouvez exécuter une case comme ci-dessous

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)

avertissement: la fonction toDictionary a été pris forme ici

OriginalL'auteur ddb

Swift 4

La méthode suivante, il est beaucoup plus facile.

Méthode 1 - À L'Aide De Equatable Protocole

Etape 1 - créer votre classe 'A' equatable comme suit

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

Etape 2 - Trier vos tableaux dans l'ordre croissant ou décroissant

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

Etape 3 - Utilisation == ou elementsEqual comparaison

let isEqual = lhsArray == rhsArray

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

Méthode 2 (Sans Equatable Protocole)

Étape 1 - trie un Tableau tel que décrit dans Method1, étape 2

Étape 2 - Utilisation elementsEqual

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

Lire plus sur Tableau de Comparaison ici

OriginalL'auteur Anand

J'ai trouvé cette solution très facile à 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)

OriginalL'auteur Jeremy Andrews

Vous devez vous connecter pour publier un commentaire.