Il existe deux manières de tester l’égalité des instances de classe : l’égalité de référence et l’égalité de valeur. Dans cet article, nous discuterons des deux.
Indice : Ce message utilise Swift 4
L’opérateur d’identité ===
En utilisant l’opérateur d’identité === vous pouvez comparer les références pointant vers les instances d’une classe. Si ces références pointent vers la même instance, l’opérateur renvoie true. Jetez un œil à l’exemple suivant :
Class TestClassA { } let test1 = TestClassA() let test2 = TestClassA() let test3 = test1 print("test1 and test2 pointing to the same instance: \(test1===test2)") //false print("test1 and test3 pointing to the same instance: \(test1===test3)") //true
Comme vous pouvez le voir, test1 et test3 pointent vers la même instance, alors que test1 et test2 ne pointent pas vers la même instance.
Vous pouvez également vérifier l’inégalité en utilisant le !== opérateur:
print("test1 and test3 are not pointing to the same instances: \(test1!==test3)" //true
Notez que l’opérateur d’identité n’est pas disponible pour les énumérations, les structures et les types de données primitifs. Cela a du sens car dans ces cas, il n’est pas possible que deux valeurs pointent vers la même instance.
L’opérateur d’égalité ==
L’opérateur d’égalité, en revanche, fonctionne différemment. Il compare si deux instances sont égales. Cela ne semble pas très concret et en fait, ce que cela signifie n’est pas défini. Au lieu de cela, chaque classe doit définir ce que l’égalité signifie pour elle. Si la classe ne le fait pas, il n’est pas possible d’utiliser l’opérateur d’égalité :
Class TestClassA { } let test1 = TestClassA() let test2 = TestClassA() print("test1 is equal to test2 \(test1==test2)") //Compiler error
La dernière ligne produit une erreur de compilation. Au lieu de cela, vous devez implémenter le protocole Equatable :
class TestClassA: Equatable { let a: Int init(a:Int) { self.a = a } public static func == (lhs: TestClassA, rhs: TestClassA) -> Bool { return lhs.a == rhs.a } } let test1 = TestClassA(a:5) let test2 = TestClassA(a:6) let test3 = TestClassA(a:5) print("test1 is equal to test2 \(test1==test2)") //false print("test1 is equal to test3 \(test1==test3)") //true
Comme vous pouvez le voir, dans cet exemple, deux instances de TestClass sont égaux si les propriétés une sont égaux.
Le protocole comparable
Il n’est pas seulement possible de définir l’égalité de valeur pour deux instances d’une classe, mais également pour un ordre. Pour cela, vous devez implémenter le protocole Comparable. Il étend le protocole Equatable, de sorte que le == La fonction doit être implémentée comme expliqué dans la dernière section. De plus, le < fonction doit également être implémentée:
class TestClassA: Equatable, Comparable { let a: Int init(a:Int) { self.a = a } public static func < (lhs: TestClassA, rhs: TestClassA) -> Bool { return lhs.a < rhs.a } public static func == (lhs: TestClassA, rhs: TestClassA) -> Bool { return lhs.a == rhs.a } } let test1 = TestClassA(a:5) let test2 = TestClassA(a:6) let test3 = TestClassA(a:5) print("test1 < test2 \(test1<test2)") //true print("test1 < test3 \(test1<test3)") //false print("test1 <= test3 \(test1<=test3)") //true print("test1 > test3 \(test1>test2)") //false
Comme vous pouvez le voir, c’est très simple.