使用 Swift 進行 JSON 解析

Teri3992 8年前發布 | 24K 次閱讀 Swift JSON Apple Swift開發

使用 Swift 解析 JSON 是件很痛苦的事。你必須考慮多個方面：可選類性、類型轉換、基本類型（primitive types）、構造類型（constructed types）（其構造器返回結果也是可選類型）、字符串類型的鍵（key）以及其他一大堆問題。

對于強類型（well-typed）的 Swift 來說，其實更適合使用一種強類型的有線格式(wire format)。在我的下一個項目中，我將會選擇使用 Google 的 protocol buffers （這篇文章說明了它的好處）。我希望在得到更多經驗后，寫篇文章說說它和 Swift 配合起來有多么好用。但目前這篇文章主要是關于如何解析 JSON 數據 —— 一種被最廣泛使用的有線格式。

對于 JSON 的解析，已經有了許多優秀的解決方案。第一個方案，使用如 Argo 這樣的庫，采用函數式操作符來柯里化一個初始化構造器：

extension User: Decodable {
  static func decode(j: JSON) -> Decoded<User> {
    return curry(User.init)
      <^> j <| "id"
      <*> j <| "name"
      <*> j <|? "email" // Use ? for parsing optional values
      <*> j <| "role" // Custom types that also conform to Decodable just work
      <*> j <| ["company", "name"] // Parse nested objects
  }
}

Argo 是一個非常好的解決方案。它簡潔，靈活，表達力強，但柯里化以及奇怪的操作符都是些不太好理解的東西。(Thoughtbot 的人已經寫了一篇不錯的文章來對這些加以解釋)

另外一個常見的解決方案是，手動使用 guard let 進行處理以得到非可選值。這個方案需要手動做的事兒會多一些，對于每個屬性的處理都需要兩行代碼：一行用來在 guard 語句中生成非可選的局部變量，另一行設置屬性。若要得到上例中同樣的結果，代碼可能長這樣：

class User {
  init?(dictionary: [String: AnyObject]?) {
    guard
      let dictionary = dictionary,
      let id = dictionary["id"] as? String,
      let name = dictionary["name"] as? String,
      let roleDict = dictionary["role"] as? [String: AnyObject],
      let role = Role(dictionary: roleDict)
      let company = dictionary["company"] as? [String: AnyObject],
      let companyName = company["name"] as? String,
        else {
          return nil
    }

    self.id = id
    self.name = name
    self.role = role
    self.email = dictionary["email"] as? String
    self.companyName = companyName
  }
}

這份代碼的好處在于它是純 Swift 的，不過看起來比較亂，可讀性不佳，變量間的依賴鏈并不明顯。舉個例子，由于 roleDict 被用在 role 的定義中，所以它必須在 role 被定義前定義，但由于代碼如此繁雜，很難清晰地找出這種依賴關系。

（我甚至都不想提在 Swift 1 中解析 JSON 時，大量 if let 嵌套而成的鞭尸金字塔（pyramid-of-doom），那可真是糟透了，很高興現在我們有了多行的 if let 和 guard let 結構。）

在 Swift 的錯誤處理發布的時候，我覺得這東西糟透了。似乎不管從哪一個方面都不及 Result ：

你無法直接訪問到錯誤：Swift 的錯誤處理機制在 Result 類型之上，添加了一些必須使用的語法（是的，事實如此），這讓人們無法直接訪問到錯誤。
你不能像使用 Result 一樣進行鏈式處理。 Result 是個 monad ，可以用 flatMap 鏈接起來進行有效的處理。
Swift 錯誤模型無法異步使用（除非你進行一些 hack，比如說提供一個內部函數來拋出結果)，但 Result 可以。

盡管 Swift 的錯誤處理模型有著這些看起來相當明顯的缺點，但有篇文章講述了一個使用 Swift 錯誤模型的例子，在該例子中 Swift 的錯誤模型明顯比 Objective-C 的版本更加簡潔，也比 Result 可讀性更強。這是怎么回事呢？

這里的秘密在于，當你的代碼中有許多 try 調用的時候，利用帶有 do / catch 結構的 Swift 錯誤模型進行處理，效果會非常好。在 Swift 中對代碼進行錯誤處理時需要寫一些模板代碼。在聲明函數時，你需要加入 throws ，或使用 do / catch 結構顯式地處理所有錯誤。對于單個 try 語句來說，做這些事讓人覺得很麻煩。然而，就多個 try 語句而言，這些前期工作就變得物有所值了。

我曾試圖尋找一種方法，能夠在 JSON 缺失某個鍵時打印出某種警告。如果在訪問缺失的鍵時，能夠得到一個報錯，那么這個問題就解決了。由于在鍵缺失的時候，原生的 Dictionary 類型并不會拋出錯誤，所以需要有個對象對字典進行封裝。我想實現的代碼大概長這樣：

struct MyModel {
    let aString: String
    let anInt: Int

    init?(dictionary: [String: AnyObject]?) {
        let parser = Parser(dictionary: dictionary)
        do {
            self.aString = try parser.fetch("a_string")
            self.anInt = try parser.fetch("an_int")
        } catch let error {
            print(error)
            return nil 
        }
    }
}

理想的說來，由于類型推斷的存在，在解析過程中我甚至不需要明確地寫出類型。現在讓我們絲分縷解，看看怎么實現這份代碼。首先從 ParserError 開始：

struct ParserError: ErrorType {
    let message: String
}

接下來，我們開始搞定 Parser 。它可以是一個 struct 或是一個 class 。（由于它不會被用在別的地方，所以他的引用語義并不重要。）

struct Parser {
    let dictionary: [String: AnyObject]?

    init(dictionary: [String: AnyObject]?) {
        self.dictionary = dictionary
    }
}

我們的 parser 將會獲取一個字典并持有它。

fetch 函數開始顯得有點復雜了。我們來一行一行地進行解釋。類中的每個方法都可以類型參數化，以充分利用類型推斷帶來的便利。此外，這個函數會拋出錯誤，以使我們能夠獲得處理失敗的數據：

func fetch<T>(key: String) throws -> T {

下一步是獲取鍵對應的對象，并保證它不是空的，否則拋出一個錯誤。

let fetchedOptional = dictionary?[key]
guard let fetched = fetchedOptional else {
    throw ParserError(message: "The key \"\(key)\" was not found.")
}

最后一步是，給獲得的值加上類型信息。

guard let typed = fetched as? T else {
    throw ParserError(message: "The key \"\(key)\" was not the correct type. It had value \"\(fetched).\"")
}

最終，返回帶類型的非空值。

    return typed
}

（我將會在文末附上包含所有代碼的 gist 和 playground）

這份代碼是可用的！類型參數化及類型推斷為我們處理了一切。上面寫的 “理想” 代碼完美地工作了：

self.aString = try parser.fetch("a_string")

我還想添加一些東西。首先，添加一種方法來解析出那些確實可選的值（譯者注：也就是我們允許這些值為空）。由于在這種情況下我們并不需要拋出錯誤，所以我們可以實現一個簡單許多的方法。但很不幸，這個方法無法和上面的方法同名，否則編譯器就無法知道應該使用哪個方法了，所以，我們把它命名為 fetchOptional 。這個方法相當的簡單。

func fetchOptional<T>(key: String) -> T? {
    return dictionary?[key] as? T
}

（如果鍵存在，但是并非你所期望的類型，則可以拋出一個錯誤。為了簡略起見，我就不寫了）

另外一件事就是，在字典中取出一個對象后，有時需要對它進行一些額外的轉換。我們可能得到一個枚舉的 rawValue ，需要構建出對應的枚舉，或者是一個嵌套的字典，需要處理它包含的對象。我們可以在 fetch 函數中接收一個閉包作為參數，作進一步地類型轉換，并在轉換失敗的情況下拋出錯誤。泛型中 U 參數類型能夠幫助我們明確 transformation 閉包轉換得到的結果值類型和 fetch 方法得到的值類型一致。

func fetch<T, U>(key: String, transformation: (T) -> (U?)) throws -> U {
    let fetched: T = try fetch(key)
    guard let transformed = transformation(fetched) else {
        throw ParserError(message: "The value \"\(fetched)\" at key \"\(key)\" could not be transformed.")
    }
    return transformed
}

最后，我們希望 fetchOptional 也能接受一個轉換閉包作為參數。

func fetchOptional<T, U>(key: String, transformation: (T) -> (U?)) -> U? {
    return (dictionary?[key] as? T).flatMap(transformation)
}

看啊！ flatMap 的力量！注意，轉換閉包 transformation 和 flatMap 接收的閉包有著一樣的形式： T -> U?

現在我們可以解析帶有嵌套項或者枚舉的對象了。

class OuterType {
    let inner: InnerType

    init?(dictionary: [String: AnyObject]?) {
        let parser = Parser(dictionary: dictionary)
        do {
            self.inner = try parser.fetch("inner") { InnerType(dictionary: $0) }
        } catch let error {
            print(error)
            return nil 
        }
    }
}

再一次注意到，Swift 的類型推斷魔法般地為我們處理了一切，而我們根本不需要寫下任何 as? 邏輯！

用類似的方法，我們也可以處理數組。對于基本數據類型的數組， fetch 方法已經能很好地工作了：

let stringArray: [String]

//...
do {
    self.stringArray = try parser.fetch("string_array")
//...

對于我們想要構建的特定類型（Domain Types）的數組， Swift 的類型推斷似乎無法那么深入地推斷類型，所以我們必須加入另外的類型注解：

self.enums = try parser.fetch("enums") { (array: [String]) in array.flatMap(SomeEnum(rawValue: $0)) }

由于這行顯得有些粗糙，讓我們在 Parser 中創建一個新的方法來專門處理數組：

func fetchArray<T, U>(key: String, transformation: T -> U?) throws -> [U] {
    let fetched: [T] = try fetch(key)
    return fetched.flatMap(transformation)
}

這里使用 flatMap 來幫助我們移除空值，減少了代碼量:

self.enums = try parser.fetchArray("enums") { SomeEnum(rawValue: $0) }

末尾的這個閉包應該被作用于每個元素，而不是整個數組（你也可以修改 fetchArray 方法，以在任意值無法被構建時拋出錯誤。）

我很喜歡泛型模式。它很簡單，可讀性強，而且也沒有復雜的依賴（這只是個 50 行的 Parser 類型）。它使用了 Swift 風格的結構，還會給你非常特定的錯誤提示，告訴你為何解析失敗了，當你在從服務器返回的 JSON 沼澤中摸爬滾打時，這顯得非常有用。最后，用這種方法解析的另外一個好處是，它在結構體和類上都能很好地工作，這使得從引用類型切換到值類型，或者反之，都變得很簡單。

這里是包含所有代碼的一個 gist，而這里是一個作為補充的 Playground.

來自：http://swift.gg/2016/09/06/decoding-json/

本文由用戶 Teri3992 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1473144335608.html

Swift JSON Apple Swift開發

使用 Swift 進行 JSON 解析

相關經驗

相關資訊

相關文檔

目錄