Pfthb

I need a dictionary extension that can remove all matching keys from an arbitrary dictionary ([String: Any]).

An example use case could look like this:

Remove all keys from the given dictionary that match one of the following: ["test", "staging"]

[
"foo": [ "bar": "tralala" ]
"test": [ "foo": "bar", "staging": "hi"]
"aaa": [ "bbb": "cccc", "staging": "jjj"]
]

Intended result:

[
"foo": [ "bar": "tralala" ]
"aaa": [ "bbb": "cccc"]
]

Using Any as a type for the values of a dictionary is discouraged. It would be preferable, in this case, to define your dictionary as [String : [String : String]].

If you really can't avoid using any, let's define this dictionary which has multiple levels of nested dictionaries:

let dictionary = [
 "foo" : [ "bar": "tralala" ],
 "test": [ "foo": "bar", "staging": "hi"],
 "aaa" : [ "bbb": "cccc", "staging": "jjj"],
 "d" : [ "e": "f", "g": ["h": "i", "test": "j"]],
]

And declare the keys that we'd like to remove:

let badKeys = ["test", "staging"]

Here is a recursive function that removes the unwanted keys:

func remove(_ keys: [String], from dict: [String: Any]) -> [String: Any] 
 var filtered = dict.filter !keys.contains($0.key) 
 for entry in filtered 
 if let value = entry.value as? [String : String] 
 filtered[entry.key] = remove(badKeys, from: value)
 
 
 return filtered

And you could use it like so:

let result = remove(badKeys, from: dictionary)

Which yields:

["aaa": ["bbb": "cccc"], "foo": ["bar": "tralala"], "d": ["e": "f", "g": ["h": "i"]]]

(Bear in mind that a dictionary is an unordered collection, so the the results may differ in order)

It is not clear what you tried and where you got stuck, you really should include this – not doing so will be why you've been down voted.

However, let's see if we can help. You state your dictionary is of type [String:Any] and do not give any nesting limit, so we'll use the following test data:

let sampleDict : [String:Any] =
[
 "foo": [ "bar": "tralala" ],
 "test": [ "foo": "bar", "staging": "hi"],
 "staging" : 3,
 "one" : [ "two" : [ "three" : 3, "staging" : 4.2]],
 "aaa": [ "bbb": "cccc", "staging": "jjj"]
]

If our algorithm copes with that it should cope with anything (famous last words...).

A straightforward algorithm using pre-defined methods and avoiding loops:

1. Filter the dictionary removing any key/value pairs where the key needs to be deleted.


2. Map the values in the filtered dictionary, for any value which is itself a [String:Any] dictionary recursively apply this algorithm to the value.

In Swift:

func removeMatchingKeys(_ dict : [String:Any], _ keysToRemove : [String]) -> [String:Any]

 return dict
 // filter keeping only those key/value pairs
 // where the key isn't in keysToRemove
 .filter !keysToRemove.contains($0.key) 
 // map the values in the filtered dictionary recursing
 // if the value is itself a [String:Any] dictionary
 .mapValues
 if let nested = $0 as? [String:Any]
 // value is dictionary, recurse
 return removeMatchingKeys(nested, keysToRemove) 
 else
 // value isn't a dictionary, leave as is
 return $0 
 

Testing this with the keys:

let sampleKeys = ["test", "staging"]

The statement:

print( removeMatchingKeys(sampleDict, sampleKeys) )

Produces:

["foo": ["bar": "tralala"], "aaa": ["bbb": "cccc"], "one": ["two": ["three": 3.0]]]

The above algorithm makes two passes over the data, first to filter it and then to map it. If, and only if, this turns out to be a performance issue you can replace the two pre-defined functions filter and map with a simple handwritten loop which combines the operations and only passes over the data once.

Note: Above uses Xcode 10/Swift 4.2, use any other version and YMMV (i.e. syntax & pre-defined functions could easily be different) but the algorithm is still applicable.