Swift: How to remove a null value from Dictionary?

Question

I'm new in Swift and I have a problem with filtering NULL values from JSON file and setting it into Dictionary. I getting JSON response from the server with null values and it crashes my app.

Here is JSON response:

"FirstName": "Anvar",
"LastName": "Azizov",
"Website": null,
"About": null,

I will be very appreciated for help to deal with it.

UPD1: At this moment I decided to do it in a next way:

if let jsonResult = responseObject as? [String: AnyObject] {                    
    var jsonCleanDictionary = [String: AnyObject]()

    for (key, value) in enumerate(jsonResult) {
      if !(value.1 is NSNull) {
         jsonCleanDictionary[value.0] = value.1
      }
    }
}

What code/library are you using to interpret the json string? Is it being passed into a NSDictionary or some other container? A code example will help people understand better what you are trying to do and where the issue lies. — , Nov 20 '14 at 16:12
Instead of removing you should detect and handle the null values correctly. Compare http://stackoverflow.com/questions/24026609/detect-a-null-value-in-nsdictionary. — Martin R, Nov 20 '14 at 16:20
@Graff, I'm using AfNetworking and the data passed into a NSDictionary. I decided to enumerate on values and delete all Null vallues. I've updated the question with an example. — Anvar Azizov, Nov 21 '14 at 14:27
As @MartinR has said, it's usually better to handle the null values properly rather than blindly filter them out. Can you show the code which is crashing? Then we can help solve that issue and the data doesn't need to be filtered. — , Nov 21 '14 at 14:34

Marián Černý · Answer 1 · 2019-04-01T09:09:37.007

Swift 5

Use compactMapValues:

dictionary.compactMapValues { $0 }

compactMapValues has been introduced in Swift 5. For more info see Swift proposal SE-0218.

Example with dictionary

let json = [
    "FirstName": "Anvar",
    "LastName": "Azizov",
    "Website": nil,
    "About": nil,
]

let result = json.compactMapValues { $0 }
print(result) // ["FirstName": "Anvar", "LastName": "Azizov"]

Example including JSON parsing

let jsonText = """
  {
    "FirstName": "Anvar",
    "LastName": "Azizov",
    "Website": null,
    "About": null
  }
  """

let data = jsonText.data(using: .utf8)!
let json = try? JSONSerialization.jsonObject(with: data, options: [])
if let json = json as? [String: Any?] {
    let result = json.compactMapValues { $0 }
    print(result) // ["FirstName": "Anvar", "LastName": "Azizov"]
}

Swift 4

I would do it by combining filter with mapValues:

dictionary.filter { $0.value != nil }.mapValues { $0! }

Examples

Use the above examples just replace let result with

let result = json.filter { $0.value != nil }.mapValues { $0! }

Couln't not remove the `null` entry from valid json i.e: `{ "something": [ { "name": "One" }, { "name": "Two" }, null ]}` — Luiz Dias, Dec 03 '21 at 08:00
The question and my solution is about removing `null` from the root JSON dictionary. It does not remove all the `null`s inside the JSON. You want to remove `null` from an array that is a value inside root JSON dictionary. You can use this: `if let something = json["something"] as? [Any?] { print(something.compactMap { $0 is NSNull ? nil : $0 }) }`. Note that JSONSerialization returns `NSNull` objects for `null` that are not automatically converted to `nil` when converting to Swift array `[Any?]`, therefore you need to check for `NSNull` explicitly. — Marián Černý, Dec 04 '21 at 11:51

Antonio · Accepted Answer · 2018-01-17T17:18:09.950

15

You can create an array containing the keys whose corresponding values are nil:

let keysToRemove = dict.keys.array.filter { dict[$0]! == nil }

and next loop through all elements of that array and remove the keys from the dictionary:

for key in keysToRemove {
    dict.removeValueForKey(key)
}

Update 2017.01.17

The force unwrapping operator is a bit ugly, although safe, as explained in the comments. There are probably several other ways to achieve the same result, a better-looking way of the same method is:

let keysToRemove = dict.keys.filter {
  guard let value = dict[$0] else { return false }
  return value == nil
}

edited Jan 17 '18 at 17:18

answered Nov 20 '14 at 16:15

Antonio

71,651
11
148
165

2

the force unwrap is a wtf here. this is only not crashing because the value type is not an optional. also: never force unwrap at all – Hogdotmac Jan 17 '18 at 13:41
3

@Hogdotmac it's definitely not an elegant way of doing it nowadays, but take into account that `dict[$0]` is an optional which may contain another optional. The force unwrap is safe because we're looping through the array of keys, so each of these keys exists – Antonio Jan 17 '18 at 16:53
Adding to @Antonio's point, force-unwrap will let compiler avoid unnecessary branching. – MMujtabaRoohani Jun 12 '21 at 07:43
Looks like it doesn't work for a valid json like this `{ "something": [ { "name": "One" }, { "name": "Two" }, null ]}` – Luiz Dias Dec 03 '21 at 07:59

Daniel T. · Answer 3 · 2018-06-05T14:39:22.323

8

I ended up with this in Swift 2:

extension Dictionary where Value: AnyObject {

    var nullsRemoved: [Key: Value] {
        let tup = filter { !($0.1 is NSNull) }
        return tup.reduce([Key: Value]()) { (var r, e) in r[e.0] = e.1; return r }
    }
}

Same answer but for Swift 3:

extension Dictionary {

    /// An immutable version of update. Returns a new dictionary containing self's values and the key/value passed in.
    func updatedValue(_ value: Value, forKey key: Key) -> Dictionary<Key, Value> {
        var result = self
        result[key] = value
        return result
    }

    var nullsRemoved: [Key: Value] {
        let tup = filter { !($0.1 is NSNull) }
        return tup.reduce([Key: Value]()) { $0.0.updatedValue($0.1.value, forKey: $0.1.key) }
    }
}

Things get a lot easier in Swift 4. Just use Dictionary's filter directly.

jsonResult.filter { !($0.1 is NSNull) }

Or if you don't want to remove the relevant keys, you can do this:

jsonResult.mapValues { $0 is NSNull ? nil : $0 }

Which will replace the NSNull values with nil instead of removing the keys.

edited Jun 05 '18 at 14:39

answered Mar 04 '16 at 02:40

Daniel T.

32,821
6
50
72

Pretty similar to what I came up with. Both `filter` and `reduce` iterate through the array so only using `reduce` will probably be a bit faster than using both of them. I like the idea of it being an extension. – Mar 04 '16 at 03:04
And they are deprecating car in this context for Swift 3. – Daniel T. Mar 04 '16 at 12:15
True, I updated my answer to account for that and to avoid creating a new copy of the dictionary on every iteration. – Mar 04 '16 at 16:46
@DanielT i have used the above code for swift 2 but now I'm migrating to swift3 and I'm getting error "cannot assign through subscript: 'r' is a let constant". can u please help – Thripthi Haridas Dec 26 '16 at 06:15
@ThripthiHaridas I updated the answer with a Swift 3 version. – Daniel T. Dec 26 '16 at 19:48
@DanielT I'm migrating above code to swift4. Please help me out with the code. – Thripthi Haridas Jun 05 '18 at 11:37
@ThripthiHaridas I added it to the answer. – Daniel T. Jun 05 '18 at 11:54
@DanielT. Thanks – Thripthi Haridas Jun 05 '18 at 11:56

score 3 · Answer 4 · 2016-03-04T16:49:27.297

Assuming that you just want to filter out any NSNull values from a dictionary, this is probably one of the better ways of going about it. It's future-proofed against Swift 3, as far as I know for now:

(With thanks to AirspeedVelocity for the extension, translated to Swift 2)

import Foundation

extension Dictionary {
/// Constructs [key:value] from [(key, value)]

  init<S: SequenceType
    where S.Generator.Element == Element>
    (_ seq: S) {
      self.init()
      self.merge(seq)
  }

  mutating func merge<S: SequenceType
    where S.Generator.Element == Element>
    (seq: S) {
      var gen = seq.generate()
      while let (k, v) = gen.next() {
        self[k] = v
      }
  }
}

let jsonResult:[String: AnyObject] = [
  "FirstName": "Anvar",
  "LastName" : "Azizov",
  "Website"  : NSNull(),
  "About"    : NSNull()]

// using the extension to convert the array returned from flatmap into a dictionary
let clean:[String: AnyObject] = Dictionary(
  jsonResult.flatMap(){ 
    // convert NSNull to unset optional
    // flatmap filters unset optionals
    return ($0.1 is NSNull) ? .None : $0
  })
// clean -> ["LastName": "Azizov", "FirstName": "Anvar"]

In Swift 2, `jsonResult.filter { !($0.1 is NSNull) }` comes back with a type of [(String: AnyObject)] rather than [String: AnyObject]... Any ideas? — Daniel T., Mar 04 '16 at 02:13
Yeah, it's a bit trickier. The easiest way to do it is with `reduce` although there are other ways to go about it. I'll edit the answer. — , Mar 04 '16 at 02:39

Eralp Karaduman · Answer 5 · 2017-12-01T11:31:49.993

Suggesting this approach, flattens optional values and also compatible with Swift 3

String key, optional AnyObject? value dictionary with nil values:

let nullableValueDict: [String : AnyObject?] = [
    "first": 1,
    "second": "2",
    "third": nil
]

// ["first": {Some 1}, "second": {Some "2"}, "third": nil]

nil values removed and transformed into non optional value dictionary

nullableValueDict.reduce([String : AnyObject]()) { (dict, e) in
    guard let value = e.1 else { return dict }
    var dict = dict
    dict[e.0] = value
    return dict
}

// ["first": 1, "second": "2"]

Redeclaration var dict = dict is needed due to removal of var parameters in swift 3, so for swift 2,1 it could be;

nullableValueDict.reduce([String : AnyObject]()) { (var dict, e) in
    guard let value = e.1 else { return dict }
    dict[e.0] = value
    return dict
}

Swift 4, would be;

let nullableValueDict: [String : Any?] = [
    "first": 1,
    "second": "2",
    "third": nil
]

let dictWithoutNilValues = nullableValueDict.reduce([String : Any]()) { (dict, e) in
    guard let value = e.1 else { return dict }
    var dict = dict
    dict[e.0] = value
    return dict
}

Hey @adrian i updated the answer with Swift 4 compatible. See [Swift Sandbox](http://swift.sandbox.bluemix.net/#/repl/5a213dfe3d51ff687fc49fdd) — Eralp Karaduman, Dec 01 '17 at 11:35

score 3 · Answer 6 · answered Mar 29 '19 at 06:17

3

Swift 5

compactMapValues(_:)

Returns a new dictionary containing only the key-value pairs that have non-nil values as the result of transformation by the given closure.

let people = [
    "Paul": 38,
    "Sophie": 8,
    "Charlotte": 5,
    "William": nil
]

let knownAges = people.compactMapValues { $0 }

answered Mar 29 '19 at 06:17

Saranjith

11,242
5
69
122

Looks like it doesn't work for a valid json like this `{ "something": [ { "name": "One" }, { "name": "Two" }, null ]}` – Luiz Dias Dec 03 '21 at 07:59

score 3 · Answer 7 · answered Jan 25 '21 at 05:15

Swift5

Use compactMapValues to create a dictionary extension for future usage

extension Dictionary where Key == String, Value == Optional<Any> {
    func discardNil() -> [Key: Any] {
        return self.compactMapValues({ $0 })
    }
}

How to use

public func toDictionary() -> [String: Any] {
    let emailAddress: String? = "test@mail.com"
    let phoneNumber: String? = "xxx-xxx-xxxxx"
    let newPassword: String = "**********"

    return [
        "emailAddress": emailAddress,
        "phoneNumber": phoneNumber,
        "passwordNew": newPassword
    ].discardNil()
}

score 2 · Answer 8 · answered Jun 15 '18 at 09:21

You can replace the null values to empty string by following function.

func removeNullFromDict (dict : NSMutableDictionary) -> NSMutableDictionary
{
    let dic = dict;

    for (key, value) in dict {

        let val : NSObject = value as! NSObject;
        if(val.isEqual(NSNull()))
        {
            dic.setValue("", forKey: (key as? String)!)
        }
        else
        {
            dic.setValue(value, forKey: key as! String)
        }

    }

    return dic;
}

Roman Podymov · Answer 9 · 2018-04-26T12:34:18.327

Since Swift 4 provides method reduce(into:_:) for class Dictionary you can remove nil-values from Dictionary with the following function:

func removeNilValues<K,V>(dict:Dictionary<K,V?>) -> Dictionary<K,V> {

    return dict.reduce(into: Dictionary<K,V>()) { (currentResult, currentKV) in

        if let val = currentKV.value {

            currentResult.updateValue(val, forKey: currentKV.key)
        }
    }
}

You can test it like that:

let testingDict = removeNilValues(dict: ["1":nil, "2":"b", "3":nil, "4":nil, "5":"e"])
print("test result is \(testingDict)")

Andres Canella · Answer 10 · 2021-05-20T12:08:40.017

1

Another quick way to do it in case you're not in Swift 5 yet... This will produce the same effect as compactMapValues.

Same dictionary but with no optionals.

let cleanDictionary = originalDictionary.reduce(into: [String: Any]()) { $0[$1.key] = $1.value }

Quick playground:

let originalDictionary = [
    "one": 1,
    "two": nil,
    "three": 3]

let cleanDictionary = originalDictionary.reduce(into: [String: Any]()) { $0[$1.key] = $1.value }    
for element in cleanDictionary {
    print(element)
}

output:

["one": 1, "three": 3]

edited May 20 '21 at 12:08

answered May 19 '21 at 17:40

Andres Canella

3,706
1
35
47

How to remove for empty String "four" = "" ? – kiran Jan 13 '22 at 13:25
That is beyond the scope of the question, I suggest looking for it separately. This question is focused on nil values:) – Andres Canella Jan 15 '22 at 23:02
Okay I will look it into another – kiran Jan 16 '22 at 18:23

buildsucceeded · Answer 11 · 2017-10-11T13:30:54.810

I just had to solve this for a general case where NSNulls could be nested in the dictionary at any level, or even be part of an array:

extension Dictionary where Key == String, Value == Any {

func strippingNulls() -> Dictionary<String, Any> {

    var temp = self
    temp.stripNulls()
    return temp
}

mutating func stripNulls() {

    for (key, value) in self {
        if value is NSNull {
            removeValue(forKey: key)
        }
        if let values = value as? [Any] {
            var filtered = values.filter {!($0 is NSNull) }

            for (index, element) in filtered.enumerated() {
                if var nestedDict = element as? [String: Any] {
                    nestedDict.stripNulls()

                    if nestedDict.values.count > 0 {
                        filtered[index] = nestedDict as Any
                    } else {
                        filtered.remove(at: index)
                    }
                }
            }

            if filtered.count > 0 {
                self[key] = filtered
            } else {
                removeValue(forKey: key)
            }
        }

        if var nestedDict = value as? [String: Any] {

            nestedDict.stripNulls()

            if nestedDict.values.count > 0 {
                self[key] = nestedDict as Any
            } else {
                self.removeValue(forKey: key)
            }
        }
    }
}

}

I hope this is helpful to others and I welcome improvements!

(Note: this is Swift 4)

I'm trying to create a dictionary of values using `Mirror` to get all the properties of a class, chuck them in a `Dictionary`, and filter out the nil values. This code does not crash, but it doesn't remove nil values and their associated keys for me. — Adrian, Nov 28 '17 at 18:26

Rashesh Bosamiya · Answer 12 · 2017-12-28T06:13:29.997

Following is the solution, when JSON have sub-dictionaries. This will go-through all the dictionaries, sub-dictionaries of JSON and remove NULL(NSNull) key-value pair from the JSON.

extension Dictionary {

    func removeNull() -> Dictionary {
        let mainDict = NSMutableDictionary.init(dictionary: self)
        for _dict in mainDict {
            if _dict.value is NSNull {
                mainDict.removeObject(forKey: _dict.key)
            }
            if _dict.value is NSDictionary {
                let test1 = (_dict.value as! NSDictionary).filter({ $0.value is NSNull }).map({ $0 })
                let mutableDict = NSMutableDictionary.init(dictionary: _dict.value as! NSDictionary)
                for test in test1 {
                    mutableDict.removeObject(forKey: test.key)
                }
                mainDict.removeObject(forKey: _dict.key)
                mainDict.setValue(mutableDict, forKey: _dict.key as? String ?? "")
            }
            if _dict.value is NSArray {
                let mutableArray = NSMutableArray.init(object: _dict.value)
                for (index,element) in mutableArray.enumerated() where element is NSDictionary {
                    let test1 = (element as! NSDictionary).filter({ $0.value is NSNull }).map({ $0 })
                    let mutableDict = NSMutableDictionary.init(dictionary: element as! NSDictionary)
                    for test in test1 {
                        mutableDict.removeObject(forKey: test.key)
                    }
                    mutableArray.replaceObject(at: index, with: mutableDict)
                }
                mainDict.removeObject(forKey: _dict.key)
                mainDict.setValue(mutableArray, forKey: _dict.key as? String ?? "")
            }
        }
        return mainDict as! Dictionary<Key, Value>
    }
 }

score 0 · Answer 13 · answered Nov 23 '18 at 07:00

Trim Null form NSDictionary to get ride of crash Pass Dictionary to this function and get result as NSMutableDictionary

func trimNullFromDictionaryResponse(dic:NSDictionary) -> NSMutableDictionary {
    let allKeys = dic.allKeys
    let dicTrimNull = NSMutableDictionary()
    for i in 0...allKeys.count - 1 {
        let keyValue = dic[allKeys[i]]
        if keyValue is NSNull {
            dicTrimNull.setValue("", forKey: allKeys[i] as! String)
        }
        else {
            dicTrimNull.setValue(keyValue, forKey: allKeys[i] as! String)
        }
    }
    return dicTrimNull
}

score 0 · Answer 14 · answered Jul 17 '19 at 03:18

0

Try to unwrap it with the expected type of values and check for the nill or empty if yes then remove that value from the dictionary.

This will work if the values in the dictionary is has empty values

answered Jul 17 '19 at 03:18

Teja Swaroop

1,139
12
18

score 0 · Answer 15 · answered Jan 30 '21 at 09:21

//
//  Collection+SF.swift
//  PanoAI
//
//  Created by Forever Positive on 2021/1/30.
//

import Foundation

extension Array where Element == Optional<Any>{
    var trimed:[Any] {
       var newArray = [Any]()
        for item in self{
            if let item = item as? [Any?] {
                newArray.append(contentsOf: item.trimed)
            }else if item is NSNull || item == nil {
                //skip
            }else if let item = item{
                newArray.append(item)
            }
        }
        return newArray
    }
}

extension Dictionary where Key == String, Value == Optional<Any> {
    var trimed:[Key: Any] {
        return self.compactMapValues({ v in
            if let dic = v as? [String:Any?] {
                return dic.trimed
            }else if let _ = v as? NSNull {
                return nil;
            }else if let array = v as? [Any?] {
                return array.trimed;
            }else{
                return v;
            }
        })
    }
}

// MARK: - Usage
//let dic:[String:Any?] = ["a":"a","b":nil,"c":NSNull(),"d":["1":"1","2":nil,"3":NSNull(),"4":["a","b",nil,NSNull()]],"e":["a","b",nil,NSNull()]]
//print(dic.trimed)

Swift: How to remove a null value from Dictionary?

15 Answers15

Swift 5

Example with dictionary

Example including JSON parsing

Swift 4

Examples

Swift 5

Linked