Swift 4: Formatting number's into friendly K's

Question

Currently working on a simple function which does a great job for me..

For example: If i have 1000, It'll print out 1.0K, or 1,000,000 it'll be 1M, everything works fine until here,

What if i wanted to turn 1,000,000,000 into 1B?

I tried the following ->

func formatPoints(from: Int) -> String {
     let number = Double(from)
     let thousand = number / 1000
     let million = number / 1000000
     let billion = number / 1000000000

     if million >= 1.0 { 
     return "\(round(million*10)/10)M" 
} else if thousand >= 1.0 { 
     return "\(round(thousand*10)/10)K"
} else if billion >= 1.0 {
        return ("\(round(billion*10/10))B")
} else {
    return "\(Int(number))"}
}

print(formatPoints(from: 1000000000))

But it returns 1000.0M, not 1B

Thanks!

See https://stackoverflow.com/questions/18267211/ios-convert-large-numbers-to-smaller-format — rmaddy, Jan 21 '18 at 20:55
Your logic doesn't make too much sense. Why for 1000 it uses minimumFraction digits = 1 (1.0K) and for 1_000_000 it uses 0 (1M)? — Leo Dabus, Jan 22 '18 at 01:39

fake girlfriends · Accepted Answer · 2020-08-27T15:39:28.003

This answer formats by truncating (versus rounding). 1,515 rounded would generate 2k whereas truncated would generate 1.5k. The function requires reducing a number's scale (removing digits to the right of the decimal) which I've just packaged as an extension so it can be used anywhere (not just in the function).

extension Double {
    func reduceScale(to places: Int) -> Double {
        let multiplier = pow(10, Double(places))
        let newDecimal = multiplier * self // move the decimal right
        let truncated = Double(Int(newDecimal)) // drop the fraction
        let originalDecimal = truncated / multiplier // move the decimal back
        return originalDecimal
    }
}

func formatNumber(_ n: Int) -> String {
    let num = abs(Double(n))
    let sign = (n < 0) ? "-" : ""

    switch num {
    case 1_000_000_000...:
        var formatted = num / 1_000_000_000
        formatted = formatted.reduceScale(to: 1)
        return "\(sign)\(formatted)B"

    case 1_000_000...:
        var formatted = num / 1_000_000
        formatted = formatted.reduceScale(to: 1)
        return "\(sign)\(formatted)M"

    case 1_000...:
        var formatted = num / 1_000
        formatted = formatted.reduceScale(to: 1)
        return "\(sign)\(formatted)K"

    case 0...:
        return "\(n)"

    default:
        return "\(sign)\(n)"
    }
}

You can fine tune this method for specific cases, such as returning 100k instead of 100.5k or 1M instead of 1.1M. This method handles negatives as well.

print(formatNumber(1515)) // 1.5K
print(formatNumber(999999)) // 999.9K
print(formatNumber(1000999)) // 1.0M

If you put the cases in descending order, you would only have to wrtie `case 1_000_000_000...`, `case 1_000_000...`, `case 1_000...`. Also, you just extract the sign: `let sign = (n < 0) ? "-" : ""`, then return `return "\(sign)\(formatted)X"` — Alexander, Jan 21 '18 at 22:20
@iabuseservers You should put brackets around the initial definition of `formatted` (which isn't actually formatted, at that time!), and call truncate directly on it. `return "\(sign)\((num / 1_000).truncate(places: 1))K"` — Alexander, Jan 21 '18 at 22:41

Andy Jazz · Answer 2 · 2021-08-05T08:25:21.030

The following logic of if-else statements shows you what goes first and what last:

import Foundation

func formatPoints(from: Int) -> String {

    let number = Double(from)
    let thousand = number / 1000
    let million = number / 1000000
    let billion = number / 1000000000
    
    if billion >= 1.0 {
        return "\(round(billion*10)/10)B"
    } else if million >= 1.0 {
        return "\(round(million*10)/10)M"
    } else if thousand >= 1.0 {
        return ("\(round(thousand*10/10))K")
    } else {
        return "\(Int(number))"
    }
}

print(formatPoints(from: 1000))             /*  1.0 K  */
print(formatPoints(from: 1000000))          /*  1.0 M  */
print(formatPoints(from: 1000000000))       /*  1.0 B  */

Billion must go first.

[round()](https://developer.apple.com/documentation/swift/double/2884722-round) is an instance method inside Foundation module (or in Swift Standard Library). — Andy Jazz, Aug 05 '21 at 08:09

Swift 4: Formatting number's into friendly K's

2 Answers2