Swift not converting specific values to a float

Question

My code is not working to convert 1.1 to a float. It works to convert 1.0, 1.25, and 1.5 to floats but doesn't convert 1.1. I do not understand why this would happen as they are all decimals with very few digits of precision required. This is when decoding from a JSON.

The code in question:

if let path = Bundle.main.path(forResource: "moves", ofType: "json") {
    do {
        let data = try Data(contentsOf: URL(fileURLWithPath: path))
        let json = try JSONSerialization.jsonObject(with: data, options: [])
        if let array = json as? [[String:Any]] {
            for dict in array {
                if let actionName = dict["name"] as? String,
                   let type = dict["type"] as? String,
                   let amt = dict["amtlost"] as? Int,
                   let val = dict["atkdefval"] as? Float,
                   let dtype = dict["element"] as? String,
                   let target = dict["target"] as? Bool,
                   let steal = dict["stealAmt"] as? Float{
                    
                    let cmove = Actions(name: actionName, type: type, amtlost: amt, atkdefval: val, damageType: dtype, target: target, stealAmt: steal)
                    self.moves.append(cmove)
                } else {
                    print(dict)
                    let val = dict["atkdefval"] as? Float
                    print(val)
                }
            }
        }
    } catch {
        print("Error reading location JSON file: \(error)")
    }
} else {
    print("Could not read JSON")
}
print(self.moves.count)
for move in moves {
    print(move.name)
    print(move.atkdefval)
}

The JSON:

[
    {
        "name": "Slash",
        "type": "phys",
        "amtlost": 0,
        "atkdefval": 1.5,
        "element": "slashing",
        "target": false,
        "stealAmt": 0
    },
    {
        "name": "Punch",
        "type": "phys",
        "amtlost": 0,
        "atkdefval": 1.1,
        "element": "bludgeoning",
        "target": false,
        "stealAmt": 0
    },
    {
        "name": "Magic Missile",
        "type": "magic",
        "amtlost": 2,
        "atkdefval": 1.75,
        "element": "force",
        "target": false,
        "stealAmt": 0
    },
    {
        "name": "Block",
        "type": "defense",
        "amtlost": 0,
        "atkdefval": 1.5,
        "element": "bludgeoning",
        "target": false,
        "stealAmt": 0
    },
    {
        "name": "Healing Word",
        "type": "healing",
        "amtlost": 2,
        "atkdefval": 1.25,
        "element": "light",
        "target": false,
        "stealAmt": 0
    },
    {
        "name": "Shield",
        "type": "shield",
        "amtlost": 1,
        "atkdefval": 1.5,
        "element": "force",
        "target": false,
        "stealAmt": 0
    }
]

The class code (in case it helps):

enum ActionType:String, Codable{
    case phys = "phys"
    case magic = "magic"
    case defense = "defense"
    case healing = "healing"
    case shield = "shield"
}

enum DamageElement: String, Codable{
    case slash = "slashing"
    case pierce = "piercing"
    case bludgeon = "bludgeoning"
    case fire = "fire"
    case ice = "ice"
    case earth = "earth"
    case lightning = "lightning"
    case light = "light"
    case dark = "dark"
    case force = "force"
}

class Actions: Codable, Hashable, Equatable{
    var name: String
    var type: ActionType
    var amtlost: Int
    var atkdefval: Float
    var element: DamageElement
    var target: Bool // false is hp, true is mp
    var stealAmt: Float
    
    static func == (lhs: Actions, rhs: Actions) -> Bool {
        return lhs.name == rhs.name
    }
    
    func hash(into hasher: inout Hasher) { return hasher.combine(ObjectIdentifier(self))}
    
    init(){
        self.name = "punch"
        self.type = .phys
        self.amtlost = 0
        self.atkdefval = 4
        self.element = .bludgeon
        self.target = false
        self.stealAmt = 0
    }
    
    init(name: String, type: String, amtlost: Int, atkdefval: Float, damageType: String, target: Bool, stealAmt: Float) {
        self.name = name
        self.type = ActionType(rawValue: type.lowercased())!
        self.amtlost = amtlost
        self.atkdefval = atkdefval
        self.element = DamageElement(rawValue: damageType.lowercased())!
        self.target = target
        self.stealAmt = stealAmt
    }
    
}

I tried to have it convert from a JSON dict as a float but it converted as nil instead of the expected 1.1. I tried converting it to a string from the JSON and to a float from there and it worked but it is confusing as to why the first way doesn't work.

What happens if you call `print(type(of: dict["atkdefval"]))`? — McKinley, May 07 '23 at 17:53
Why are you using `JSONSerialization` when your types conforms to `Codable`? — Joakim Danielson, May 07 '23 at 17:56
A possibly better way to deserialize the JSON is to write `let actions = try JSONDecoder().decode([Actions].self, from: data)`. Then `actions` will be an array of `Actions`. — McKinley, May 07 '23 at 17:56
From what I can see your types conform to `Codable`, so you should be able to use `JSONDecoder().decode(data, to: [Action].self)` instead of going through `JSONSerialization`. That would simplify your code a lot, and I think would fix your problem. — Chip Jarred, May 07 '23 at 18:00
Not relater to your question but why not simply `let url = Bundle.main.url(forResource: "moves", withExtension: "json")`? — Leo Dabus, May 07 '23 at 18:49

Rob Napier · Accepted Answer · 2023-05-07T19:33:11.647

You should use JSONDecoder as McKinley describes, but the reason this fails for 1.1 is because the default internal type is Double and the (rounded) Double value 1.1 doesn't fit in Float exactly. Consider:

import Foundation
NSNumber(1.1) as? Double    // 1.1
NSNumber(1.1) as? Float     // nil
NSNumber(1.5) as? Double    // 1.5
NSNumber(1.5) as? Float     // 1.5

1.5 can be expressed precisely in both Float and Double, so it converts.

JSONSerialization packs everything into an NSNumber, and that won't as? bridge to Float if it requires rounding. You could write it this way (but I don't recommend it):

    if let actionName = dict["name"] as? String,
       let type = dict["type"] as? String,
       let amt = dict["amtlost"] as? Int,
       let val = (dict["atkdefval"] as? NSNumber)?.floatValue, // <==
       let dtype = dict["element"] as? String,
       let target = dict["target"] as? Bool,
       let steal = (dict["stealAmt"] as? NSNumber)?.floatValue // <==

You can also fix this by using Double everywhere rather than Float, and you should do that anyway. When in doubt, use Double in Swift for floating point.

But in addition, the better solution is to use JSONDecoder which avoids these subtle problems. Since all the types are already Decodable, your entire decoding logic can be replaced by:

self.moves = try JSONDecoder().decode([Actions].self, from: data)

NSNumber returns nil if you try to fetch a Float that can't be represented exactly? That's unexpected and a little bizarre, since **most** decimal values can't be represented exactly in binary floating point. Thanks for the heads up, Rob! — Duncan C, May 07 '23 at 20:16
NSNumber doesn't. Swift's `as?` cast to Float from an NSNumber that wraps a Double does. As a counter-example, an NSNumber that wraps a Float will `as?` cast to Float fine, because it will be exact: `NSNumber(value: Float(1.1)) as? Float`. — Rob Napier, May 07 '23 at 20:47

McKinley · Answer 2 · 2023-05-07T18:32:23.393

Since your Actions class conforms to Codable, you can actually use the simpler JSONDecoder instead of JSONSerialization:

let listOfMoves = try JSONDecoder().decode([Actions].self, from: data)
self.moves.append(contentsOf: listOfMoves)

Then you don't have to worry about manually casting the entries of the dictionary to Floats and Bools, etc., and then manually creating Actions. Instead, JSONDecoder will perform all that for you and spit out a nice array of Actions -- or throw an error if the JSON is improperly formatted.

Swift not converting specific values to a float

2 Answers2