Swift 是否可以将任何类型强制转换为可选类型？

假设我有这样一段代码：

let x: Int? = 10  
let y: Any = x

extension Dictionary where Value == Any {
    func typedValue<T>(forKey key: Key) -> T? {
        if let anyValue: Any = self[key] {
            return (anyValue as! T)
        }
        return nil
    }

    func optionalTypedValue<T>(forKey key: Key) -> T?? {
        return self.typedValue(forKey: key)
    }
}

现在我想将y转换为Int？：

let z = y as Int? // Error: Cannot downcast from 'Any' to a more optional type 'Int?'

---

这是不可能的还是有别的办法

您可以这样做，在任何

func unwrap(any:Any) -> Any? {
    let mi:MirrorType = reflect(any)
    if mi.disposition != .Optional {
        return any
    }
    if mi.count == 0 { return nil } // Optional.None
    let (name,some) = mi[0]
    return some.value
}

所以在你的情况下

让z=展开（y）为？Int

---

参考资料：

对于Swift 2.0，您可以使用以下内容：

let x: Int? = 10
let y: Any = x
let z = Mirror(reflecting: y).descendant("Some") as? Int

或者作为一种功能：

func castToOptional<T>(x: Any) -> T? {
    return Mirror(reflecting: x).descendant("Some") as? T
}
let x: Int? = 10
let y: Any = x
let z: Int? = castToOptional(y)

func castToOptional（x:Any）->T？{
返回镜像（反射：x）。后代（“部分”）为？T
}
设x:Int？=10
设y:Any=x
让z:Int？=卡斯托选项（y）

如果您不喜欢反射，也可以这样做：

func castToOptional<T>(x: Any) -> T {
    return x as! T
}
let x: Int? = 10
let y: Any = x
let z: Int? = castToOptional(y)

func castToOptional（x:Any）->T{
返回x为！T
}
设x:Int？=10
设y:Any=x
让z:Int？=卡斯托选项（y）

func castasoptionant（值：Any）->Int？{
让镜像=镜像（反射：值）
如果mirror.subjectType==可选的.self{
让ret=镜像。儿童。第一个？.1
返回ret as？Int
}否则{
归零
}
}
设x:Int？=10
设y:Any=x
设z=castasoptionant（y）//10
让a:加倍10
让b:Any=a
设c=castasoptionant（b）//nil

这个解决方案怎么样，我对前面的答案做了一个通用版本

fileprivate func unwrap<T>(value: Any)
  -> (unwraped:T?, isOriginalType:Bool) {

  let mirror = Mirror(reflecting: value)
  let isOrgType = mirror.subjectType == Optional<T>.self
  if mirror.displayStyle != .optional {
    return (value as? T, isOrgType)
  }
  guard let firstChild = mirror.children.first else {
    return (nil, isOrgType)
  }
  return (firstChild.value as? T, isOrgType)
}

let value: [Int]? = [0]
let value2: [Int]? = nil

let anyValue: Any = value
let anyValue2: Any = value2

let unwrappedResult:([Int]?, Bool)
  = unwrap(value: anyValue)    // ({[0]}, .1 true)
let unwrappedResult2:([Int]?, Bool)
  = unwrap(value: anyValue2)  // (nil, .1 true)
let unwrappedResult3:([UInt]?, Bool)
  = unwrap(value: anyValue)  // (nil, .1 false)
let unwrappedResult4:([NSNumber]?, Bool)
  = unwrap(value: anyValue)  ({[0]}, .1 false)

fileprivate func展开（值：任意）
->（未包装：T？，等原始类型：Bool）{
让镜像=镜像（反射：值）
让isOrgType=mirror.subjectType==Optional.self
如果mirror.displayStyle！=可选{
返回值（值为？T，isOrgType）
}
guard let firstChild=mirror.children.first-else{
返回值（零，isOrgType）
}
返回值（firstChild.value为？T，isOrgType）
}
let值：[Int]？=[0]
let value2:[Int]？=无
让anyValue:Any=value
设anyValue2:Any=value2
让展开结果：（[Int]？，Bool）
=展开（值：anyValue）/（{[0]}，.1 true）
让展开结果2:（[Int]？，Bool）
=展开（值：anyValue2）/（零，.1真）
让展开结果3:（[UInt]？，Bool）
=展开（值：anyValue）/（nil，.1 false）
让展开结果4:（[NSNumber]？，Bool）
=展开（值：anyValue）（{[0]}，.1 false）

以下是操场上的代码

---

如果有人正在寻找即插即用词典解决方案，可以这样做：

let x: Int? = 10  
let y: Any = x

extension Dictionary where Value == Any {
    func typedValue<T>(forKey key: Key) -> T? {
        if let anyValue: Any = self[key] {
            return (anyValue as! T)
        }
        return nil
    }

    func optionalTypedValue<T>(forKey key: Key) -> T?? {
        return self.typedValue(forKey: key)
    }
}

扩展字典，其中Value==Any{
func类型值（forKey:key）->T{
如果让anyValue:Any=self[key]{
返回值（任意值为！T）
}
归零
}
func optionalTypedValue（分叉键：键）->T{
返回self.typedValue（forKey:key）
}
}

但是强制转换是不可能的..它返回nil我认为此方法无法将

任何

强制转换为Swift 3/xcode 8中键入的可选项。啊哈！

某些

中的小写“s”。阅读发行说明有时很有用！对于swift 3，使用

让z=Mirror（反射：y）。后代（“一些”）作为？Int

Mirror（reflecting:x）

substant（…）

方法在Swift 3中不起作用（

Mirror（reflecting:x）。children.count

为

0

），但

将x返回为！T

可以！出于某种奇怪的原因，尝试执行

（myAnyVar as！SCNRenderingAPI？

会给我一个编译时错误

错误：无法从“Any”向下转换为更可选的类型“SCNRenderingAPI？”

，但在函数内部执行相同的转换非常有效。干杯建议编辑：“如果您不喜欢反射，也可以这样做：”→ “或者您可以在Swift 3中执行此操作，或者如果您不喜欢反射：”