ObjectIdentifier() ve '===' Kullanıcısı Operatör

Question

Arasındaki Fark, Swift'de bir kök sınıf uygulayayım diyelim ki, Equatable protokolünü kabul ettiğimi bildiriyorum (türümün bir dizisinin içerip içermediğini anlamak istiyorum) belirli bir örnek veya değil). olarak protokolün gerektirdiği == operatörü uygulanması arasındaki bu özel vakadan- içinde, herhangi -eğer farkı nedir

:

public static func ==(lhs: MyClass, rhs: MyClass) -> Bool { 

    return ObjectIdentifier(lhs) == ObjectIdentifier(rhs) 
} 

... aksine sadece bunu yapmaya:

public static func ==(lhs: MyClass, rhs: MyClass) -> Bool { 

    return (lhs === rhs) 
} 

Bir başvuru olarak, belgenin ObjectIdentifier()::

sınıf örneği veya metatype için benzersiz bir tanımlayıcı. Swift'de yalnızca sınıf örnekleri ve metatiplerin benzersiz kimlikleri vardır. Yapılar, sayılar, işlevler veya kopyalar için kimlik kavramı yoktur.

... ve bu The Swift Programming Language (Swift 3) "Temel Operatörleri" bölümü === operatör için söyledikleridir:

Swift ayrıca iki kimlik operatörleri (=== ve !==) içerir

NOT, iki nesne başvurusunun her ikisinin de aynı nesne örneğine başvurup başvurmadığını test etmek için kullandığınız. Daha fazla bilgi için bkz. Sınıflar ve Yapılar. sınıf örneği bir fark yoktur

Answer 1

, bakınız, aşağıdaki comments in ObjectIdentifier.swift:

/// Creates an instance that uniquely identifies the given class instance. 
    /// 
    /// The following example creates an example class `A` and compares instances 
    /// of the class using their object identifiers and the identical-to 
    /// operator (`===`): 
    /// 
    ///  class IntegerRef { 
    ///   let value: Int 
    ///   init(_ value: Int) { 
    ///    self.value = value 
    ///   } 
    ///  } 
    /// 
    ///  let x = IntegerRef(10) 
    ///  let y = x 
    /// 
    ///  print(ObjectIdentifier(x) == ObjectIdentifier(y)) 
    ///  // Prints "true" 
    ///  print(x === y) 
    ///  // Prints "true" 
    /// 
    ///  let z = IntegerRef(10) 
    ///  print(ObjectIdentifier(x) == ObjectIdentifier(z)) 
    ///  // Prints "false" 
    ///  print(x === z) 
    ///  // Prints "false" 
    /// 

Aynı zamanda sadece amacı ise, saklama için işaretçiler karşılaştırır implementation of == for ObjectIdentifier, aşikar hale:

public static func == (x: ObjectIdentifier, y: ObjectIdentifier) -> Bool { 
    return Bool(Builtin.cmp_eq_RawPointer(x._value, y._value)) 
    } 

the === operator ne

olduğu hangi yanı es:

public func === (lhs: AnyObject?, rhs: AnyObject?) -> Bool { 
    switch (lhs, rhs) { 
    case let (l?, r?): 
    return Bool(Builtin.cmp_eq_RawPointer(
     Builtin.bridgeToRawPointer(Builtin.castToUnknownObject(l)), 
     Builtin.bridgeToRawPointer(Builtin.castToUnknownObject(r)) 
    )) 
    case (nil, nil): 
    return true 
    default: 
    return false 
    } 
} 

ObjectIdentifierHashable uygundur, böylece sınıf için o protokolünü uygulamak istiyorsanız bu yararlıdır:

extension MyClass: Hashable { 
    var hashValue: Int { 
     return ObjectIdentifier(self).hashValue 
    } 
} 

bir nesne tanımlayıcısı da meta türleri için oluşturulabilir (Örneğin) === için tanımlanmamıştır.