HL666's questions

我正在思考这个问题的答案：如何测试泛型变量是否属于 AnyObject 类型

该解决方案似乎不再起作用。我有以下代码：

public struct ObjectHashable<T>: Hashable {
  
  public let object: T
  
  public init(object: T) {
    
    let t1 = type(of: object)
    let b1 = t1 is AnyClass
    print(t1) // Plugin
    print(b1) // false
    
    let t2 = T.self
    let b2 = t2 is AnyClass
    print(t2) // Plugin 
    print(b2) // false
    
    let t3 = Mirror(reflecting: object).subjectType 
    let b3 = t3 is AnyClass 
    print(t3) // P
    print(b3) // true 

    self.object = object
    
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return true
  }
  
  public func hash(into hasher: inout Hasher) {
  }
}

protocol Plugin: AnyObject {}
class P: Plugin {}

typealias PluginHashable = ObjectHashable<Plugin>

PluginHashable(object: P())

这是一个令人惊讶的行为。

1.

let t1 = type(of: object)

type(of:)应该返回动态类型，即P，而不是Plugin。但我打印出了“插件”。

2.

let b1 = t1 is AnyClass

因为 t1 是引用类型，所以它不应该是真的吗？（基于此处的答案：如何测试泛型变量是否属于 AnyObject 类型）

3.

let t2 = T.self

打印出来Plugin，这是有道理的，因为我输入Plugin了<>

4.

let b2 = t2 is AnyClass

这是错误的，但我认为出于同样的原因，它应该是正确的

5.

    let t3 = Mirror(reflecting: object).subjectType // P

打印出来P，这是有道理的

6.

    let b3 = t3 is AnyClass // true

确实如此，这很有道理。但为什么它与其他两种情况不同呢？

我有这个 Swift 结构：

struct Foo {
  let i: Int
}
let f1 = Foo(i: 1)
let f2 = Foo(i: 2)

然后在 LLDB 中，我将它们转换为__SwiftValue并打印出来：

p (f1 as AnyObject)

(__SwiftValue) 0x00000001676332d0 {
  baseNSObject@0 = {
    isa = __SwiftValue
  }
}

p (f2 as AnyObject)


(__SwiftValue) 0x0000000167633300 {
  baseNSObject@0 = {
    isa = __SwiftValue
  }
}

正如您所看到的，这两个地址是不同的，这是有道理的，因为它们无论如何都是位于不同内存位置的不同数据。

但是，如果我取ObjectIdentifier，它们就相等：

p ObjectIdentifier(f1 as AnyObject)
(ObjectIdentifier) ObjectIdentifier(0x00000001676332d0) {
  _value = 0x00000001676332d0
}

p ObjectIdentifier(f2 as AnyObject)

(ObjectIdentifier) ObjectIdentifier(0x00000001676332d0) {
  _value = 0x00000001676332d0
}

这种奇怪的行为基本上是说“相等的 ObjectIdentifier”并不意味着“相等的地址”（===）：

p (f1 as AnyObject === f2 as AnyObject)
(Bool)  (_value = 0)

p (ObjectIdentifier(f1 as AnyObject) == ObjectIdentifier(f2 as AnyObject))
(Bool)  (_value = 1)

为什么会这样？我的理解是__SwiftValue是 的子类NSObject，所以它们应该有不同的ObjectIdentifiers 。这很奇怪。

更新：

我在 LLDB 之外添加了示例代码：

      let f1 = Foo(i: 1)
      let f2 = Foo(i: 2)
      
      let b1 = (f1 as AnyObject) === (f2 as AnyObject)
      let b2 = ObjectIdentifier(f1 as AnyObject) == ObjectIdentifier(f2 as AnyObject)
      

并在调试器中得到 b1 = false 和 b2 = true：

我有一个仅限于类类型的协议：

protocol Plugin: AnyObject {}

现在我想使用插件作为哈希表的键。我不想让Plugin协议继承自Hashable，因为这样我就得any Plugin在所有地方都写一遍（因为它会从其父协议继承“自身要求”）。

为了解决这个问题，我想创建一个通用包装器。我不想使用AnyHashable，因为我希望在出现错误时使用更严格的类型。

public struct ObjectHashable<T: AnyObject>: Hashable {
  
  public let object: T
  
  public init(object: T) {
    self.object = object
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return ObjectIdentifier(lhs.object) == ObjectIdentifier(rhs.object)
  }
  
  public func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(object))
  }
}

现在我想做类似的事情

typealias PluginHashable = ObjectHashable<Plugin>

然而，这给了我错误：

要求指定为“T”：“AnyObject”[其中T = 任何插件]

所以我把它改成了

typealias PluginHashable = ObjectHashable<any Plugin>

我遇到了同样的错误：

要求指定为“T”：“AnyObject”[其中T = 任何插件]

我的理解是，虽然Plugin协议被限制为类类型，但any Plugin事实并非如此。但是，我不知道下一步该怎么做。

更新：

如果我不使用通用的 for ObjectHashable，它就会起作用：

public struct PluginHashable: Hashable {
  
  public let plugin: Plugin
  
  public init(plugin: Plugin) {
    self.plugin = plugin
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return ObjectIdentifier(lhs.plugin) == ObjectIdentifier(rhs.plugin)
  }
  
  public func hash(into hasher: inout Hasher) {
    hasher.combine(ObjectIdentifier(plugin))
  }
}

但是，这个解决方案仅适用于Plugin协议，因此并不理想。我更希望有一个适用于所有类似情况的解决方案。