Avertissement Xcode: la propriété immuable ne sera pas décodée car elle est déclarée avec une valeur initiale qui ne peut pas être écrasée

Cet avertissement apparaît parce que les propriétés immuables avec des valeurs initiales ne participent pas au décodage - après tout, elles sont immuables et ont une valeur initiale, ce qui signifie que la valeur initiale ne sera jamais modifiée.

Par exemple, considérez ce code:

let json = """
{}
"""
let decoder = JSONDecoder()

struct VarModel: Decodable {
    var value: String = "1"
}

let varModel = try! decoder.decode(VarModel.self, from: json.data(using: .utf8)!)

Cela affichera en fait le Model(value: "1") , même si le json que nous lui avons donné avait la value "2" .

En fait, vous n'avez même pas besoin de fournir la valeur des données que vous décodez, car elles ont de toute façon une valeur initiale!

struct VarModel: Decodable {
    var value: String = "1"
}
let json = """
{"value": "2"}
"""
let varModel = try! decoder.decode(VarModel.self, from: json.data(using: .utf8)!)
print(varModel) // "VarModel(value: "2")"

Changer la valeur en var signifie qu'il décodera correctement:

let json = """
{}
"""
let decoder = JSONDecoder()
let model = try! decoder.decode(Model.self, from: json.data(using: .utf8)!)
print(model) // prints "Model(value: "1")"

Si vous voyez cette erreur, cela signifie que votre code n'a jamais correctement analysé la propriété en question lors du décodage. Si vous le changez en var, la propriété sera analysée correctement, ce qui peut être ce que vous voulez - cependant, vous devez vous assurer que les données que vous décodez ont toujours ce jeu de clés. Par exemple, cela lèvera une exception (et plantera puisque nous utilisons try! ):

struct Model: Decodable {
    let value: String = "1"
}

let json = """
{"value": "2"}
"""
let decoder = JSONDecoder()
let model = try! decoder.decode(Model.self, from: json.data(using: .utf8)!)
print(model)

En conclusion, la suggestion de Xcode est probablement viable dans de nombreux cas, mais vous devez évaluer au cas par cas si le changement de la propriété en var cassera la fonctionnalité de votre application.

Si vous souhaitez que la propriété renvoie toujours la valeur initiale codée en dur (ce qui se passe actuellement), envisagez d'en faire une propriété calculée ou une variable différée.

L'explication de Noé est correcte. C'est une source courante de bogues et ce qui se passe n'est pas immédiatement évident en raison du comportement «magique» de la synthèse Codable, c'est pourquoi j'ai ajouté cet avertissement au compilateur, car il attire votre attention sur le fait que la propriété ne sera pas décodée et vous oblige à l'appeler explicitement si c'est le comportement attendu.

Comme l'explique le correctif, vous avez quelques options si vous souhaitez désactiver cet avertissement - celui que vous choisissez dépend du comportement exact que vous souhaitez:

1. Passez la valeur initiale via un init :

struct ExampleItem: Decodable {
  let number: Int = 42
  
  private enum CodingKeys: CodingKey {}
}

Cela permettra au number d'être décodé, mais vous pouvez également transmettre des instances de ExampleItem où la valeur par défaut est utilisée.

Vous pouvez également l'utiliser directement dans init place, lors du décodage:

struct ExampleItem: Decodable {
  var number: Int = 42
}

Cela permettra au number d'être décodé, mais utilisez 42 comme valeur par défaut si le décodage échoue.

2. Faites de la propriété une var , bien que vous puissiez également en faire une private(set) var :

struct ExampleItem: Decodable {
  let number: Int
    
  private enum CodingKeys: String, CodingKey {
    case number
  }
    
  init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    number = try container.decodeIfPresent(Int.self, forKey: .number) ?? 42
  }
}

En faire un var permettra au number d'être décodé, mais cela permettra également aux appelants de le modifier. En le marquant plutôt comme private(set) var , vous pouvez l'interdire si vous le souhaitez.

3. Définissez une énumération CodingKeys explicite:

struct ExampleItem: Decodable {
  let number: Int
    
  init(number: Int = 42) {
    self.number = number
  }
}

Cela empêchera le décodage du number . Étant donné que l'énumération n'a pas de cas, cela indique clairement au compilateur qu'il n'y a aucune propriété que vous souhaitez décoder.

Solution: définissez une énumération CodingKeys explicite pour empêcher le décodage de l' id . Par exemple,

struct Course: Identifiable, Decodable {
  let id = UUID()
  let name: String

  private enum CodingKeys: String, CodingKey {
    case name
  }
  
  init(name: String) { self.name = name }
  init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    let name = try container.decodeIfPresent(String.self, forKey: .name)
    self.name = name ?? "default-name"
  }
}