Type checks on Int and Bool values are returning incorrectly in Swift 4.2 - swift

Question

I currently have an issue with Swift 4.2 that I wanted to ask for peoples help addressing.
At the moment, I am deserializing a JSON response, which is a dictionary whose keys are of type String and whose values can be of type Int or Bool. A good example is the following:
{
"number_of_likes": 0,
"is_liked": true
}
When I deserialize the object, the JSON response is of type [String: Any], which is expected.
The task:
I need to create an array detailing which keys are of type Bool and set to true.
The problem:
When running the following code using the response highlighted above:
guard let json = json as? [String: Any] else {
return
}
for key in dict.keys {
print("KEY: \(key)")
let value = dict[key]
if value is Int {
print("It is an integer")
}
if value is Bool {
print("It is a bool")
}
}
return strings
The console prints this:
🔵 t+20.765 KEY: number_of_likes
🔵 t+20.765 It is an integer
🔵 t+20.765 It is a bool
🔵 t+20.765 KEY: is_liked
🔵 t+20.765 It is an integer
🔵 t+20.765 It is a bool
As you can see, the 0 Int value is causing the console to print that it is of type Bool and Int, while the true Bool value is causing the console to print that it is of type Int and Bool.
For context, I did find the following question on StackOverflow, but the answer did not work unless I check for type CFBool as opposed to type Bool.
Is it possible to distinguish Bool and Int in Swift?
Can someone please tell me if I am doing something wrong, or if this is an issue with Swift 4.2?
I definitely appreciate the help, so thank you for all who read this.

Answer 1

Sadly, you can't solve this without going down to a pretty low level, using either Core Foundation types or Objective-C #encode strings.
The problem is that, under the covers, Foundation's JSON serialization uses NSNumber to wrap both integers and booleans. So the JSON 0 and the JSON true are both converted to NSNumber objects, and Swift is willing to convert either of those NSNumber objects to an Int or a Bool on request.
However, the JSON booleans are in fact converted to a subclass of NSNumber called __NSCFBoolean, which is the type that a CFBooleanRef (in Swift, CFBoolean) references:
import Foundation
let json = """
{
"number_of_likes": 0,
"is_liked": true
}
"""
let data = json.data(using: .utf8)!
let jso = try! JSONSerialization.jsonObject(with: data, options: []) as! [String: Any]
for key in jso.keys {
if let value = jso[key] as? NSNumber {
print("\(key) \(type(of: value)) \(String(cString: value.objCType))")
}
}
Output:
number_of_likes __NSCFNumber q
is_liked __NSCFBoolean c
It's not documented that Foundation JSON serialization decodes JSON booleans to Core Foundation CFBooleans, but it's unlikely to change.
So here's a Core Foundation way to test:
if let isLikedCF = jso["is_liked"] as CFTypeRef?,
CFGetTypeID(isLikedCF) == CFBooleanGetTypeID()
{
print("it's bool")
} else {
print("it's not bool")
}
What we're doing here is converting the value from the JSON dictionary to a CFTypeRef (which is a reference to any Core Foundation type, and everything returned by Foundation's JSONSerialization is toll-free bridged to a Core Foundation type), and then checking whether the Core Foundation object's type ID is the CFBoolean type ID.
Another way to test using Core Foundation is to recognize that there are only two CFBooleanRef values, kCFBooleanTrue and kCFBooleanFalse. You can see if jso["is_liked"] as? NSNumber is identical to one of those two values, using ===:
if let isLikedNumber = jso["is_liked"] as? NSNumber,
isLikedNumber === kCFBooleanTrue || isLikedNumber === kCFBooleanFalse
{
print("it's bool")
} else {
print("it's not bool")
}
You can also test by checking the NSNumber's Objective-C type code. You cast jso["is_liked"] as? NSNumber, ask for its objCType, convert the resulting C-string to a Swift String, and compare it to "c". If so, it's a boolean. Otherwise, it's not.
if let isLikedNumber = jso["is_liked"] as? NSNumber {
if String(cString: isLikedNumber.objCType) == "c" {
print("it's bool")
} else {
print("it's not bool")
}
}
The c comes from #encode(BOOL) (in Objective-C), where BOOL is a typedef of signed char. This is really obscure stuff. I'd recommend going with a Core Foundation test (shown above), since it's easier to understand and better documented.

Answer 2

You should do something like this
import UIKit
var str = """
{
"number_of_likes": 0,
"is_liked": true
}
"""
struct JsonStruct: Decodable {
var boolWithKey: [String: Bool]?
var intWithKey: [String: Int]?
init(from decoder: Decoder) {
guard let container = try? decoder.container(keyedBy: CodingKeys.self) else {
fatalError()
}
for key in container.allKeys {
if let possibleInt = try? container.decode(Int.self, forKey: key) {
intWithKey = [key.stringValue: possibleInt]
}
if let possibleBool = try? container.decode(Bool.self, forKey: key) {
boolWithKey = [key.stringValue: possibleBool]
}
}
print(container.allKeys)
}
struct CodingKeys: CodingKey {
var stringValue: String
init?(stringValue: String) {
self.stringValue = stringValue
}
var intValue: Int?
init?(intValue: Int) {
return nil
}
}
}
let jsonData = str.data(using: .utf8)!
let jsonDecoder = JSONDecoder()
let jsonStruct = try! jsonDecoder.decode(JsonStruct.self, from: jsonData)
print("\(jsonStruct.boolWithKey)")
print("\(jsonStruct.intWithKey)")
Output:
CodingKeys(stringValue: "number_of_likes", intValue: nil),
CodingKeys(stringValue: "is_liked", intValue: nil)]
Optional(["is_liked": true])
Optional(["number_of_likes": 0])