Quiero formatear decimales para tener cuatro números distintos de cero después del 0. final. Por ejemplo, 0.001765 o 0.00004839.

Cualquier número por encima de 1 simplemente tendría dos decimales. Por ejemplo, 2.23.

Me pregunto si puedo lograr esto usando NumberFormatter?

0
vikzilla 23 ene. 2018 a las 03:08

3 respuestas

La mejor respuesta

Tienes dos condiciones. Use minimumSignificantDigits y maximumSignificantDigits para los 4 dígitos y use maximumFractionDigits para los 2 lugares para valores superiores a 1.

extension FloatingPoint {
    func specialFormat() -> String {
        let fmt = NumberFormatter()
        fmt.numberStyle = .decimal
        if abs(self) >= 1 {
            // adjust as needed
            fmt.maximumFractionDigits = 2
        } else {
            fmt.minimumSignificantDigits = 4
            fmt.maximumSignificantDigits = 4
        }

        return fmt.string(for: self)!
    }
}

print(0.001765345.specialFormat())
print(0.00004839643.specialFormat())
print(1.2345.specialFormat())

Salida:

0.001765
0.00004840
1,23

2
rmaddy 23 ene. 2018 a las 00:31

Use la propiedad maximumSignificantDigits.

let nf = NumberFormatter()
nf.maximumSignificantDigits = 4
print(nf.string(for: 0.00000232323)!)
// prints 0.000002323
print(nf.string(for: 2.3)!)
// prints 2.3
3
Samah 23 ene. 2018 a las 00:25

Utilicé una combinación de las respuestas / comentarios recibidos para resolver este problema de manera óptima.

Primero, los dos formateadores necesarios como propiedades estáticas a través de una extensión (como lo sugiere Leo).

extension Formatter {
    static let twoDecimals: NumberFormatter = {
        let formatter = NumberFormatter()
        formatter.numberStyle = .decimal
        formatter.minimumFractionDigits = 2
        formatter.maximumFractionDigits = 2
        return formatter
    }()

    static let fourSigDigits: NumberFormatter = {
        let formatter = NumberFormatter()
        formatter.numberStyle = .decimal
        formatter.minimumSignificantDigits = 4
        formatter.maximumSignificantDigits = 4
        return formatter
    }()
}

Luego, una extensión para aplicar condicionalmente el formateador adecuado (como sugiere rmaddy):

extension FloatingPoint {
    var currencyFormat: String {
        return abs(self) >= 1 ? 
            Formatter.twoDecimals.string(for: self) ?? "" :
            Formatter.fourSigDigits.string(for: self) ?? ""
    }
}

Finalmente, puedes usarlo así:

let eth = 1200.123456
let xrp = 1.23456789
let trx = 0.07891234

eth.currencyFormat //"1200.12"
xrp.currencyFormat //"1.23"
trx.currencyFormat //"0.07891"
0
Leo Dabus 23 ene. 2018 a las 02:31
48392223