• Swift 4 JSON 解析指南

    2017-07-13 08:57:28
    Apple 终于在 Swift 4 的 Foundation 的模块中添加了对 JSON 解析的原生支持。 虽然已经有很多第三方类库实现了 JSON 解析,但是能够看到这样一个功能强大、易于使用的官方实现还是不免有些兴奋。 值得注意的...

    Apple 终于在 Swift 4 的 Foundation 的模块中添加了对 JSON 解析的原生支持。

    虽然已经有很多第三方类库实现了 JSON 解析,但是能够看到这样一个功能强大、易于使用的官方实现还是不免有些兴奋。

    值得注意的是,官方的实现方式适用于任何 Encoder/Decoder ,例如 PropertyListEncoder 。当然如果你需要 XML 格式的内容,可以进行自定义实现。在接下来的内容中,我们将专注于 JSON 格式的解析,因为这是 iOS 开发中最常见的数据格式。

    基础

    如果你的 JSON 数据结构和你使用的 Model 对象结构一致的话,那么解析过程将会非常简单。

    下面是一个 JSON 格式的啤酒说明:

    1
    2
    3
    4
    5
    6
    {
        "name""Endeavor",
        "abv": 8.9,
        "brewery""Saint Arnold",
        "style""ipa"
    }

    对应的 Swift 数据结构如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    enum BeerStyle : String {
        case ipa
        case stout
        case kolsch
        // ...
    }
     
    struct Beer {
        let name: String
        let brewery: String
        let style: BeerStyle
    }

    为了将 JSON 字符串转化为 Beer 类型的实例,我们需要将 Beer 类型标记为 Codable。

    Codable 实际上是 Encodable & Decodable 两个协议的组合类型,所以如果你只需要单向转换的话,你可以只选用其中一个。该功能也是 Swift 4 中引入的最重要新特性之一。

    Codable 带有默认实现,所以在大多数情形下,你可以直接使用该默认实现进行数据转换。

    1
    2
    3
    4
    5
    6
    7
    enum BeerStyle : String, Codable {
       // ...
    }
     
    struct Beer : Codable {
       // ...
    }

    下面只需要创建一个解码器:

    1
    2
    3
    let jsonData = jsonString.data(encoding: .utf8)!
    let decoder = JSONDecoder()
    let beer = try! decoder.decode(Beer.self, for: jsonData)

    这样我们就将 JSON 数据成功解析为了 Beer 实例对象。因为 JSON 数据的 Key 与 Beer 中的属性名一致,所以这里不需要进行自定义操作。

    需要注意的是,这里直接使用了 try! 操作。因为这里只是简单示例,所以在真实程序中你应该对错误进行捕获并作出对应的处理。

    但是,现实中不可能一直都是完美情形,很大几率存在 Key 值与属性名不匹配的情形。

    自定义键值名

    通常情形下,API 接口设计时会采用 snake-case 的命名风格,但是这与 Swift 中的编程风格有着明显的差异。

    为了实现自定义解析,我们需要先去看下 Codable 的默认实现机制。

    默认情形下 Keys 是由编译器自动生成的枚举类型。该枚举遵守 CodingKey 协议并建立了属性和编码后格式之间的关系。

    为了解决上面的风格差异需要对其进行自定义,实现代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    struct Beer : Codable {
          // ...
          enum CodingKeys : String, CodingKey {
              case name
              case abv = "alcohol_by_volume"
              case brewery = "brewery_name"
              case style
        }
    }

    现在我们将 Beer 实例转化为 JSON ,看看自定义之后的 JSON 数据格式:

    1
    2
    3
    let encoder = JSONEncoder()
    let data = try! encoder.encode(beer)
    print(String(data: data, encoding: .utf8)!)

    输出如下:

    1
    {"style":"ipa","name":"Endeavor","alcohol_by_volume":8.8999996185302734,"brewery_name":"Saint Arnold"}

    上面的输出格式对阅读起来并不是太友好。不过我们可以设置 JSONEncoder 的 outputFormatting 属性来定义输出格式。

    默认 outputFormatting 属性值为 .compact,输出效果如上。如果将其改为 .prettyPrinted 后就能获得更好的阅读体检。

    1
    encoder.outputFormatting = .prettyPrinted

    效果如下:

    1
    2
    3
    4
    5
    6
    {
      "style" "ipa",
      "name" "Endeavor",
      "alcohol_by_volume" : 8.8999996185302734,
      "brewery_name" "Saint Arnold"
    }

    JSONEncoder 和 JSONDecoder 其实还有很多选项可以自定义设置。其中有一个常用的需求就是自定义时间格式的解析。

    时间格式处理

    JSON 没有数据类型表示日期格式,因此需要客户端和服务端对序列化进行约定。通常情形下都会使用 ISO 8601 日期格式并序列化为字符串。

    提示:nsdateformatter.com 是一个非常有用的网站,你可以查看各种日期格式的字符串表示,包括 ISO 8601。

    其他格式可能是参考日期起的总秒(或毫秒)数,并将其序列化为 JSON 格式中的数字类型。

    之前,我们必须自己处理这个问题。在数据结构中使用属性接收该字符串格式日期,然后使用 DateFormatter 将该属性转化为日期,反之亦然。

    不过 JSONEncoder 和 JSONDecoder 自带了该功能。默认情况下,它们使用 .deferToDate 处理日期,如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    struct Foo : Encodable {
        let date: Date
    }
     
    let foo = Foo(date: Date())
    try! encoder.encode(foo)
    {
      "date" : 519751611.12542897
    }

    当然,我们也可以选用 .iso8601 格式:

    1
    2
    3
    4
    encoder.dateEncodingStrategy = .iso8601
    {
      "date" "2017-06-21T15:29:32Z"
    }

    其他日期编码格式选择如下:

    • .formatted(DateFormatter) - 当你的日期字符串是非标准格式时使用。需要提供你自己的日期格式化器实例。

    • .custom((Date, Encoder) throws -> Void ) - 当你需要真正意义上的自定义时,使用一个闭包进行实现。

    • .millisecondsSince1970、 .secondsSince1970 - 这在 API 设计中不是很常见。 由于时区信息完全不在编码表示中,所以不建议使用这样的格式,这使得人们更容易做出错误的假设。

    对日期进行 Decoding 时基本上是相同的选项,但是 .custom 形式是 .custom((Decoder) throws -> Date ),所以我们给了一个解码器并将任意类型转换为日期格式。

    浮点类型处理

    浮点是 JSON 与 Swift 另一个存在不匹配情形的类型。如果服务器返回的事无效的 "NaN" 字符串会发生什么?无穷大或者无穷大?这些不会映射到 Swift 中的任何特定值。

    默认的实现是 .throw,这意味着如果上述数值出现的话就会引发错误,不过对此我们可以自定义映射。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    {
       "a""NaN",
       "b""+Infinity",
       "c""-Infinity"
    }
    struct Numbers {
      let a: Float
      let b: Float
      let c: Float
    }
    decoder.nonConformingFloatDecodingStrategy =
      .convertFromString(
          positiveInfinity: "+Infinity",
          negativeInfinity: "-Infinity",
          nan: "NaN")
     
    let numbers = try! decoder.decode(Numbers.elf, from: jsonData)
    dump(numbers)

    上述处理后:

    1
    2
    3
    4
    __lldb_expr_71.Numbers
      - a: inf
      - b: -inf
      - c: nan

    当然,我们也可以使用 JSONEncoder 的 nonConformingFloatEncodingStrategy 进行反向操作。

    虽然大多数情形下上述处理不太可能出现,但是以防万一也不给过。

    Data 处理

    有时候服务端 API 返回的数据是 base64 编码过的字符串。

    对此,我们可以在 JSONEncoder 使用以下策略:

    • .base64

    • .custom((Data, Encoder) throws -> Void)

    反之,编码时可以使用:

    • .base64

    • .custom((Decoder) throws -> Data)

    显然,.base64 时最常见的选项,但如果需要自定义的话可以采用 block 方式。

    Wrapper Keys

    通常 API 会对数据进行封装,这样顶级的 JSON 实体 始终是一个对象。

    例如:

    1
    2
    3
    {
      "beers": [ {...} ]
    }

    在 Swift 中我们可以进行对应处理:

    1
    2
    3
    struct BeerList : Codable {
        let beers: [Beer]
    }

    因为键值与属性名一致,所有上面代码已经足够了。

    Root Level Arrays

    如果 API 作为根元素返回数组,对应解析如下所示:

    1
    2
    let decoder = JSONDecoder()
    let beers = try decoder.decode([Beer].self, from: data)

    需要注意的是,我们在这里使用 Array 作为类型。只要 T 可解码,Array 就可解码。

    Dealing with Object Wrapping Keys

    另一个常见的场景是,返回的数组对象里的每一个元素都被包装为字典类型对象。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    [
      {
        "beer" : {
          "id""uuid12459078214",
          "name""Endeavor",
          "abv": 8.9,
          "brewery""Saint Arnold",
          "style""ipa"
        }
      }
    ]

    你可以使用上面的方法来捕获此 Key 值,但最简单的方式就是认识到该结构的可编码的实现形式。

    如下:

    1
    [[String:Beer]]

    或者更易于阅读的形式:

    1
    Array

    与上面的 Array 类似,如果 K 和 T 是可解码 Dictionary就能解码。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    let decoder = JSONDecoder()
    let beers = try decoder.decode([[String:Beer]].self, from: data)
    dump(beers)
     1 element
      ? 1 key/value pair
        ? (2 elements)
          - key: "beer"
          ? value: __lldb_expr_37.Beer
            - name: "Endeavor"
            - brewery: "Saint Arnold"
            - abv: 8.89999962
            - style: __lldb_expr_37.BeerStyle.ipa

    更复杂的嵌套

    有时候 API 的响应数据并不是那么简单。顶层元素不一定只是一个对象,而且通常情况下是多个字典结构。

    例如:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    {
        "meta": {
            "page": 1,
            "total_pages": 4,
            "per_page": 10,
            "total_records": 38
        },
        "breweries": [
            {
                "id": 1234,
                "name""Saint Arnold"
            },
            {
                "id": 52892,
                "name""Buffalo Bayou"
            }
        ]
    }

    在 Swift 中我们可以进行对应的嵌套定义处理:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    struct PagedBreweries : Codable {
        struct Meta : Codable {
            let page: Int
            let totalPages: Int
            let perPage: Int
            let totalRecords: Int
            enum CodingKeys : String, CodingKey {
                case page
                case totalPages = "total_pages"
                case perPage = "per_page"
                case totalRecords = "total_records"
            }
        }
     
        struct Brewery : Codable {
            let id: Int
            let name: String
        }
     
        let meta: Meta
        let breweries: [Brewery]
    }

    该方法的最大优点就是对同一类型的对象做出不同的响应(可能在这种情况下,“brewery” 列表响应中只需要 id 和 name 属性,但是如果查看详细内容的话则需要更多属性内容)。因为该情形下 Brewery 类型是嵌套的,我们依旧可以在其他地方进行不同的 Brewery 类型实现。

    结论

    Swift 4 中基础 Codable API 的内容已经介绍差不多了。更多的内容可以查看 Codable.swiftUsing JSON with Custom Types 。

    展开全文
  • 使用SwiftyJSON解析JSON

    2017-01-04 15:34:29
    因为Swift对于类型有非常严格的控制,它在处理JSON时是挺麻烦的,因为它天生就是隐式类型。SwiftyJSON是一个能帮助我们在Swift中使用JSON的开源类库。开始之前,让我们先看一下在Swift中处理JSON是多么痛苦。 下载...

    因为Swift对于类型有非常严格的控制,它在处理JSON时是挺麻烦的,因为它天生就是隐式类型。SwiftyJSON是一个能帮助我们在Swift中使用JSON的开源类库。开始之前,让我们先看一下在Swift中处理JSON是多么痛苦。

    下载地址:https://github.com/lingoer/SwiftyJSON

    下面将解析http://api.smemo.info/test.php/Index/jsonTest?type=3这个JSON数据。

    //SwiftyJson
            
            //获取json
            var apiData:NSData!=NSData(contentsOfURL: NSURL(string: "http://api.smemo.info/test.php/Index/jsonTest?type=3")!, options: NSDataReadingOptions.DataReadingUncached, error: nil)
            //make json object
            var result=NSString(data: apiData, encoding: NSUTF8StringEncoding)
            var error:NSError?
            
            println(result)

            //生成json字段
            
            let json=JSON(data: apiData, options: NSJSONReadingOptions.allZeros, error: &error);
            //解析字段
            if let language=json["language"].stringValue{
                println("lanauage:\(language)")
            }
            if let title=json["user"]["title"].stringValue{
                println("user title:\(title)")
            }
            if let url=json["user"]["url"].stringValue{
                println("user url:\(url)")
            }
            //解析数组
            if let dataArray = json["data"].arrayValue{
                println(dataArray.description)
                //遍历数组
                for item in dataArray{
                    println(item.description)
                    //解析数组内的字段
                    if let type=item["name"].stringValue{
                        println("type:\(type)")
                    }
                    if let type=item["form"].stringValue{
                        println("form:\(type)")
                    }
                    if let type=item["type"].stringValue{
                        println("type:\(type)")
                    }
                }
            }
            //解析字段以及下面的数组
            if let extra = json["extra"]["type"].stringValue{
                println("extra type:\(extra)")
            }
            //解析字段内的数组
            if let dataArray = json["extra"]["data"].arrayValue{
                println(dataArray.description)
                //遍历数组
                for item in dataArray{
                    println(item.description)
                    //解析数组内的字段
                    if let type=item["name"].stringValue{
                        println("extra type:\(type)")
                    }
                    if let type=item["form"].stringValue{
                        println("extra form:\(type)")
                    }
                    if let type=item["type"].stringValue{
                        println("extra type:\(type)")
                    }
                }
            }
    展开全文
  • Swift4 JSON解析指南

    2017-07-05 14:48:39
    Apple 终于在 Swift 4 的 Foundation 的模块中添加了对 JSON 解析的原生支持。 虽然已经有很多第三方类库实现了 JSON 解析,但是能够看到这样一个功能强大、易于使用的官方实现还是不免有些兴奋。 值得注意的是,...

    原文链接点击打开链接

    Apple 终于在 Swift 4 的 Foundation 的模块中添加了对 JSON 解析的原生支持。

    虽然已经有很多第三方类库实现了 JSON 解析,但是能够看到这样一个功能强大、易于使用的官方实现还是不免有些兴奋。

    值得注意的是,官方的实现方式适用于任何 Encoder/Decoder ,例如 PropertyListEncoder 。当然如果你需要 XML 格式的内容,可以进行自定义实现。在接下来的内容中,我们将专注于 JSON 格式的解析,因为这是 iOS 开发中最常见的数据格式。

    基础

    如果你的 JSON 数据结构和你使用的 Model 对象结构一致的话,那么解析过程将会非常简单。

    下面是一个 JSON 格式的啤酒说明:

    1
    2
    3
    4
    5
    6
    {
        "name""Endeavor",
        "abv": 8.9,
        "brewery""Saint Arnold",
        "style""ipa"
    }

    对应的 Swift 数据结构如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    enum BeerStyle : String {
        case ipa
        case stout
        case kolsch
        // ...
    }
     
    struct Beer {
        let name: String
        let brewery: String
        let style: BeerStyle
    }

    为了将 JSON 字符串转化为 Beer 类型的实例,我们需要将 Beer 类型标记为 Codable。

    Codable 实际上是 Encodable & Decodable 两个协议的组合类型,所以如果你只需要单向转换的话,你可以只选用其中一个。该功能也是 Swift 4 中引入的最重要新特性之一。

    Codable 带有默认实现,所以在大多数情形下,你可以直接使用该默认实现进行数据转换。

    1
    2
    3
    4
    5
    6
    7
    enum BeerStyle : String, Codable {
       // ...
    }
     
    struct Beer : Codable {
       // ...
    }

    下面只需要创建一个解码器:

    1
    2
    3
    let jsonData = jsonString.data(encoding: .utf8)!
    let decoder = JSONDecoder()
    let beer = try! decoder.decode(Beer.self, for: jsonData)

    这样我们就将 JSON 数据成功解析为了 Beer 实例对象。因为 JSON 数据的 Key 与 Beer 中的属性名一致,所以这里不需要进行自定义操作。

    需要注意的是,这里直接使用了 try! 操作。因为这里只是简单示例,所以在真实程序中你应该对错误进行捕获并作出对应的处理。

    但是,现实中不可能一直都是完美情形,很大几率存在 Key 值与属性名不匹配的情形。

    自定义键值名

    通常情形下,API 接口设计时会采用 snake-case 的命名风格,但是这与 Swift 中的编程风格有着明显的差异。

    为了实现自定义解析,我们需要先去看下 Codable 的默认实现机制。

    默认情形下 Keys 是由编译器自动生成的枚举类型。该枚举遵守 CodingKey 协议并建立了属性和编码后格式之间的关系。

    为了解决上面的风格差异需要对其进行自定义,实现代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    struct Beer : Codable {
          // ...
          enum CodingKeys : String, CodingKey {
              case name
              case abv = "alcohol_by_volume"
              case brewery = "brewery_name"
              case style
        }
    }

    现在我们将 Beer 实例转化为 JSON ,看看自定义之后的 JSON 数据格式:

    1
    2
    3
    let encoder = JSONEncoder()
    let data = try! encoder.encode(beer)
    print(String(data: data, encoding: .utf8)!)

    输出如下:

    1
    {"style":"ipa","name":"Endeavor","alcohol_by_volume":8.8999996185302734,"brewery_name":"Saint Arnold"}

    上面的输出格式对阅读起来并不是太友好。不过我们可以设置 JSONEncoder 的 outputFormatting 属性来定义输出格式。

    默认 outputFormatting 属性值为 .compact,输出效果如上。如果将其改为.prettyPrinted 后就能获得更好的阅读体检。

    1
    encoder.outputFormatting = .prettyPrinted

    效果如下:

    1
    2
    3
    4
    5
    6
    {
      "style" "ipa",
      "name" "Endeavor",
      "alcohol_by_volume" : 8.8999996185302734,
      "brewery_name" "Saint Arnold"
    }

    JSONEncoder 和 JSONDecoder 其实还有很多选项可以自定义设置。其中有一个常用的需求就是自定义时间格式的解析。

    时间格式处理

    JSON 没有数据类型表示日期格式,因此需要客户端和服务端对序列化进行约定。通常情形下都会使用 ISO 8601 日期格式并序列化为字符串。

    提示:nsdateformatter.com 是一个非常有用的网站,你可以查看各种日期格式的字符串表示,包括 ISO 8601。

    其他格式可能是参考日期起的总秒(或毫秒)数,并将其序列化为 JSON 格式中的数字类型。

    之前,我们必须自己处理这个问题。在数据结构中使用属性接收该字符串格式日期,然后使用 DateFormatter 将该属性转化为日期,反之亦然。

    不过 JSONEncoder 和 JSONDecoder 自带了该功能。默认情况下,它们使用 .deferToDate 处理日期,如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    struct Foo : Encodable {
        let date: Date
    }
     
    let foo = Foo(date: Date())
    try! encoder.encode(foo)
    {
      "date" : 519751611.12542897
    }

    当然,我们也可以选用 .iso8601 格式:

    1
    2
    3
    4
    encoder.dateEncodingStrategy = .iso8601
    {
      "date" "2017-06-21T15:29:32Z"
    }

    其他日期编码格式选择如下:

    • .formatted(DateFormatter) - 当你的日期字符串是非标准格式时使用。需要提供你自己的日期格式化器实例。

    • .custom((Date, Encoder) throws -> Void ) - 当你需要真正意义上的自定义时,使用一个闭包进行实现。

    • .millisecondsSince1970、 .secondsSince1970 - 这在 API 设计中不是很常见。 由于时区信息完全不在编码表示中,所以不建议使用这样的格式,这使得人们更容易做出错误的假设。

    对日期进行 Decoding 时基本上是相同的选项,但是 .custom 形式是 .custom((Decoder) throws -> Date ),所以我们给了一个解码器并将任意类型转换为日期格式。

    浮点类型处理

    浮点是 JSON 与 Swift 另一个存在不匹配情形的类型。如果服务器返回的事无效的 "NaN" 字符串会发生什么?无穷大或者无穷大?这些不会映射到 Swift 中的任何特定值。

    默认的实现是 .throw,这意味着如果上述数值出现的话就会引发错误,不过对此我们可以自定义映射。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    {
       "a""NaN",
       "b""+Infinity",
       "c""-Infinity"
    }
    struct Numbers {
      let a: Float
      let b: Float
      let c: Float
    }
    decoder.nonConformingFloatDecodingStrategy =
      .convertFromString(
          positiveInfinity: "+Infinity",
          negativeInfinity: "-Infinity",
          nan: "NaN")
     
    let numbers = try! decoder.decode(Numbers.elf, from: jsonData)
    dump(numbers)

    上述处理后:

    1
    2
    3
    4
    __lldb_expr_71.Numbers
      - a: inf
      - b: -inf
      - c: nan

    当然,我们也可以使用 JSONEncoder 的 nonConformingFloatEncodingStrategy 进行反向操作。

    虽然大多数情形下上述处理不太可能出现,但是以防万一也不给过。

    Data 处理

    有时候服务端 API 返回的数据是 base64 编码过的字符串。

    对此,我们可以在 JSONEncoder 使用以下策略:

    • .base64

    • .custom((Data, Encoder) throws -> Void)

    反之,编码时可以使用:

    • .base64

    • .custom((Decoder) throws -> Data)

    显然,.base64 时最常见的选项,但如果需要自定义的话可以采用 block 方式。

    Wrapper Keys

    通常 API 会对数据进行封装,这样顶级的 JSON 实体 始终是一个对象。

    例如:

    1
    2
    3
    {
      "beers": [ {...} ]
    }

    在 Swift 中我们可以进行对应处理:

    1
    2
    3
    struct BeerList : Codable {
        let beers: [Beer]
    }

    因为键值与属性名一致,所有上面代码已经足够了。

    Root Level Arrays

    如果 API 作为根元素返回数组,对应解析如下所示:

    1
    2
    let decoder = JSONDecoder()
    let beers = try decoder.decode([Beer].self, from: data)

    需要注意的是,我们在这里使用 Array 作为类型。只要 T 可解码,Array 就可解码。

    Dealing with Object Wrapping Keys

    另一个常见的场景是,返回的数组对象里的每一个元素都被包装为字典类型对象。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    [
      {
        "beer" : {
          "id""uuid12459078214",
          "name""Endeavor",
          "abv": 8.9,
          "brewery""Saint Arnold",
          "style""ipa"
        }
      }
    ]

    你可以使用上面的方法来捕获此 Key 值,但最简单的方式就是认识到该结构的可编码的实现形式。

    如下:

    1
    [[String:Beer]]

    或者更易于阅读的形式:

    1
    Array

    与上面的 Array 类似,如果 K 和 T 是可解码 Dictionary就能解码。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    let decoder = JSONDecoder()
    let beers = try decoder.decode([[String:Beer]].self, from: data)
    dump(beers)
     1 element
      ? 1 key/value pair
        ? (2 elements)
          - key: "beer"
          ? value: __lldb_expr_37.Beer
            - name: "Endeavor"
            - brewery: "Saint Arnold"
            - abv: 8.89999962
            - style: __lldb_expr_37.BeerStyle.ipa

    更复杂的嵌套

    有时候 API 的响应数据并不是那么简单。顶层元素不一定只是一个对象,而且通常情况下是多个字典结构。

    例如:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    {
        "meta": {
            "page": 1,
            "total_pages": 4,
            "per_page": 10,
            "total_records": 38
        },
        "breweries": [
            {
                "id": 1234,
                "name""Saint Arnold"
            },
            {
                "id": 52892,
                "name""Buffalo Bayou"
            }
        ]
    }

    在 Swift 中我们可以进行对应的嵌套定义处理:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    struct PagedBreweries : Codable {
        struct Meta : Codable {
            let page: Int
            let totalPages: Int
            let perPage: Int
            let totalRecords: Int
            enum CodingKeys : String, CodingKey {
                case page
                case totalPages = "total_pages"
                case perPage = "per_page"
                case totalRecords = "total_records"
            }
        }
     
        struct Brewery : Codable {
            let id: Int
            let name: String
        }
     
        let meta: Meta
        let breweries: [Brewery]
    }

    该方法的最大优点就是对同一类型的对象做出不同的响应(可能在这种情况下,“brewery” 列表响应中只需要 id 和 name 属性,但是如果查看详细内容的话则需要更多属性内容)。因为该情形下 Brewery 类型是嵌套的,我们依旧可以在其他地方进行不同的 Brewery 类型实现。

    结论

    Swift 4 中基础 Codable API 的内容已经介绍差不多了。更多的内容可以查看 Codable.swiftUsing JSON with Custom Types

    展开全文
  • 做实际项目总是离不开这两步,大多数情况下都是采用第三方框架来辅助完成,swift也不...网络请求使用AFNetworking,json解析使用MJExtension。 下面开始正文:1. swift中使用oc框架其原理很简单,需要一个.h头文件,里

    做实际项目总是离不开这两步,大多数情况下都是采用第三方框架来辅助完成,swift也不例外,由于swift并不成熟,用swift语言写的第三方框架很不稳定(苹果更新太快了),所幸swift和oc可以混编,所以本次使用的框架都是oc里面常用的。网络请求使用AFNetworking,json解析使用MJExtension。
    下面开始正文:

    1. swift中使用oc框架

    其原理很简单,需要一个.h头文件,里面导入我们需要使用的oc框架的头文件,把这个.h文件配置到项目设置中即可

    1).我们采取一个不容易出错的方法来创建.h文件,在swift项目中新建oc类

    这里写图片描述

    注意语言选择oc语言,创建完后,xcode会有这么一个提示

    这里写图片描述

    询问是否创建一个桥街头,这波很关键,点创建
    这里写图片描述

    如图,创建完后在项目设置那里会有配置这个文件的,如果自己创建自己配置,很容易把路径写错~
    接下来测试一下我们是否配置正确
    在前面创建的test类中写一个方法,并且在swift中调用

    这里写图片描述

    这里写图片描述

    在上面的桥街头文件中导入test.h (很关键!)
    这里写图片描述

    在swift中调用测试
    这里写图片描述

    一般会高亮并且能自动提示就没啥子问题了、

    2. 引入第三方框架并调用

    这里就很简单了,直接把代码拷贝进来,导入头文件就行了

    这里写图片描述

    并且在桥街头文件中导入框架包

    #import "AFNetworking.h"
    #import "MJExtension.h"

    至于框架的使用方法,我就不再赘述,官方文档写的很清楚了、

     let manager = AFHTTPSessionManager()
            let url = "http://op.juhe.cn/onebox/weather/query?cityname=%e6%b7%b1%e5%9c%b3&key=eb08f814be6e473ec5ad9a6bde57e5e5&dtype=json"
    
            manager.GET(url, parameters: nil, success: { ( datatask :NSURLSessionDataTask, object :AnyObject?) in
                NSLog("请求成功")            
            },failure: { (datask, object) in
                NSLog("请求失败%@",object)
            })

    还有一个要注意的,在高版本的xcode中,不允许使用http请求(只允许HTTPS),需要在项目的plist文件中加入这么一段

    <key>NSAppTransportSecurity</key><dict>
            <key>NSAllowsArbitraryLoads</key>
            <true/></dict>

    测试一下,如果上述配置正确的话,是能够打印请求成功的~

    3.请求成功后的数据解析
    看回调方法上,object就是返回的数据,但是他是一个anyobject类型,就相当于oc里面的id类型(任意类型),实测返回的是一个字典类型,倘若你想打印出来,需要先强转成字典(oc里面可以直接打印)

    let dict : NSDictionary = object as! NSDictionary
                NSLog("%@", dict)

    框架已经帮我们转成字典类型了,现在要做的就是字典转模型了

    4.复杂json解析&模型的写法

    上面我们已经取到了字典了,其实已经可以利用系统的方法来字典转模型,但是对于比较复杂的json数据,系统的方法还是需要让我们写很多的代码~
    这次用来测试的json数据是天气预报的,放出接口文档,上面有返回的json示例,如果你把上面的字典打印出来了,你也将看到大致结构

    模型类

    class WeatherBean: NSObject {
    
        var reason : String!
        var error_code : NSNumber!
        var result : Result!
    
    
        class Result: NSObject {
            var data:Data!
        }
    
        class Data: NSObject {
            var realtime:Realtime!
            var life:Life!
            var weather:Array<Weather2>!
            var pm25:Pm25!
            var date : String!
            var isForeign : NSNumber!
    
        }
    
        class Realtime: NSObject {
            var city_code:String!
            var city_name:String!
            var date:String!
            var time:String!
            var week:NSNumber!
            var moon:String!
            var dataUptime:NSNumber!
            var weather:Weather!
            var wind:Wind!
    
        }
    
        class Weather: NSObject {
            var temperature:String!
            var humidity:String!
            var info:String!
            var img:String!
        }
    
        class Wind: NSObject {
            var direct:String!
            var power:String!
            var offset:String!
            var windspeed:String!
        }
    
        class Life: NSObject {
            var data:String!
            var info:Info!
        }
        class Info: NSObject {
            var chuanyi:Array<String>!
            var ganmao:Array<String>!
            var kongtiao:Array<String>!
            var wuran:Array<String>!
            var xiche:Array<String>!
            var yundong:Array<String>!
            var ziwaixian:Array<String>!
        }
    
        class Weather2: NSObject {
            var date:String!
            var info:Info2!
            var week:String!
            var nongli:String!
    
            class Info2: NSObject {
                var day:Array<String>!
                var night:Array<String>!
            }
    
        }
    
        class Pm25: NSObject {
    
            var show_desc:String!
            var pm25:Pm252!
            var dateTime:String!
            var key:String!
            var cityName:String!
    
            class Pm252: NSObject {
                var pm25:String!
                var curPm:String!
                var pm10:String!
                var level:String!
                var quality:String!
                var des:String!
    
            }
    
    
        }
    
    
    }
    

    最深大概4-5层,算的上是很复杂的了~

    Java的小伙伴一定都用过gson,其实mj解析和这个非常像,模型类的写法都一致

     manager.GET(url, parameters: nil, success: { ( datatask :NSURLSessionDataTask, object :AnyObject?) in
    
                let weat = WeatherBean.mj_objectWithKeyValues(object)
                NSLog("请求成功"+weat.reason+weat.result.data.pm25.cityName)
    
    
            },failure: { (datask, object) in
                NSLog("请求失败%@",object)
            })

    如此便能解析到所有的数据~

    打个断点,可以看到更多数据哦
    这里写图片描述

    完~

    展开全文
  • Swift Json解析基础

    2019-07-18 23:48:50
    func JSONToData(obj:Any) -> Data { //先判断是否可以转换 if !JSONSerialization.isValidJSONObject(obj) { return Data.init() } //开始转换 ...
    func JSONToData(obj:Any) -> Data {
           
            //先判断是否可以转换
            if !JSONSerialization.isValidJSONObject(obj) {
                return Data.init()
            }
            
            //开始转换
            //JSONSerialization.WritingOptions.prettyPrinted 是输出JSON时的格式更容易查看。
            return try! JSONSerialization.data(withJSONObject: obj, options: .prettyPrinted)      
        }
        
        func DataToJSON(anyData:Data) -> Any {
            if JSONSerialization.isValidJSONObject(anyData) {
                return anyData
            }
            
            //开始转换
            return try! JSONSerialization.jsonObject(with: anyData, options: JSONSerialization.ReadingOptions.mutableContainers)
        }
    
        func jsonToStream(obj:Any,stream:OutputStream) -> (Int,NSError?) {
            //判断是否可以写入
            var error:NSError?
            if !JSONSerialization.isValidJSONObject(obj){
                return (0,error)
            }
            
            let result = JSONSerialization.writeJSONObject(obj, to: stream, options: .prettyPrinted, error: &error)
            if (error != nil) {
                return (0,error!)
            }
            return (result,nil)
        }
        
        func StreamToJSON(stream:InputStream) -> Any {
            return try! JSONSerialization.jsonObject(with: stream, options: .mutableContainers)
        }

     

    Call Fuction

    // 数组转换
        let  ArrayFunc = ["aa","bb","ccc"]
        // 转换
        let ArrayJsonData = JSONToData(obj: ArrayFunc)
        // 解码
        let ArrayUJson = DataToJSON(anyData: ArrayJsonData)
        // 输出
        print(ArrayUJson)
    
    /*
    打印
    
    (
        aa,
        bb,
        ccc
    )
    
    */
        
        //字典转换
        let dict:[String : Any]=["name":"jack","age":18]
        let dataDict=JSONToData(obj: dict)
        let dict2=DataToJSON(anyData: dataDict)
        print(dict2)
    
    /*
    打印
    
    {
        age = 18;
        name = jack;
    }
    
    */

     

    转载于:https://www.cnblogs.com/dhui69/p/11202476.html

    展开全文
  • // ViewController.swift // AFNetworking_swiftDemo // // Created by apple on 15/7/27. // Copyright (c) 2015年 紫晶立方科技有限公司. All rights reserved. // import UIKit class ...
  • iOS Json解析Swift

    2016-10-31 14:55:30
    let result = String.init(data: data!, encoding: NSUTF8StringEncoding)     let data = (result?.dataUsingEncoding(NSUTF8StringEncoding)!)! as NSData  
  • 我们使用swift JSONSerialization进行解析 数据分为两种 “{}“和”[]” 一.数据格式为“{}” import UIKit let jsonstr="{\"status\":\"1\",\"data\":{\"udid\":\"5bce8b974adbc6a60858d41657f1761305f62ce9\",\...
  • 开源项目:JSONNeverDie,纯 Swift 开发的全功能 JSON 解析、生成库,兼容 SwiftyJSON 主要 API:https://github.com/johnlui/JSONNeverDie 本篇文章中,我将跟大家一起,一步一步构造出一个好用的 JSON 解析...
  • {"results":[{"location":{"id":"WS0E9D8WN298","name":"广州","country":"CN","path":"广州,广州,广东,中国","timezone":"Asia/Shanghai","timezone_offset":"+08:00"},"now":{"text":"大雨","code...如何进行json解析
  • json数组 ,单个的json已经回解析了,下面是解析单个json的方法 var json : AnyObject = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions.AllowFragments, error: nil)! var name...
  • Swift 里处理 JSON 其实是一件挺棘手的事情,因为 Swift 对于类型的要求非常严格,所以在解析JSON 之后想要从结果的 AnyObject 中获取某个键值是一件非常麻烦的事情。举个例子,我们使用 ...
  • swift-json解析数据类型

    2018-11-27 13:47:01
    let dic = NSMutableDictionary() dic["age"] = 20 dic["name"] = "明月" dic["address"] = nil dic["weight"] = 1 dic["student"...l
  • 这里讲解的是json字符串解析.寻常解析用三方库即可.但是有时,解析出来的数据并不是你想要的. 例如返回的数据为一个数组,但是却用json字符串包装的.那么你用原生的或三方库解析出来的数据为一个字符串类型:
  • Swift中,使用NSJSONSerialization对象,进行解析.1:将对象(字典/数组)转换成Json String 需要注意:并不是所有的对象都能转换成Json,必须满足以下条件: 1,顶层对象必须是NSArray或者NSDictionary 2,所有的对象...
  • Json的解码与编码操作,这里使用swift自带的类JSONDecoder 和 JSONEncoder 1、基础处理 如果你的 JSON 数据结构和你使用的 Model 对象结构一致的话,那么解析过程将会非常简单 2、自定义键值名 默认情形下 Keys ...
  • swift4--解析json文件

    2018-08-19 12:36:05
    首先添加一个供测试用的JSON文件 menu.json { "menu": { "id": "file", "value": "File", "menuitem": [ { "value": &...
  • 1 创建工程:打开xcode 选择ios平台下的sing view application ,选择swift语言,创建工程 2 在项目中新建data.json文件,用于存储json格式的文件 3 data.json文件的内容是(ps:这里的数据是找的网上的json...
  • 方法一: import Foundationimport ObjectMapperimport Moyaimport FTIndicatorstruct RejectModel : Codable { var id = 0 var projectnm = "" var requestdt = "" var createdAt = "...
  • 6个开源库的JSON解析速度测试
1 2 3 4 5 ... 20
收藏数 5,126
精华内容 2,050