반응형
Swift 4 디코딩 가능한 프로토콜에서 JSON 사전 유형으로 속성을 디코딩하는 방법
고객 개체에 JSON 사전을 포함 할 수 Customer있는 metadata속성을 포함하는 데이터 유형이 있다고 가정 해 보겠습니다.
struct Customer {
let id: String
let email: String
let metadata: [String: Any]
}
{
"object": "customer",
"id": "4yq6txdpfadhbaqnwp3",
"email": "john.doe@example.com",
"metadata": {
"link_id": "linked-id",
"buy_count": 4
}
}
metadata속성은 임의의 JSON 맵 오브젝트가 될 수 있습니다.
deserialized JSON에서 속성을 캐스팅하기 전에 NSJSONDeserialization새로운 Swift 4 Decodable프로토콜을 사용하면 여전히 그렇게 할 방법을 생각할 수 없습니다.
Decodable 프로토콜로 Swift 4에서 이것을 달성하는 방법을 아는 사람이 있습니까?
내가 찾은 이 요점 에서 영감을 얻어 UnkeyedDecodingContainer및에 대한 확장을 작성했습니다 KeyedDecodingContainer. 여기 에서 내 요점에 대한 링크를 찾을 수 있습니다 . 이제이 코드를 사용 하여 익숙한 구문으로 Array<Any>또는 모든 것을 디코딩 할 수 있습니다 Dictionary<String, Any>.
let dictionary: [String: Any] = try container.decode([String: Any].self, forKey: key)
또는
let array: [Any] = try container.decode([Any].self, forKey: key)
편집 : 사전 배열을 디코딩하는 한 가지주의 사항 [[String: Any]]이 있습니다. 필요한 구문은 다음과 같습니다. 강제 캐스팅 대신 오류를 던지고 싶을 것입니다.
let items: [[String: Any]] = try container.decode(Array<Any>.self, forKey: .items) as! [[String: Any]]
편집 2 : 단순히 전체 파일을 사전으로 변환하려는 경우 JSONDecoder 자체를 확장하여 사전을 직접 디코딩하는 방법을 찾지 못했기 때문에 JSONSerialization의 api를 사용하는 것이 좋습니다.
guard let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] else {
// appropriate error handling
return
}
확장
// Inspired by https://gist.github.com/mbuchetics/c9bc6c22033014aa0c550d3b4324411a
struct JSONCodingKeys: CodingKey {
var stringValue: String
init?(stringValue: String) {
self.stringValue = stringValue
}
var intValue: Int?
init?(intValue: Int) {
self.init(stringValue: "\(intValue)")
self.intValue = intValue
}
}
extension KeyedDecodingContainer {
func decode(_ type: Dictionary<String, Any>.Type, forKey key: K) throws -> Dictionary<String, Any> {
let container = try self.nestedContainer(keyedBy: JSONCodingKeys.self, forKey: key)
return try container.decode(type)
}
func decodeIfPresent(_ type: Dictionary<String, Any>.Type, forKey key: K) throws -> Dictionary<String, Any>? {
guard contains(key) else {
return nil
}
guard try decodeNil(forKey: key) == false else {
return nil
}
return try decode(type, forKey: key)
}
func decode(_ type: Array<Any>.Type, forKey key: K) throws -> Array<Any> {
var container = try self.nestedUnkeyedContainer(forKey: key)
return try container.decode(type)
}
func decodeIfPresent(_ type: Array<Any>.Type, forKey key: K) throws -> Array<Any>? {
guard contains(key) else {
return nil
}
guard try decodeNil(forKey: key) == false else {
return nil
}
return try decode(type, forKey: key)
}
func decode(_ type: Dictionary<String, Any>.Type) throws -> Dictionary<String, Any> {
var dictionary = Dictionary<String, Any>()
for key in allKeys {
if let boolValue = try? decode(Bool.self, forKey: key) {
dictionary[key.stringValue] = boolValue
} else if let stringValue = try? decode(String.self, forKey: key) {
dictionary[key.stringValue] = stringValue
} else if let intValue = try? decode(Int.self, forKey: key) {
dictionary[key.stringValue] = intValue
} else if let doubleValue = try? decode(Double.self, forKey: key) {
dictionary[key.stringValue] = doubleValue
} else if let nestedDictionary = try? decode(Dictionary<String, Any>.self, forKey: key) {
dictionary[key.stringValue] = nestedDictionary
} else if let nestedArray = try? decode(Array<Any>.self, forKey: key) {
dictionary[key.stringValue] = nestedArray
}
}
return dictionary
}
}
extension UnkeyedDecodingContainer {
mutating func decode(_ type: Array<Any>.Type) throws -> Array<Any> {
var array: [Any] = []
while isAtEnd == false {
// See if the current value in the JSON array is `null` first and prevent infite recursion with nested arrays.
if try decodeNil() {
continue
} else if let value = try? decode(Bool.self) {
array.append(value)
} else if let value = try? decode(Double.self) {
array.append(value)
} else if let value = try? decode(String.self) {
array.append(value)
} else if let nestedDictionary = try? decode(Dictionary<String, Any>.self) {
array.append(nestedDictionary)
} else if let nestedArray = try? decode(Array<Any>.self) {
array.append(nestedArray)
}
}
return array
}
mutating func decode(_ type: Dictionary<String, Any>.Type) throws -> Dictionary<String, Any> {
let nestedContainer = try self.nestedContainer(keyedBy: JSONCodingKeys.self)
return try nestedContainer.decode(type)
}
}
나도이 문제를 가지고 놀았고 마침내 "일반 JSON"유형으로 작업하기위한 간단한 라이브러리를 작성했습니다 . (여기서 "일반"은 "사전에 알려진 구조 없음"을 의미합니다.) 요점은 구체적인 유형으로 일반 JSON을 나타내는 것입니다.
public enum JSON {
case string(String)
case number(Float)
case object([String:JSON])
case array([JSON])
case bool(Bool)
case null
}
그런 다음이 유형은 Codable및 Equatable.
Codable프로토콜 을 확인하는 메타 데이터 구조체 Decodable를 생성 하고 클래스를 사용하여 아래와 같이 객체를 생성 할 수 있습니다.
let json: [String: Any] = [
"object": "customer",
"id": "4yq6txdpfadhbaqnwp3",
"email": "john.doe@example.com",
"metadata": [
"link_id": "linked-id",
"buy_count": 4
]
]
struct Customer: Codable {
let object: String
let id: String
let email: String
let metadata: Metadata
}
struct Metadata: Codable {
let link_id: String
let buy_count: Int
}
let data = try JSONSerialization.data(withJSONObject: json, options: .prettyPrinted)
let decoder = JSONDecoder()
do {
let customer = try decoder.decode(Customer.self, from: data)
print(customer)
} catch {
print(error.localizedDescription)
}
나는 약간 다른 해결책을 가지고 왔습니다.
[String: Any]Any가 배열, 중첩 된 사전 또는 배열의 사전 일 수 있다는 단순한 구문 분석 이상의 무언가가 있다고 가정 해 보겠습니다 .
이 같은:
var json = """
{
"id": 12345,
"name": "Giuseppe",
"last_name": "Lanza",
"age": 31,
"happy": true,
"rate": 1.5,
"classes": ["maths", "phisics"],
"dogs": [
{
"name": "Gala",
"age": 1
}, {
"name": "Aria",
"age": 3
}
]
}
"""
글쎄, 이것이 내 해결책입니다.
public struct AnyDecodable: Decodable {
public var value: Any
private struct CodingKeys: CodingKey {
var stringValue: String
var intValue: Int?
init?(intValue: Int) {
self.stringValue = "\(intValue)"
self.intValue = intValue
}
init?(stringValue: String) { self.stringValue = stringValue }
}
public init(from decoder: Decoder) throws {
if let container = try? decoder.container(keyedBy: CodingKeys.self) {
var result = [String: Any]()
try container.allKeys.forEach { (key) throws in
result[key.stringValue] = try container.decode(AnyDecodable.self, forKey: key).value
}
value = result
} else if var container = try? decoder.unkeyedContainer() {
var result = [Any]()
while !container.isAtEnd {
result.append(try container.decode(AnyDecodable.self).value)
}
value = result
} else if let container = try? decoder.singleValueContainer() {
if let intVal = try? container.decode(Int.self) {
value = intVal
} else if let doubleVal = try? container.decode(Double.self) {
value = doubleVal
} else if let boolVal = try? container.decode(Bool.self) {
value = boolVal
} else if let stringVal = try? container.decode(String.self) {
value = stringVal
} else {
throw DecodingError.dataCorruptedError(in: container, debugDescription: "the container contains nothing serialisable")
}
} else {
throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not serialise"))
}
}
}
사용해보십시오
let stud = try! JSONDecoder().decode(AnyDecodable.self, from: jsonData).value as! [String: Any]
print(stud)
이전 답변을 찾았을 때 간단한 JSON 객체 케이스 만 테스트했지만 @slurmomatic 및 @zoul과 같은 런타임 예외가 발생하는 빈 케이스는 테스트하지 않았습니다. 이 문제로 죄송합니다.
그래서 간단한 JSONValue 프로토콜을 사용하여 다른 방법을 시도하고 AnyJSONValue유형 삭제 구조체를 구현하고 대신 해당 유형을 사용합니다 Any. 다음은 구현입니다.
public protocol JSONType: Decodable {
var jsonValue: Any { get }
}
extension Int: JSONType {
public var jsonValue: Any { return self }
}
extension String: JSONType {
public var jsonValue: Any { return self }
}
extension Double: JSONType {
public var jsonValue: Any { return self }
}
extension Bool: JSONType {
public var jsonValue: Any { return self }
}
public struct AnyJSONType: JSONType {
public let jsonValue: Any
public init(from decoder: Decoder) throws {
let container = try decoder.singleValueContainer()
if let intValue = try? container.decode(Int.self) {
jsonValue = intValue
} else if let stringValue = try? container.decode(String.self) {
jsonValue = stringValue
} else if let boolValue = try? container.decode(Bool.self) {
jsonValue = boolValue
} else if let doubleValue = try? container.decode(Double.self) {
jsonValue = doubleValue
} else if let doubleValue = try? container.decode(Array<AnyJSONType>.self) {
jsonValue = doubleValue
} else if let doubleValue = try? container.decode(Dictionary<String, AnyJSONType>.self) {
jsonValue = doubleValue
} else {
throw DecodingError.typeMismatch(JSONType.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Unsupported JSON tyep"))
}
}
}
디코딩 할 때 사용하는 방법은 다음과 같습니다.
metadata = try container.decode ([String: AnyJSONValue].self, forKey: .metadata)
이 문제의 문제는 value.jsonValue as? Int. 우리 Conditional Conformance는 Swift에 착륙 할 때까지 기다려야 합니다. 그러면이 문제가 해결되거나 적어도 더 나아질 수 있습니다.
[이전 답변]
이 질문을 Apple Developer 포럼에 게시했는데 매우 쉽습니다.
내가 할 수있는
metadata = try container.decode ([String: Any].self, forKey: .metadata)
이니셜 라이저에서.
애초에 그것을 놓친 것은 내 잘못이었습니다.
당신이 사용하는 경우 SwiftyJSON를 JSON을 구문 분석, 당신은 업데이트 할 수 있습니다 4.1.0 이 Codable프로토콜 지원합니다. 선언 만하면 metadata: JSON모든 준비가 완료됩니다.
import SwiftyJSON
struct Customer {
let id: String
let email: String
let metadata: JSON
}
import BeyovaJSON
struct Customer: Codable {
let id: String
let email: String
let metadata: JToken
}
//create a customer instance
customer.metadata = ["link_id": "linked-id","buy_count": 4]
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
print(String(bytes: try! encoder.encode(customer), encoding: .utf8)!)
가장 쉽고 제안되는 방법은 JSON 형식의 각 사전 또는 모델에 대해 별도의 모델 을 만드는 것입니다 .
여기 내가하는 일
//Model for dictionary **Metadata**
struct Metadata: Codable {
var link_id: String?
var buy_count: Int?
}
//Model for dictionary **Customer**
struct Customer: Codable {
var object: String?
var id: String?
var email: String?
var metadata: Metadata?
}
//Here is our decodable parser that decodes JSON into expected model
struct CustomerParser {
var customer: Customer?
}
extension CustomerParser: Decodable {
//keys that matches exactly with JSON
enum CustomerKeys: String, CodingKey {
case object = "object"
case id = "id"
case email = "email"
case metadata = "metadata"
}
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CustomerKeys.self) // defining our (keyed) container
let object: String = try container.decode(String.self, forKey: .object) // extracting the data
let id: String = try container.decode(String.self, forKey: .id) // extracting the data
let email: String = try container.decode(String.self, forKey: .email) // extracting the data
//Here I have used metadata model instead of dictionary [String: Any]
let metadata: Metadata = try container.decode(Metadata.self, forKey: .metadata) // extracting the data
self.init(customer: Customer(object: object, id: id, email: email, metadata: metadata))
}
}
용법:
if let url = Bundle.main.url(forResource: "customer-json-file", withExtension: "json") {
do {
let jsonData: Data = try Data(contentsOf: url)
let parser: CustomerParser = try JSONDecoder().decode(CustomerParser.self, from: jsonData)
print(parser.customer ?? "null")
} catch {
}
}
** 파싱하는 동안 안전한쪽에 있도록 선택 사항을 사용했으며 필요에 따라 변경할 수 있습니다.
나는 디코딩 +는 인코딩 방법을 용이하게 포드를 만들었습니다 [String: Any], [Any]. 그리고 이것은 여기 https://github.com/levantAJ/AnyCodable 에서 선택적 속성을 인코딩하거나 디코딩합니다.
pod 'DynamicCodable', '1.0'
사용 방법:
import DynamicCodable
struct YourObject: Codable {
var dict: [String: Any]
var array: [Any]
var optionalDict: [String: Any]?
var optionalArray: [Any]?
enum CodingKeys: String, CodingKey {
case dict
case array
case optionalDict
case optionalArray
}
init(from decoder: Decoder) throws {
let values = try decoder.container(keyedBy: CodingKeys.self)
dict = try values.decode([String: Any].self, forKey: .dict)
array = try values.decode([Any].self, forKey: .array)
optionalDict = try values.decodeIfPresent([String: Any].self, forKey: .optionalDict)
optionalArray = try values.decodeIfPresent([Any].self, forKey: .optionalArray)
}
func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
try container.encode(dict, forKey: .dict)
try container.encode(array, forKey: .array)
try container.encodeIfPresent(optionalDict, forKey: .optionalDict)
try container.encodeIfPresent(optionalArray, forKey: .optionalArray)
}
}
여기에 더 일반적인 (뿐만 아니라 [String: Any],하지만 [Any]디코딩 할 수 있습니다) 및 @loudmouth 대답에서 영감을 (별도의 엔티티가 사용됩니다) 접근 방식을 캡슐화.
그것을 사용하면 다음과 같이 보일 것입니다.
extension Customer: Decodable {
public init(from decoder: Decoder) throws {
let selfContainer = try decoder.container(keyedBy: CodingKeys.self)
id = try selfContainer.decode(.id)
email = try selfContainer.decode(.email)
let metadataContainer: JsonContainer = try selfContainer.decode(.metadata)
guard let metadata = metadataContainer.value as? [String: Any] else {
let context = DecodingError.Context(codingPath: [CodingKeys.metadata], debugDescription: "Expected '[String: Any]' for 'metadata' key")
throw DecodingError.typeMismatch([String: Any].self, context)
}
self.metadata = metadata
}
private enum CodingKeys: String, CodingKey {
case id, email, metadata
}
}
JsonContainer확장하지 않고 JSON 데이터를 JSON 객체 (배열 또는 사전)로 디코딩하는 데 사용하는 도우미 엔티티입니다 *DecodingContainer(따라서 JSON 객체가를 의미하지 않는 드문 경우를 방해하지 않습니다 [String: Any]).
struct JsonContainer {
let value: Any
}
extension JsonContainer: Decodable {
public init(from decoder: Decoder) throws {
if let keyedContainer = try? decoder.container(keyedBy: Key.self) {
var dictionary = [String: Any]()
for key in keyedContainer.allKeys {
if let value = try? keyedContainer.decode(Bool.self, forKey: key) {
// Wrapping numeric and boolean types in `NSNumber` is important, so `as? Int64` or `as? Float` casts will work
dictionary[key.stringValue] = NSNumber(value: value)
} else if let value = try? keyedContainer.decode(Int64.self, forKey: key) {
dictionary[key.stringValue] = NSNumber(value: value)
} else if let value = try? keyedContainer.decode(Double.self, forKey: key) {
dictionary[key.stringValue] = NSNumber(value: value)
} else if let value = try? keyedContainer.decode(String.self, forKey: key) {
dictionary[key.stringValue] = value
} else if (try? keyedContainer.decodeNil(forKey: key)) ?? false {
// NOP
} else if let value = try? keyedContainer.decode(JsonContainer.self, forKey: key) {
dictionary[key.stringValue] = value.value
} else {
throw DecodingError.dataCorruptedError(forKey: key, in: keyedContainer, debugDescription: "Unexpected value for \(key.stringValue) key")
}
}
value = dictionary
} else if var unkeyedContainer = try? decoder.unkeyedContainer() {
var array = [Any]()
while !unkeyedContainer.isAtEnd {
let container = try unkeyedContainer.decode(JsonContainer.self)
array.append(container.value)
}
value = array
} else if let singleValueContainer = try? decoder.singleValueContainer() {
if let value = try? singleValueContainer.decode(Bool.self) {
self.value = NSNumber(value: value)
} else if let value = try? singleValueContainer.decode(Int64.self) {
self.value = NSNumber(value: value)
} else if let value = try? singleValueContainer.decode(Double.self) {
self.value = NSNumber(value: value)
} else if let value = try? singleValueContainer.decode(String.self) {
self.value = value
} else if singleValueContainer.decodeNil() {
value = NSNull()
} else {
throw DecodingError.dataCorruptedError(in: singleValueContainer, debugDescription: "Unexpected value")
}
} else {
let context = DecodingError.Context(codingPath: [], debugDescription: "Invalid data format for JSON")
throw DecodingError.dataCorrupted(context)
}
}
private struct Key: CodingKey {
var stringValue: String
init?(stringValue: String) {
self.stringValue = stringValue
}
var intValue: Int?
init?(intValue: Int) {
self.init(stringValue: "\(intValue)")
self.intValue = intValue
}
}
}
숫자 및 부울 유형은에서 지원되며 NSNumber, 그렇지 않으면 다음과 같이 작동하지 않습니다.
if customer.metadata["keyForInt"] as? Int64 { // as it always will be nil
extension ViewController {
func swiftyJson(){
let url = URL(string: "https://itunes.apple.com/search?term=jack+johnson")
//let url = URL(string: "http://makani.bitstaging.in/api/business/businesses_list")
Alamofire.request(url!, method: .get, parameters: nil).responseJSON { response in
var arrayIndexes = [IndexPath]()
switch(response.result) {
case .success(_):
let data = response.result.value as! [String : Any]
if let responseData = Mapper<DataModel>().map(JSON: data) {
if responseData.results!.count > 0{
self.arrayExploreStylistList = []
}
for i in 0..<responseData.results!.count{
arrayIndexes.append(IndexPath(row: self.arrayExploreStylistList.count + i, section: 0))
}
self.arrayExploreStylistList.append(contentsOf: responseData.results!)
print(arrayIndexes.count)
}
// if let arrNew = data["results"] as? [[String : Any]]{
// let jobData = Mapper<DataModel>().mapArray(JSONArray: arrNew)
// print(jobData)
// self.datamodel = jobData
// }
self.tblView.reloadData()
break
case .failure(_):
print(response.result.error as Any)
break
}
}
}
}
원하는 것은의 디자인에 위배 Codable됩니다. 기본 개념 Codable은 형식이 안전한 방식으로 데이터를 보관 및 보관 취소하는 메커니즘을 제공하는 것입니다. 즉, 사전에 속성과 해당 데이터 유형을 정의해야합니다. 나는 당신의 문제에 대한 두 가지 해결책을 생각할 수 있습니다.
1. 모든 잠재적 메타 데이터 키 나열
종종 API 문서에 충분히 깊이 도달하면 모든 잠재적 메타 데이터 키의 전체 목록을 찾을 수 있습니다. Metadata다음 키를 선택적 속성으로 사용 하여 구조체를 정의 합니다.
struct Customer: Decodable {
struct Metadata: Decodable {
var linkId: String?
var buyCount: Int?
var somethingElse: Int?
private enum CodingKeys: String, CodingKey {
case linkId = "link_id"
case buyCount = "buy_count"
case somethingElse = "something_else"
}
}
var object: String
var id: String
var email: String
var metadata: Metadata
}
let customer = try! JSONDecoder().decode(Customer.self, from: jsonData)
print(customer.metadata)
저는 Swift 디자이너들이이 접근 방식을 선호했을 것임을 알 수 있습니다.
2. Decodable 및 JSONSerialization 결합
JSONSerialization형식 안전에 대한 절충안에서 큰 역 동성을 제공합니다. Decodable디자인 철학이 정반대 인와 확실히 혼동 할 수 있습니다 .
struct Customer {
private struct RawCustomer: Decodable {
var object: String
var id: String
var email: String
}
var object: String
var id: String
var email: String
var metadata: [String: AnyObject]
init(jsonData: Data) throws {
let rawCustomer = try JSONDecoder().decode(RawCustomer.self, from: jsonData)
object = rawCustomer.object
id = rawCustomer.id
email = rawCustomer.email
let jsonObject = try JSONSerialization.jsonObject(with: jsonData)
if let dict = jsonObject as? [String: AnyObject],
let metadata = dict["metadata"] as? [String: AnyObject]
{
self.metadata = metadata
} else {
self.metadata = [String: AnyObject]()
}
}
}
let customer = try! Customer(jsonData: jsonData)
print(customer.metadata)
반응형
'Programing' 카테고리의 다른 글
| 시작하기 : Node.js 용 데이터베이스 설정 (0) | 2020.09.25 |
|---|---|
| scrollIntoView는 모든 브라우저에서 작동합니까? (0) | 2020.09.25 |
| 사용자의 브라우저가 표시 할 수있는 모든 글꼴 나열 (0) | 2020.09.25 |
| npm : "0.1"버전이 잘못된 이유는 무엇입니까? (0) | 2020.09.25 |
| Django에서 이메일 주소를 사용자 이름으로 수락 (0) | 2020.09.25 |