how to change value of dictionary of dictionary effectively and dynamically - ios

Question

If I have a dictionary "dic" like this:
{
"a": {
"b": Any
}
"c": {
"d": Any
}
}
If I want to change the value of key "b", I know I can do it like this:
dic["a"]["b"] = somethingNew
But If the key path is varible, how can I change the value according to the key path? is there some api like this:
dic.updateValueByKeyPath(path: ["a", "b"], updateValue: somethingNew)
Or the idea to achieve this purpose , thanks ~

Answer 1

I recently answered a Q&A that wanted to remove (rather than update) a nested value in a dictionary of nested dictionaries.
Remove nested key from dictionary
We can use a similar approach here: using a recursive method which visits your given key path by repeatedly attempting conversions of (sub-)dictionary values to [Key: Any] dictionaries themselves. The only restriction here is that the Key types much be the same for all dictionaries within the nested dictionary.
Implementation
Recursive "core" function updateValue(_:, inDict:, forKeyPath:) and public updateValue(_:, forKeyPath:) method form key paths on for [Key] (e.g. ["a", "b"] applied to your example):
/* general "key path" extension */
public extension Dictionary {
public mutating func updateValue(_ value: Value, forKeyPath keyPath: [Key])
-> Value? {
let (valInd, newDict) = updateValue(value, inDict: self,
forKeyPath: Array(keyPath.reversed()))
if let dict = newDict as? [Key: Value] { self = dict }
return valInd
}
fileprivate func updateValue(_ value: Value, inDict dict: [Key: Any],
forKeyPath keyPath: [Key]) -> (Value?, [Key: Any]) {
guard let key = keyPath.last else { return (value, dict) }
var dict = dict
if keyPath.count > 1, let subDict = dict[key] as? [Key: Any] {
let (val, newSubDict) = updateValue(value, inDict: subDict,
forKeyPath: Array(keyPath.dropLast()))
dict[key] = newSubDict
return (val, dict)
}
let val = dict.updateValue(value, forKey: key) as? Value
return (val, dict)
}
}
Less general public updateValue(_:, forKeyPath:) method (using the core function above) for keys that conforms to ExpressibleByStringLiteral; key paths on form my.key.path (e.g. "a.b" applied to your example):
/* String literal specific "key path" extension */
public extension Dictionary where Key: ExpressibleByStringLiteral {
public mutating func updateValue(_ value: Value, forKeyPath keyPath: String)
-> Value? {
let keyPathArr = keyPath.components(separatedBy: ".")
.reversed().flatMap { $0 as? Key }
if keyPathArr.isEmpty { return self.updateValue(value, forKey: "") }
let (valInd, newDict) = updateValue(value,
inDict: self, forKeyPath:keyPathArr)
if let dict = newDict as? [Key: Value] { self = dict }
return valInd
}
}
Example usage
We'll apply the methods above to the example from the linked thread.
var dict: [String: Any] = [
"countries": [
"japan": [
"capital": [
"name": "tokyo",
"lat": "35.6895",
"lon": "139.6917"
],
"language": "japanese"
]
],
"airports": [
"germany": ["FRA", "MUC", "HAM", "TXL"]
]
]
Using the ExpressibleByStringLiteral key path method to update the value of an existing key-value pair:
if let oldValue = dict.updateValue("nihongo",
forKeyPath: "countries.japan.language") {
print("Removed old value: ", oldValue)
}
else {
print("Added new key-value pair")
}
print(dict)
/* Removed old value: japanese
[
"countries": [
"japan": [
"capital": [
"name": "tokyo",
"lon": "139.6917"
],
"language": "nihongo"
]
],
"airports": [
"germany": ["FRA", "MUC", "HAM", "TXL"]
]
] */
The same method used to add a new key-value pair at a given key path dictionary:
if let oldValue = dict.updateValue("asia",
forKeyPath: "countries.japan.continent") {
print("Removed old value: ", oldValue)
}
else {
print("Added new key-value pair")
}
print(dict)
/* Added new key-value pair
[
"countries": [
"japan": [
"capital": [
"name": "tokyo",
"lon": "139.6917"
],
"language": "nihongo",
"continent": "asia"
]
],
"airports": [
"germany": ["FRA", "MUC", "HAM", "TXL"]
]
] */
We would get the same result as in the examples above if we used the general [Key] as key path method instead of the ExpressibleByStringLiteral one used above. Using the former, the calls would be changed into:
... = dict.updateValue("nihongo",
forKeyPath: ["countries", "japan", "language"]
... = dict.updateValue("asia",
forKeyPath: ["countries", "japan", "continent"]
Finally note that a call to updateValue using the [Key] as key path method will return nil also in case of an empty array being passed as argument ([]). This could possibly be changed to a throwing case, as a nil return above should tell us that a new key-value pair was added (as inspired by the updateValue(_:, forKey:) method in stdlib).
Performance?
The methods above will make use of some (sub-)dictionary copying along the way, but unless you're working with huge dictionaries, this shouldn't be an issue. Anyhow, no need to worry about performance until a profiler tells you have a bottleneck.