無法從 swift 中的字典 JSON 數組中獲取值

Question

json 響應：“結果”：{

   "user_images": [
        {
            "id": 113,
            "user_id": "160",
            "image": "1617349564.jpg",
            "image_title": "33"
          
        },
        {
            "id": 112,
            "user_id": "160",
            "image": "1617349541.jpg",
            "image_title": "22"
           
        },
        {
            "id": 111,
            "user_id": "160",
            "image": "1617349528.jpg",
            "image_title": "11"
        },
        ........

代碼：使用此代碼，我得到像上面這樣的響應意味着所有user_images數組都來了...但是在這里我需要image_title如何獲得它..如果我運行 for loop 得到錯誤..請幫忙

  if let code = ((response.dict?["result"] as? [String : Any])){
      let userImages = code["user_images"] as? [String : Any]

   }

如何從上面的字典數組中獲取image_title值

Answer 1

溶膠一

if let code = response.dict?["result"] as? [String : Any]  {
  if let userImages = code["user_images"] as? [[String : Any]] {
      for item in userImages {
         print(item["image_title"])
      } 
   } 
}

溶膠 2

if let code = response.dict?["result"] as? [String : Any]  { 
   do { 
       let data = try JSONSerialization.data(withJSONObject: code) 
       let decoder = JSONDecoder() 
       decoder.keyDecodingStrategy = .convertFromSnakeCase 
       let res = try decoder.decode(Result.self, from: data) 
       let titles = res.userImages.map { $0.imageTitle } 
       print(titles) 
   }
   catch {
       print(error)
   } 
}

---

// MARK: - Result
struct Result: Codable {
    let userImages: [UserImage]
 
} 
// MARK: - UserImage
struct UserImage: Codable {
    let id: Int
    let userId, image, imageTitle: String
}

Answer 2

來自@Sh_Khan 的代碼

if let code = response.dict?["result"] as? [String : Any]  {
  //You're using "as?" which means you're casting as an optional type. 
  //One simple solution to this is here where it's unwrapped using "if let"
  if let userImages = code["user_images"] as? [[String : Any]] {
      // [String:Any] is a Dictionary
      // [[String:Any]] is an Array of Dictionary
      for item in userImages {
         print(item["image_title"])
      } 
   } else {
      // We didn't unwrap this safely at all, do something else. 
}

讓我們深入研究一下。 這個結構是 JSON Object

    {
        "id": 113,
        "user_id": "160",
        "image": "1617349564.jpg",
        "image_title": "33"
    }

但是當它獨立時，它只是一個 JSON object。 添加一個鍵，或者在這個例子中user_images使它成為一個字典。 請注意， [沒有包裹它。 意味着它是一個獨立的字典。 如果這是您的 object，僅此一項，您的原始代碼就可以工作，但您正在處理一個Array of Dictionaries 。

"user_images":
    {
        "id": 113,
        "user_id": "160",
        "image": "1617349564.jpg",
        "image_title": "33"
    }

這行代碼本質上意味着您期望取回該Array of Dictionary 。 請記住，字典的每個值都不是數組值，這就是為什么您看不到類似[[[String: Any]]]的內容，因為數據不是這樣嵌套的。

if let userImages = code["user_images"] as? [[String : Any]]

這與選項有關嗎？

可選項基本上是可以返回的nil可能值。 通常，在使用 JSON 時，您不能保證始終會收到給定鍵的值。 鍵值對甚至可能完全丟失。 如果發生這種情況，您最終會崩潰，因為它沒有得到處理。 以下是處理Optionals的最常用方法

var someString: String? //This is the optional one
var someOtherString = "Hello, World!" //Non-optional

if let unwrappedString1 = someString {
   //This code will never be reached
} else {
   //This code will, because it can't be unwrapped.
}

guard let unwrappedString2 = someString else {
   //This code block will run
   return //Could also be continue, break, or return someValue
} 

//The code will never make it here.
print(someOtherString)

此外，您可以通過鏈式展開來使用選項，這是一個很好的功能。

var someString: String?
var someInt: Int?
var someBool: Bool?

someString = "Hello, World!"

//someString is not nil, but an important distinction to make, if any
//fail, ALL fail.
if let safeString = someString,
   let safeInt = someInt,
   let safeBool = someBool {
      //If the values are unwrapped safely, they will be accessible here.
      //In this case, they are nil, so this block will never be hit.
      //I make this point because of scope, the guard statement saves you from the 
      //scoping issue present in if let unwrapping.
      print(safeString)
      print(safeInt)
      print(safeBool)
}

guard let safeString = someString,
      let safeInt = someInt, 
      let safeBool = someBool {
         //This will be hit if a value is null
      return
}

//However notice the scope is available outside of the guard statement, 
//meaning you can safely use the values now without them being contained
//to an if statement. Despite this example, they would never be hit.
print(safeString)
print(safeInt)
print(safeBool)