L'index du dictionnaire [Swift] peut soudainement devenir invalide

Le Dictionary de Swift a un indice appelé ʻIndex`. Obtenez-le simplement comme ceci:

let key: Key = Key(hoge)
let dictionary: [Key: Value] = [key: Value(fuga)]
let index: [Key: Value].Index? = dictionary.index(forKey: key)

En utilisant l '«index» obtenu de cette manière,

if let index = index, let value = dictionary[index]{
   print(value) //Value(fuga)
}

Et vous pouvez facilement accéder aux éléments.

Je ne sais pas ce qui me rend heureux avec cela seul, mais par exemple, si «Key» est grand, il semble qu'il vaut mieux sauvegarder «Index».

struct Key: Hashable{
    let key0: String
    let key1: String
    let key2: String
    let key3: String
    let key4: String

    func hash(into hasher: inout Hasher) {
        self.key0.hash(into: &hasher)
        self.key1.hash(into: &hasher)
        self.key2.hash(into: &hasher)
        self.key3.hash(into: &hasher)
        self.key4.hash(into: &hasher)
    }
}

print(MemoryLayout<Key>.size)                          //80
print(MemoryLayout<Dictionary<Key, Int>.Index>.size)   //17

Cependant, lorsque j'ai écrit le code pour enregistrer «Index» et l'ai déplacé comme ceci, un crash mystérieux s'est produit. Peu importe à quel point j'ai levé les yeux, «Index» n'était pas faux et j'étais inquiet pendant un moment, mais la réponse était inscrite dans le document.

https://developer.apple.com/documentation/swift/dictionary

Dit

A dictionary’s indices stay valid across additions to the dictionary as long as the dictionary has enough capacity to store the added values without allocating more buffer. When a dictionary outgrows its buffer, existing indices may be invalidated without any notification. When you know how many new values you’re adding to a dictionary, use the init(minimumCapacity:) initializer to allocate the correct amount of buffer.

(Japonais)

Les indices de dictionnaire restent valides lorsque vous ajoutez des valeurs au dictionnaire, tant que vous disposez de suffisamment d'espace pour ajouter de nouvelles valeurs sans allouer de nouveaux tampons. Si le tampon est insuffisant (en raison d'une nouvelle allocation), les indices précédents seront invalides sans préavis. Si vous savez combien de valeurs ajouter, initialisez-les avec ʻinit (minimumCapacity :) `pour obtenir le tampon requis.

La cause était que j'ajoutais / supprimais des valeurs dans le dictionnaire plus tard.

Conclusion

Il semble donc que vous ne devriez écrire du code qui stocke les indices du dictionnaire que s'il n'y a aucune possibilité d'ajouter ou de supprimer des valeurs du dictionnaire. Je ne pense pas qu'il y ait une telle scène.

D'une manière ou d'une autre, j'ai écrit le code en supposant que Dictionary.Index semble être immuable, et j'en suis tombé amoureux. Si vous y réfléchissez bien, même les indices du tableau sont soudainement invalidés par insertion ou suppression, il est donc plutôt étrange qu'il ne soit pas invalidé.