interface SomeInterface{}

和一个符合该接口的类

class SomeClass : NSObject,SomeInterface{}

现在,我创建一个SomeInterface对象数组

var myInterfaceObjects : SomeInterface[] = SomeInterface[]()

然后我想将此数组转换为SomeClass对象数组

var someClassObjects : SomeClass[] = myInterfaceObjects as SomeClass[] //CRASH!

我如何在没有崩溃的情况下垂头丧气？

Fatal error: can't reinterpretCast values of different sizes
(lldb) bt
* thread #1: tid = 0x935ef,0x001986b8 libswift_stdlib_core.dylib`Swift.reinterpretCast <A,B>(A) -> B + 220,queue = 'com.apple.main-thread',stop reason = EXC_BREAKPOINT (code=EXC_ARM_BREAKPOINT,subcode=0xe7ffdefe)
  * frame #0: 0x001986b8 libswift_stdlib_core.dylib`Swift.reinterpretCast <A,B>(A) -> B + 220
    frame #1: 0x001bebdc libswift_stdlib_core.dylib`Swift.ContiguousArrayBuffer.storesOnlyElementsOfType <A>(Swift.ContiguousArrayBuffer<A>)<B>(B.Type) -> Swift.Bool + 912
    frame #2: 0x001bde08 libswift_stdlib_core.dylib`Swift._arrayCheckedDownCast <A,B>(Swift.Array<A>) -> Swift.Optional<Swift.Array<B>> + 292
    frame #3: 0x00094c84 MyApp`MyApp.MyClass.(data=SomeInterface[]! at 0x27db0870,response=Foundation.NSHTTPURLResponse! at 0x27db086c,error=None,self=<unavailable>) -> (Swift.Bool) -> ()).(closure #1) + 428 at MyClass.swift:81

现在,您可以尝试通过单独转换对象来解决它：

var someClassObjects : [SomeClass] = myInterfaceObjects.map { $0 as SomeClass }

编辑：更新到最新的swift语法.另外值得一提的是这个bug可能已在beta 3或beta 4中得到解决 – 我还没有检查过

我使用Alamofire和SwiftyJSON,我的JSON数据看起来像这样：

{
  "528" : {
    "name" : "Name 1","id" : "528","product_id" : null,"visible" : "0","level" : "2"
  },"29" : {
    "name" : "Name 2","id" : "29","visible" : "1","level" : "1"
  },"173" : {
    "name" : "Name 3","id" : "173","143" : {
    "name" : "Name 4","id" : "143",

…使用此代码：

Alamofire.request(.GET,dataURL,parameters: nil,encoding: .JSON)

    .responseJSON { (request,response,jsonData,error) in

        let json = JSON(jsonData!) 

        println(json)

    }

…所以JSON一切都应该没问题

>我如何访问该数据？我的意思是我如何获得名称,ID,product_ids等
>我如何将该数据(名称)放入我的TableViewController？

>创建一个名为APIProtocol的协议.
>使用GET方法设置API类,该方法接受APIProtocol类型的委托.
>设置TableViewController以实现APIProtocol.
>从TableViewController调用API.get()

码

// Step 1
protocol APIProtocol {
  func didReceiveResult(results: JSON)
}

// Step 2
func get(path: String,parameters: [String: AnyObject]? = nil,delegate: APIProtocol? = nil){
  let url = "\(self.hostname)\(path)"
  NSLog("Preparing for GET request to: \(url)")

  Alamofire.request(.GET,url,parameters: parameters)
    .responseJSON { (req,res,json,error) in
      if(error != nil) {
        NSLog("GET Error: \(error)")
        println(res)
      }
      else {
        var json = JSON(json!)
        NSLog("GET Result: \(json)")

        // Call delegate if it was passed into the call
        if(delegate != nil) {
            delegate!.didReceiveResult(json)
        }
      }
    }
}

// Step 3
class ActivityViewController: UITableViewController,APIProtocol {
  var activityModelList: NSMutableArray = [] // This is the array that my tableView is using.

  ... 

  func didReceiveResult(result: JSON) {
    var activities: NSMutableArray = []

    NSLog("Activity.didReceiveResult: \(result)")

    for (index: String,activity: JSON) in result {

      var activityModel = ActivityModel(
        id: activity["id"].intValue,message: activity["message"].stringValue
      )

      activities.addobject(activityModel)
    }

    // Set our array of new models
    activityModelList = activities

    // Make sure we are on the main thread,and update the UI.
    dispatch_sync(dispatch_get_main_queue(),{
      self.refreshControl!.endRefreshing()
      self.tableView.reloadData()
    })
  }
}

// Step 4
override func viewDidLoad() {
  MyAPI.get("/activities",delegate: self)
}

{"DynamicKey":6410,"Meta":{"name":"","page":""}}

DynamicKey在编译时是未知的.我正在尝试找到如何的引用
使用decodable解析此结构.

public struct MyStruct: Decodable {
    public let unkNown: Double
    public let Meta: [String: String]

    private enum CodingKeys: String,CodingKey {
        case Meta = "Meta"
    }
}

有任何想法吗？

// Arbitrary key
private struct Key: CodingKey,Hashable,customstringconvertible {
    static let Meta = Key(stringValue: "Meta")!

    var description: String {
        return stringValue
    }

    var hashValue: Int { return stringValue.hash }

    static func ==(lhs: Key,rhs: Key) -> Bool {
        return lhs.stringValue == rhs.stringValue
    }

    let stringValue: String
    init(_ string: String) { self.stringValue = string }
    init?(stringValue: String) { self.init(stringValue) }
    var intValue: Int? { return nil }
    init?(intValue: Int) { return nil }
}

这是一个非常通用的工具(期望静态let元),可用于各种通用密钥问题.

有了它,你可以找到不是.Meta的第一个键,并将其用作动态键.

public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: Key.self)

    Meta = try container.decode([String: String].self,forKey: .Meta)

    guard let dynamicKey = container.allKeys.first(where: { $0 != .Meta }) else {
        throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: [],debugDescription: "Could not find dynamic key"))
    }

    unkNown = try container.decode(Double.self,forKey: dynamicKey)
}

一起作为一个游乐场：

import Foundation

let json = Data("""
{"DynamicKey":6410,"page":""}}
""".utf8)

public struct MyStruct: Decodable {
    public let unkNown: Double
    public let Meta: [String: String]

    // Arbitrary key
    private struct Key: CodingKey,customstringconvertible {
        static let Meta = Key(stringValue: "Meta")!
        var description: String {
            return stringValue
        }

        var hashValue: Int { return stringValue.hash }

        static func ==(lhs: Key,rhs: Key) -> Bool {
            return lhs.stringValue == rhs.stringValue
        }

        let stringValue: String
        init(_ string: String) { self.stringValue = string }
        init?(stringValue: String) { self.init(stringValue) }
        var intValue: Int? { return nil }
        init?(intValue: Int) { return nil }
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: Key.self)

        Meta = try container.decode([String: String].self,forKey: .Meta)

        guard let dynamicKey = container.allKeys.first(where: { $0 != .Meta }) else {
            throw DecodingError.dataCorrupted(.init(codingPath: [],debugDescription: "Could not find dynamic key"))
        }

        unkNown = try container.decode(Double.self,forKey: dynamicKey)
    }
}


let myStruct = try! JSONDecoder().decode(MyStruct.self,from: json)
myStruct.unkNown
myStruct.Meta

这项技术可以扩展到decode arbitrary JSON.有时它更容易做到,然后拉出你想要的部分,然后解码每一件.例如,使用上面的JSON要点,您可以这样实现MyStruct：

public struct MyStruct: Decodable {
    public let unkNown: Double
    public let Meta: [String: String]

    public init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        let json = try container.decode(JSON.self)

        guard let Meta = json["Meta"]?.dictionaryValue as? [String: String] else {
            throw DecodingError.dataCorrupted(.init(codingPath: [],debugDescription: "Could not find Meta key"))
        }
        self.Meta = Meta

        guard let (_,unkNownjsON) = json.objectValue?.first(where: { (key,_) in key != "Meta" }),let unkNown = unkNownjsON.doubleValue
        else {
            throw DecodingError.dataCorrupted(.init(codingPath: [],debugDescription: "Could not find dynamic key"))
        }
        self.unkNown = unkNown
    }
}