我有以下对象:

class Food {
    var cal: Int
    var displayName: String
    var imgUrl: String
    var dishType: DishType

    init(cal: Int, displayName: String, imgUrl: String, dishType: DishType) {
        self.cal = cal
        self.displayName = displayName
        self.imgUrl = imgUrl
        self.dishType = dishtype
    }
}

enum DishType {
    case starter
    case main
    case desert
}

这是我的 Alamofire 请求的一部分:

if let cal = foodJson["cal"].int,
    let displayName = foodJson["display_name"].string,
    let dishType = foodJson["type"].string,
    let imgUrl = foodJson["imgUrl"].string {
    let food = Food(cal: cal, displayName: displayName, imgUrl: imgUrl, dishType: ??)

    foods.append(food)

如何将 Json 字符串“dishType”转换为我使用枚举创建的“DishType”类型，以便正确填充我的 Food 实例？

最佳答案

您可能想为您的枚举指定一个关联值:

enum DishType: String {
    case starter = "starter"
    case main    = "main"
    case desert  = "desert"
}

或者，更简单地说:

enum DishType: String {
    case starter
    case main
    case desert
}

然后你可以这样做:

dishType = DishType(rawValue: string)

例如

if let dishTypeString = foodJson["type"].string,
    let dishType = DishType(rawValue: dishTypeString) {
        ...
}    

就我个人而言，如果使用 Swift 4，我会停用 SwiftyJSON 并使用原生的 JSONDecoder 并将您的类型声明为 Codable。 (请注意，我们仍然需要定义 DishType 以具有关联值，如上所示。)

例如，假设您的 react 是这样的:

{
    "foods": [{
            "cal": 800,
            "display_name": "Beef",
            "imgUrl": "http://example.com/wheres_the_beef.jpg",
            "dishType": "main"
        },
        {
            "cal": 2000,
            "display_name": "Chocolate cake",
            "imgUrl": "http://example.com/yummy.jpg",
            "dishType": "desert"
        }
    ]
}

然后您可以像这样定义您的类型:

struct Food: Codable {
    let cal: Int
    let displayName: String
    let imgUrl: String
    let dishType: DishType
}

enum DishType: String, Codable {
    case starter
    case main
    case desert
}

然后您可以像这样解析响应:

struct FoodsResponse: Codable {
    let foods: [Food]
}

Alamofire.request(url)
    .responseData { response in
        switch response.result {
        case .success(let data):
            do {
                let decoder = JSONDecoder()
                decoder.keyDecodingStrategy = .convertFromSnakeCase
                let responseObject = try decoder.decode(FoodsResponse.self, from: data)

                print(responseObject.foods)
            } catch {
                print(error)
            }

        case .failure(let error):
            print(error)
        }
}

这让您完全摆脱手动迭代结果以将其映射到您的对象的业务。

很明显，我假设您的真实响应有更多键，而不仅仅是 foods，因此您可以将所需的任何字段添加到 FoodsResponse，但希望这能说明让 JSONDecoder 自动将 JSON 解析为您的模型结构。

有关 JSONDecoder 和 Codable 类型的更多信息，请参阅 Encoding and Decoding Custom Types .

顺便说一下，我的示例 FoodResponse 结构提出了一些问题，为什么我不只是假设 Web 服务会返回一组 Food 对象。让我解释一下我的理由。

Web 服务响应中 FoodsResponse 的更典型结构类似于:

struct FoodsResponse: Codable {
    let success: Bool
    let error: String?   // only supplied if `success` was `false`
    let foods: [Food]?   // only supplied if `success` was `true`
}

在此结构中，此响应对象可以处理成功场景，例如:

{
    "success": true,
    "foods": [...]
}

或失败:

{
    "success": false,
    "error": "No data found"
}

我认为最好有一个包含一些常见的成功 bool 值的结构，例如success，所有格式正确的响应都包含，然后具有分别为成功或失败填充的各种属性。

关于json - Swift//将一个String Json文件转换为枚举大小写，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48243445/