enum PostType: Decodable {
init(from decoder: Decoder) throws {
// What do i put here?
}
case Image
enum CodingKeys: String, CodingKey {
case image
}
}
これを完了するために私は何を置きますか?また、case
name__をこれに変更したとします。
case image(value: Int)
これをデコード可能にするにはどうすればよいですか。
EDitこれが私のフルコードです(これはうまくいきません)。
let jsonData = """
{
"count": 4
}
""".data(using: .utf8)!
do {
let decoder = JSONDecoder()
let response = try decoder.decode(PostType.self, from: jsonData)
print(response)
} catch {
print(error)
}
}
}
enum PostType: Int, Codable {
case count = 4
}
Final Editまた、このような列挙型はどのように処理されるのでしょうか。
enum PostType: Decodable {
case count(number: Int)
}
暗黙のうちに割り当てられているString
またはInt
の生の値を使用するだけです。
enum PostType: Int, Codable {
case image, blob
}
image
は0
に、blob
は1
にエンコードされています
または
enum PostType: String, Codable {
case image, blob
}
image
は"image"
に、blob
は"blob"
にエンコードされています
これは使い方の簡単な例です:
enum PostType : Int, Codable {
case count = 4
}
struct Post : Codable {
var type : PostType
}
let jsonString = "{\"type\": 4}"
let jsonData = Data(jsonString.utf8)
do {
let decoded = try JSONDecoder().decode(Post.self, from: jsonData)
print("decoded:", decoded.type)
} catch {
print(error)
}
Codable
に準拠させる方法この答えは@Howard Lovattのものに似ていますが、PostTypeCodableForm
構造体の作成を避け、代わりにKeyedEncodingContainer
およびEncoder
のプロパティとしてDecoder
型 Apple提供 を使用しています。
enum PostType: Codable {
case count(number: Int)
case title(String)
}
extension PostType {
private enum CodingKeys: String, CodingKey {
case count
case title
}
enum PostTypeCodingError: Error {
case decoding(String)
}
init(from decoder: Decoder) throws {
let values = try decoder.container(keyedBy: CodingKeys.self)
if let value = try? values.decode(Int.self, forKey: .count) {
self = .count(number: value)
return
}
if let value = try? values.decode(String.self, forKey: .title) {
self = .title(value)
return
}
throw PostTypeCodingError.decoding("Whoops! \(dump(values))")
}
func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
switch self {
case .count(let number):
try container.encode(number, forKey: .count)
case .title(let value):
try container.encode(value, forKey: .title)
}
}
}
このコードは私のためにXcode 9b3で動作します。
import Foundation // Needed for JSONEncoder/JSONDecoder
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
let decoder = JSONDecoder()
let count = PostType.count(number: 42)
let countData = try encoder.encode(count)
let countJSON = String.init(data: countData, encoding: .utf8)!
print(countJSON)
// {
// "count" : 42
// }
let decodedCount = try decoder.decode(PostType.self, from: countData)
let title = PostType.title("Hello, World!")
let titleData = try encoder.encode(title)
let titleJSON = String.init(data: titleData, encoding: .utf8)!
print(titleJSON)
// {
// "title": "Hello, World!"
// }
let decodedTitle = try decoder.decode(PostType.self, from: titleData)
未知のenum値に遭遇した場合、Swiftは.dataCorrupted
エラーをスローします。あなたのデータがサーバから来ている場合、それはいつでもあなたに未知のenum値を送ることができます(バグサーバサイド、APIバージョンに追加された新しいタイプ、そしてあなたはあなたのアプリの以前のバージョンに適切にケースを処理させたい、など)。 enumを安全にデコードするには、準備して「防御スタイル」をコーディングしてください。
関連する値の有無にかかわらず、これを行う方法の例を示します
enum MediaType: Decodable {
case audio
case multipleChoice
case other
// case other(String) -> we could also parametrise the enum like that
init(from decoder: Decoder) throws {
let label = try decoder.singleValueContainer().decode(String.self)
switch label {
case "AUDIO": self = .audio
case "MULTIPLE_CHOICES": self = .multipleChoice
default: self = .other
// default: self = .other(label)
}
}
}
そして囲む構造体でそれを使う方法:
struct Question {
[...]
let type: MediaType
enum CodingKeys: String, CodingKey {
[...]
case type = "type"
}
extension Question: Decodable {
init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
[...]
type = try container.decode(MediaType.self, forKey: .type)
}
}
@ Tokaの答えを拡張するには、生の表現可能な値を列挙に追加し、デフォルトのオプションのコンストラクタを使用してswitch
なしで列挙を構築することもできます。
enum MediaType: String, Decodable {
case audio = "AUDIO"
case multipleChoice = "MULTIPLE_CHOICES"
case other
init(from decoder: Decoder) throws {
let label = try decoder.singleValueContainer().decode(String.self)
self = MediaType(rawValue: label) ?? .other
}
}
コンストラクタをリファクタリングすることを可能にするカスタムプロトコルを使用して拡張することができます。
protocol EnumDecodable: RawRepresentable, Decodable {
static var defaultDecoderValue: Self { get }
}
extension EnumDecodable where RawValue: Decodable {
init(from decoder: Decoder) throws {
let value = try decoder.singleValueContainer().decode(RawValue.self)
self = Self(rawValue: value) ?? Self.defaultDecoderValue
}
}
enum MediaType: String, EnumDecodable {
static let defaultDecoderValue: MediaType = .other
case audio = "AUDIO"
case multipleChoices = "MULTIPLE_CHOICES"
case other
}
無効なenum値が指定された場合、値をデフォルトにするのではなく、エラーをスローするように簡単に拡張することもできます。この変更の要旨はこちらから入手できます。 https://Gist.github.com/stephanecopin/4283175fabf6f0cdaf87fef2a00c8128 。
コードはSwift 4.1/Xcode 9.3を使用してコンパイルおよびテストされました。
より簡潔な@ proxperoの応答の変形は、デコーダを次のように定式化することです。
public init(from decoder: Decoder) throws {
let values = try decoder.container(keyedBy: CodingKeys.self)
guard let key = values.allKeys.first else { throw err("No valid keys in: \(values)") }
func dec<T: Decodable>() throws -> T { return try values.decode(T.self, forKey: key) }
switch key {
case .count: self = try .count(dec())
case .title: self = try .title(dec())
}
}
func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
switch self {
case .count(let x): try container.encode(x, forKey: .count)
case .title(let x): try container.encode(x, forKey: .title)
}
}
これにより、コンパイラはケースを徹底的に検証できます。また、エンコードされた値がキーの期待値と一致しない場合のエラーメッセージも抑制されません。
あなたはあなたが望むことをすることができますが、それは少し複雑です:(
import Foundation
enum PostType: Codable {
case count(number: Int)
case comment(text: String)
init(from decoder: Decoder) throws {
self = try PostTypeCodableForm(from: decoder).enumForm()
}
func encode(to encoder: Encoder) throws {
try PostTypeCodableForm(self).encode(to: encoder)
}
}
struct PostTypeCodableForm: Codable {
// All fields must be optional!
var countNumber: Int?
var commentText: String?
init(_ enumForm: PostType) {
switch enumForm {
case .count(let number):
countNumber = number
case .comment(let text):
commentText = text
}
}
func enumForm() throws -> PostType {
if let number = countNumber {
guard commentText == nil else {
throw DecodeError.moreThanOneEnumCase
}
return .count(number: number)
}
if let text = commentText {
guard countNumber == nil else {
throw DecodeError.moreThanOneEnumCase
}
return .comment(text: text)
}
throw DecodeError.noRecognizedContent
}
enum DecodeError: Error {
case noRecognizedContent
case moreThanOneEnumCase
}
}
let test = PostType.count(number: 3)
let data = try JSONEncoder().encode(test)
let string = String(data: data, encoding: .utf8)!
print(string) // {"countNumber":3}
let result = try JSONDecoder().decode(PostType.self, from: data)
print(result) // count(3)
実際には上記の答えは本当に素晴らしいですが、彼らは継続的に開発されたクライアント/サーバープロジェクトで多くの人々が必要とするもののためのいくつかの詳細を欠いています。バックエンドは継続的に進化しながらアプリを開発します。つまり、いくつかのenumケースがその進化を変えることになります。そのため、未知のケースを含むenumの配列をデコードできるenumデコード戦略が必要です。そうでなければ、その配列を含むオブジェクトのデコードは単に失敗します。
私がしたことは非常に簡単です:
enum Direction: String, Decodable {
case north, south, east, west
}
struct DirectionList {
let directions: [Direction]
}
extension DirectionList: Decodable {
public init(from decoder: Decoder) throws {
var container = try decoder.unkeyedContainer()
var directions: [Direction] = []
while !container.isAtEnd {
// Here we just decode the string from the JSON which always works as long as the array element is a string
let rawValue = try container.decode(String.self)
guard let direction = Direction(rawValue: rawValue) else {
// Unknown enum value found - ignore, print error to console or log error to analytics service so you'll always know that there are apps out which cannot decode enum cases!
continue
}
// Add all known enum cases to the list of directions
directions.append(direction)
}
self.directions = directions
}
}
ボーナス:実装を隠す>コレクションにする
実装の詳細を隠すことは常に良い考えです。これには、もう少しコードが必要です。トリックはDirectionsList
をCollection
に適合させ、内部のlist
配列を非公開にすることです。
struct DirectionList {
typealias ArrayType = [Direction]
private let directions: ArrayType
}
extension DirectionList: Collection {
typealias Index = ArrayType.Index
typealias Element = ArrayType.Element
// The upper and lower bounds of the collection, used in iterations
var startIndex: Index { return directions.startIndex }
var endIndex: Index { return directions.endIndex }
// Required subscript, based on a dictionary index
subscript(index: Index) -> Element {
get { return directions[index] }
}
// Method that returns the next index when iterating
func index(after i: Index) -> Index {
return directions.index(after: i)
}
}
John Sundellによるこのブログ投稿のカスタムコレクションへの準拠についての詳細を読むことができます: https://medium.com/@johnsundell/creating-custom-collections-in-Swift-a344e25d0bb