Question

我有以下代码可以更轻松地处理JSON。但是，我在调试和发布模式中遇到编译器错误：Command failed due to signal: Segmentation fault 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)
    }
}
}

Answer 1

编译器不应该是段错误，无论源代码有多么错误，所以你可以在任何情况下向Apple写一个错误报告。

但问题在于定义

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

并不意味着JSONValue.NIL(nil)是有效的枚举值。

符合NilLiteralConvertible的类型是可以的类型 使用nil初始化，例如选项：

let opt : Int? = nil

因此JSONValue.NIL(Optional<Int>(0))将是有效的枚举值。但这可能不是你想要的。

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

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

然后在代码中将.NIL(nil)替换为.NIL。至少它用这个改变编译。

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

1 个答案: