Struct 结构的初始化函数中出现Swift1.2编译器错误

我有以下代码可以更轻松地处理JSON。但是，我在调试和发布模式中遇到一个编译器错误：

命令失败，原因是信号：分段错误11

。编译器编译失败的那一行是初始化方法的第一行。我还尝试了几种不同的方法（嵌套函数、首先将闭包分配给另一个变量等等），但编译器无法让它工作。有办法解决这个问题吗？谢谢你的帮助

enum JSONValue {
case JSONString(String)
case JSONNumber(Double)
case NIL(NilLiteralConvertible)
case JSONArray(Array<JSON>)
case JSONDictionary(Dictionary<String, JSON>)
}

struct JSON {
private let value: JSONValue

init(_ object: AnyObject?) {
    value = { () -> JSONValue in
        switch object {
        case _ where object is String:
            return .JSONString(object as! String)
        case _ where object is NSNumber:
            return .JSONNumber((object as! NSNumber).doubleValue)
        case _ where object is Array<AnyObject>:
            var array = [JSON]()
            let original = object as! [AnyObject]
            for item in original {
                array += [JSON(item)]
            }
            return .JSONArray(array)
        case _ where object is [String: AnyObject]:
            var dictionary = [String: JSON]()
            let original = object as! [String: AnyObject]
            for item in original {
                dictionary[item.0] = JSON(item.1)
            }
            return .JSONDictionary(dictionary)
        default:
            return .NIL(nil)
        }
    }()
}

var dictionaryKeyArray: [String] {
    switch self.value {
    case .JSONDictionary(let dictionary):
        var result = [String]()
        for item in dictionary.keys {
            result.append(item)
        }
        return result
    default:
        fatalError("no dictionary")
    }
}

var jsonArray: [JSON] {
    switch self.value {
    case .JSONArray(let array):
        return array
    default:
        fatalError("no array")
    }
}

var stringArray: [String] {
    switch self.value {
    case .JSONArray(let array):
        var result = [String]()
        for item in array {
            result.append(item.stringValue)
        }
        return result
    default:
        fatalError("no string array")
    }
}

var doubleValue: Double {
    switch self.value {
    case .JSONNumber(let double):
        return double
    default:
        fatalError("no double value")
    }
}

var intValue: Int {
    switch self.value {
    case .JSONNumber(let int):
        return Int(int)
    default:
        fatalError("no integer value")
    }
}

var stringValue: String {
    switch self.value {
    case .JSONString(let string):
        return string
    default:
        fatalError("no string value")
    }
}

var isNil: Bool {
    switch self.value {
    case .NIL(_):
        return true
    default:
        return false
    }
}

subscript(index: Int) -> JSON {
    switch self.value {
    case .JSONArray(let array) where array.count < index:
        return array[index]
    default:
        return JSON(nil)
    }
}

subscript(key: String) -> JSON {
    switch self.value {
    case .JSONDictionary(let dictionary) where dictionary[key] != nil:
        return dictionary[key]!
    default:
        return JSON(nil)
    }
}
}

enum JSONValue{
案例JSONString（字符串）
案例编号（双）
无案例（无案例）
案例JSONArray（数组）
案例JSONDictionary（字典）
}
结构JSON{
私有let值：JSONValue
init（uObject:AnyObject？）{
value={（）->JSONValue在
开关对象{
案例uuo其中对象为字符串：
return.JSONString（对象为！字符串）
案例uu，其中对象为NSNumber：
return.JSONNumber（（对象为！NSNumber）.doubleValue）
案例uu其中对象为数组：
变量数组=[JSON]（）
将original=对象设为！[AnyObject]
对于原件中的项目{
数组+=[JSON（项目）]
}
return.JSONArray（数组）
案例uu其中对象为[String:AnyObject]：
var dictionary=[String:JSON]（）
让original=对象为！[字符串：AnyObject]
对于原件中的项目{
字典[item.0]=JSON（item.1）
}
return.JSONDictionary（字典）
违约：
返回。零（零）
}
}()
}
var dictionaryKeyArray:[字符串]{
转换自我价值{
case.JSONDictionary（let字典）：
变量结果=[String]（）
用于dictionary.keys中的项{
结果。追加（项）
}
返回结果
违约：
法塔莱罗（“无字典”）
}
}
var jsonArray:[JSON]{
转换自我价值{
case.JSONArray（let数组）：
返回数组
违约：
fatalError（“无数组”）
}
}
var stringArray:[字符串]{
转换自我价值{
case.JSONArray（let数组）：
变量结果=[String]（）
用于数组中的项{
result.append（item.stringValue）
}
返回结果
违约：
fatalError（“无字符串数组”）
}
}
var doubleValue:Double{
转换自我价值{
case.JSONNumber（加倍）：
双回程
违约：
fatalError（“无双精度值”）
}
}
var intValue:Int{
转换自我价值{
case.JSONNumber（let int）：
返回整数（整数）
违约：
fatalError（“无整数值”）
}
}
var stringValue:String{
转换自我价值{
case.JSONString（let字符串）：
返回字符串
违约：
fatalError（“无字符串值”）
}
}
变量isNil:Bool{
转换自我价值{
案例：无：
返回真值
违约：
返回错误
}
}
下标（索引：Int）->JSON{
转换自我价值{
case.JSONArray（let数组），其中array.count<索引：
返回数组[索引]
违约：
返回JSON（无）
}
}
下标（键：字符串）->JSON{
转换自我价值{
case.JSONDictionary（let dictionary），其中dictionary[key]！=nil:
返回字典[键]！
违约：
返回JSON（无）
}
}
}

无论源代码有多错误，编译器都不应出错， 所以你可以在任何情况下给苹果写一份bug报告

但问题是

enum JSONValue {
    // ...
    case NIL(NilLiteralConvertible)
    // ...
}

并不意味着

JSONValue.NIL（NIL）

是有效的枚举值

符合NilLiteralConvertible的类型是可以 使用

nil

初始化，例如选项：

let opt : Int? = nil

因此

JSONValue.NIL（可选（0））

将是一个有效的枚举值。但这可能不是你想要的

我认为您应该将枚举定义为

enum JSONValue {
    case JSONString(String)
    case JSONNumber(Double)
    case NIL     // <- instead of NIL(NilLiteralConvertible)
    case JSONArray(Array<JSON>)
    case JSONDictionary(Dictionary<String, JSON>)
}

enum JSONValue{
案例JSONString（字符串）
案例编号（双）
无案例//