如何在Swift中检查类型是否为Optional？

Question

如何在Swift中检查类型是否为Optional？

假设我有一个PartialKeyPath类型的变量，其中：

struct Foo {
    let bar: String
    let baz: String?
}

typealias Property<Root> = (key: PartialKeyPath<Root>, value: Any?)
typealias Properties<Root> = [Property<Root>]

现在说我通过一个Properties实例迭代：

properties.forEach { prop in
    let valueType1 = type(of: prop.key).valueType
    let valueType2 = type(of: value)

    ...

我如何在这里检查valueType1是否为Optional<valueType2>，或者它是否可选为其他任何风味？

到目前为止，我找到的唯一方法真的很难看......

Answer 1

这是一个hacky但工作的解决方案：

func isOptional(_ type: Any.Type) -> Bool {
    let typeName = String(describing: type)
    return typeName.hasPrefix("Optional<")
}

测试：

let t1 = Int?.self
let t2 = Bool.self

print(isOptional(t1))
// true

print(isOptional(t2))
// false

Answer 2

使用与Optional field type doesn't conform protocol in Swift 3类似的方法，您可以为Optional定义一个“伪协议”，并使用它来获取包装的元类型：

protocol OptionalProtocol {
  // the metatype value for the wrapped type.
  static var wrappedType: Any.Type { get }
}

extension Optional : OptionalProtocol {
  static var wrappedType: Any.Type { return Wrapped.self }
}

如果您只是想知道类型是可选的：

func isOptionalType(_ type: Any.Type) -> Bool {
  return type is OptionalProtocol.Type
}

print(isOptionalType(String.self)) // false
print(isOptionalType(String?.self)) // true

如果要检查一个元类型是否是另一个元类型的“可选版本”：

struct Foo {
  let bar: String
  let baz: String?
}

struct Property<Root> {
  var key: PartialKeyPath<Root>
  var value: Any
}

let properties = [Property(key: \Foo.baz, value: "hello")]

/// Attempt to get the `Wrapped` metatype from a metatype of an
/// `Optional<Wrapped>`. If not an `Optional`, will return `nil`.
func wrappedTypeFromOptionalType(_ type: Any.Type) -> Any.Type? {
  return (type as? OptionalProtocol.Type)?.wrappedType
}

for property in properties {
  let valueType1 = type(of: property.key).valueType
  let valueType2 = type(of: property.value)

  if wrappedTypeFromOptionalType(valueType1) == valueType2 {
    print("\(valueType1) == Optional<\(valueType2)>")
  }
}

// Optional<String> == Optional<String>

然而，几乎可以肯定有一种更好的方法来做你在这里尝试用关键路径做的任何事情。

Answer 3

你可以使用镜像反射任何和检查displayStyle是可选的吗？

func isOptional(any:Any) -> Bool {

  let mirror = Mirror(reflecting: any)
  if mirror.displayStyle == .Optional {
      return true
  } else {
      return false
  }

}

更多关于镜面显示风格：https://developer.apple.com/documentation/swift/mirror.displaystyle

Answer 4

调整@kelin的回答：

postfix operator ...?!
postfix func ...?!<T>(_ instance: T) -> Bool {
    let subject = "\(Mirror(reflecting: instance).subjectType)"
    return !subject.hasPrefix("Optional") 
}

而@ Ercell0的答案就是这种优越的方法：

func isOptional<T>(_ instance: T) -> Bool {
    guard let displayStyle = Mirror(reflecting: instance).displayStyle 
        else { return false }
    return displayStyle == .optional
}