Swift : égalité de référence et égalité de valeur pour les classes

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.