Comparer les tableaux dans swift

== dans Swift est le même que equals() de Java, il compare les valeurs.

=== dans Swift est le même que == de Java, il compare les références.

Dans Swift, vous pouvez comparer les valeurs de contenu de tableau aussi facilement que ceci:

["1", "2"] == ["1", "2"]

, Mais cela ne fonctionnera pas si vous voulez comparer les références:

var myArray1 = [NSString(string: "1")]
var myArray2 = [NSString(string: "1")]

myArray1[0] === myArray2[0] // false
myArray1[0] == myArray2[0] // true

, Donc les réponses:

1. je pense que la performance est optimale pour faire de la valeur (pas de référence) comparaisons
2. Oui, si vous voulez comparer les valeurs
3. Swift les tableaux sont de type valeur et non de type référence. De sorte que la mémoire l'emplacement est le même que si vous le comparer à lui-même (ou insalubres les pointeurs)

Cela dépend de la façon dont vous voulez comparer. Exemple: ["1", "2"] == ["1", "2"] // true mais ["1", "2"] == ["2", "1"] // false

Si vous avez besoin que ce deuxième cas soit également vrai et que vous ignorez les valeurs répétitives, vous pouvez faire: Set(["1", "2"]) == Set(["2", "1"]) // true (utiliser NSSet pour Swift 2)

Les tableaux sont conformes à Equatable dans Swift 4.1, annulant les mises en garde mentionnées dans les réponses précédentes. Ceci est disponible dans Xcode 9.3.

Https://swift.org/blog/conditional-conformance/

Mais juste parce qu'ils ont implémenté == ne signifiait pas Array ou Optional conforme à Equatable. Étant donné que ces types peuvent stocker des types Non équatables, nous devions être en mesure d'exprimer qu'ils ne sont équatables que lors du stockage d'un type équatable.

Cela signifiait ces opérateurs == avait une grande limitation: ils ne pouvaient pas être utilisés à deux niveaux de profondeur.

Avec la conformité conditionnelle, nous pouvons maintenant résoudre ce problème. Cela nous permet d'écrire que ces types sont conformes à Equatable-en utilisant l'opérateur == déjà défini-si les types sur lesquels ils sont basés sont équivalents.

Pour comparer des tableaux d'objets personnalisés, nous pouvons utiliser elementsEqual.

class Person {

    let ID: Int!
    let name: String!

    init(ID: Int, name: String) {

        self.ID = ID
        self.name = name
    }
}

let oldFolks = [Person(ID: 1, name: "Ann"), Person(ID: 2, name: "Tony")]
let newFolks = [Person(ID: 2, name: "Tony"), Person(ID: 4, name: "Alice")]

if oldFolks.elementsEqual(newFolks, by: { $0.ID == $1.ID }) {

    print("Same people in same order")

} else {

    print("Nope")
}

Si vous avez un matrice de objets personnalisés, on doit être prudent avec le test d'égalité, au moins avec Swift 4.1:
Si l'objet personnalisé est pas une sous-classe de NSObject, la comparaison utilise le static func == (lhs: Nsobject, rhs: Nsobject) -> Bool, ce qui doit être définie.
Si il est une sous-classe de NSObject, il utilise le func isEqual(_ object: Any?) -> Bool, qui doit être remplacée.

Veuillez vérifier le code suivant et définir des points d'arrêt à toutes les instructions de retour.

class Object: Equatable {

    static func == (lhs: Object, rhs: Object) -> Bool {
        return true
    }
}

La classe suivante hérite Equatable de NSObject

class Nsobject: NSObject {

    static func == (lhs: Nsobject, rhs: Nsobject) -> Bool {
        return true
    }


    override func isEqual(_ object: Any?) -> Bool {
        return true
    }

}  

Ils peuvent être comparés avec:

let nsObject1 = Nsobject()
let nsObject2 = Nsobject()
let nsObjectArray1 = [nsObject1]
let nsObjectArray2 = [nsObject2]
let _ = nsObjectArray1 == nsObjectArray2

let object1 = Object()
let object2 = Object()
let objectArray1 = [object1]
let objectArray2 = [object2]
let _ = objectArray1 == objectArray2