Swift - Cómo convertir String a Double

Estoy tratando de escribir un programa de IMC en lenguaje rápido. Y tengo este problema: ¿cómo convertir una cadena en un doble?

En Objective-C, puedo hacer así:

double myDouble = [myString doubleValue];

Pero, ¿cómo puedo lograr esto en lenguaje Swift?

Swift 4.2+ String to Double

Debería usar los nuevos inicializadores de tipo para convertir entre String y tipos numéricos (Double, Float, Int). Devolverá un tipo Opcional (¿Doble?) Que tendrá el valor correcto o nulo si la Cadena no era un número.

Nota: La propiedad NSString doubleValue no se recomienda porque devuelve 0 si el valor no se puede convertir (es decir: entrada incorrecta del usuario).

let lessPrecisePI = Float("3.14")

let morePrecisePI = Double("3.1415926536")
let invalidNumber = Float("alphabet") // nil, not a valid number

Desenvuelva los valores para usarlos usando if / let

if let cost = Double(textField.text!) {
    print("The user entered a value price of \(cost)")
} else {
    print("Not a valid number: \(textField.text!)")
}

Puede convertir números y monedas con formato utilizando la NumberFormatterclase.

let formatter = NumberFormatter()
formatter.locale = Locale.current // USA: Locale(identifier: "en_US")
formatter.numberStyle = .decimal
let number = formatter.number(from: "9,999.99")

Formatos de moneda

let usLocale = Locale(identifier: "en_US")
let frenchLocale = Locale(identifier: "fr_FR")
let germanLocale = Locale(identifier: "de_DE")
let englishUKLocale = Locale(identifier: "en_GB") // United Kingdom
formatter.numberStyle = .currency

formatter.locale = usLocale
let usCurrency = formatter.number(from: "$9,999.99")

formatter.locale = frenchLocale
let frenchCurrency = formatter.number(from: "9999,99€")
// Note: "9 999,99€" fails with grouping separator
// Note: "9999,99 €" fails with a space before the €

formatter.locale = germanLocale
let germanCurrency = formatter.number(from: "9999,99€")
// Note: "9.999,99€" fails with grouping separator

formatter.locale = englishUKLocale
let englishUKCurrency = formatter.number(from: "£9,999.99")

Lea más en mi publicación de blog sobre cómo convertir String a tipos dobles (y moneda) .

Swift 2 Actualización Hay nuevas inicializadores failable que le permiten hacer esto de una manera más idiomática y seguros (como han dicho en muchas respuestas, el valor doble de NSString no es muy seguro, ya que devuelve 0 para valores no numéricos. Esto significa que el doubleValuede "foo"y "0"están lo mismo.)

let myDouble = Double(myString)

Esto devuelve un opcional, por lo que en casos como pasar "foo" donde doubleValuehabría devuelto 0, volverá el intializer fallable nil. Puede utilizar una guard, if-leto mappara manejar laOptional<Double>

Publicación original: no necesita usar el constructor NSString como propone la respuesta aceptada. Simplemente puede puentearlo así:

(swiftString as NSString).doubleValue

Para un poco más de sensación de rapidez, el uso NSFormatter()evita la conversión a NSString, y regresa nilcuando la cadena no contiene un Doublevalor (por ejemplo, "prueba" no volverá 0.0).

let double = NSNumberFormatter().numberFromString(myString)?.doubleValue

Alternativamente, extendiendo el Stringtipo de Swift :

extension String {
    func toDouble() -> Double? {
        return NumberFormatter().number(from: self)?.doubleValue
    }
}

y úsalo como toInt():

var myString = "4.2"
var myDouble = myString.toDouble()

Esto devuelve un opcional Double?que debe desenvolverse.

Ya sea con desenvoltura forzada:

println("The value is \(myDouble!)") // prints: The value is 4.2

o con una declaración if let:

if let myDouble = myDouble {
    println("The value is \(myDouble)") // prints: The value is 4.2
}

Actualización: para la localización, es muy fácil aplicar configuraciones regionales a NSFormatter de la siguiente manera:

let formatter = NSNumberFormatter()
formatter.locale = NSLocale(localeIdentifier: "fr_FR")
let double = formatter.numberFromString("100,25")

Finalmente, puede usar NSNumberFormatterCurrencyStyleel formateador si está trabajando con monedas donde la cadena contiene el símbolo de moneda.

Otra opción aquí es convertir esto a an NSStringy usar eso:

let string = NSString(string: mySwiftString)
string.doubleValue

Aquí hay un método de extensión que le permite simplemente llamar a doubleValue () en una cadena Swift y obtener una doble vuelta (la salida de ejemplo es lo primero)

println("543.29".doubleValue())
println("543".doubleValue())
println(".29".doubleValue())
println("0.29".doubleValue())

println("-543.29".doubleValue())
println("-543".doubleValue())
println("-.29".doubleValue())
println("-0.29".doubleValue())

//prints
543.29
543.0
0.29
0.29
-543.29
-543.0
-0.29
-0.29

Aquí está el método de extensión:

extension String {
    func doubleValue() -> Double
    {
        let minusAscii: UInt8 = 45
        let dotAscii: UInt8 = 46
        let zeroAscii: UInt8 = 48

        var res = 0.0
        let ascii = self.utf8

        var whole = [Double]()
        var current = ascii.startIndex

        let negative = current != ascii.endIndex && ascii[current] == minusAscii
        if (negative)
        {
            current = current.successor()
        }

        while current != ascii.endIndex && ascii[current] != dotAscii
        {
            whole.append(Double(ascii[current] - zeroAscii))
            current = current.successor()
        }

        //whole number
        var factor: Double = 1
        for var i = countElements(whole) - 1; i >= 0; i--
        {
            res += Double(whole[i]) * factor
            factor *= 10
        }

        //mantissa
        if current != ascii.endIndex
        {
            factor = 0.1
            current = current.successor()
            while current != ascii.endIndex
            {
                res += Double(ascii[current] - zeroAscii) * factor
                factor *= 0.1
                current = current.successor()
           }
        }

        if (negative)
        {
            res *= -1;
        }

        return res
    }
}

No hay comprobación de errores, pero puede agregarlo si lo necesita.

A partir de Swift 1.1, puede pasar directamente Stringal const char *parámetro.

import Foundation

let str = "123.4567"
let num = atof(str) // -> 123.4567

atof("123.4567fubar") // -> 123.4567

Si no te gusta obsoleto atof:

strtod("765.4321", nil) // -> 765.4321

Una advertencia: el comportamiento de la conversión es diferente de NSString.doubleValue.

atofy strtodaceptar 0xcadena hexadecimal prefijada:

atof("0xffp-2") // -> 63.75
atof("12.3456e+2") // -> 1,234.56
atof("nan") // -> (not a number)
atof("inf") // -> (+infinity)

Si prefiere el .doubleValuecomportamiento, aún podemos usar el CFStringpuente:

let str = "0xff"
atof(str)                      // -> 255.0
strtod(str, nil)               // -> 255.0
CFStringGetDoubleValue(str)    // -> 0.0
(str as NSString).doubleValue  // -> 0.0

En Swift 2.0, la mejor manera es evitar pensar como un desarrollador de Objective-C. Por lo tanto, no debe "convertir una cadena en un doble", sino que debe "inicializar un doble de una cadena". Documento de Apple por aquí: https://developer.apple.com/library/ios//documentation/Swift/Reference/Swift_Double_Structure/index.html#//apple_ref/swift/structctr/Double/s:FSdcFMSdFSSGSqSd_

Es un init opcional, por lo que puede usar el operador de fusión nula (??) para establecer un valor predeterminado. Ejemplo:

let myDouble = Double("1.1") ?? 0.0

En SWIFT 3 , puede usar:

if let myDouble = NumberFormatter().number(from: yourString)?.doubleValue {
   print("My double: \(myDouble)")
}

Nota: - Si una cadena contiene caracteres que no sean dígitos numéricos o separadores decimales o de grupo apropiados para la localidad, el análisis fallará. - Se ignoran los caracteres separadores de espacio iniciales o finales de una cadena. Por ejemplo, las cadenas "5", "5" y "5" producen el número 5.

Tomado de la documentación: https://developer.apple.com/reference/foundation/numberformatter/1408845-number

No he visto la respuesta que estaba buscando. Acabo de publicar aquí el mío en caso de que pueda ayudar a alguien. Esta respuesta es válida solo si no necesita un formato específico .

Swift 3

extension String {
    var toDouble: Double {
        return Double(self) ?? 0.0
    }
}

Prueba esto:

   var myDouble = myString.bridgeToObjectiveC().doubleValue
   println(myDouble)

NOTA

Eliminado en Beta 5. ¿Esto ya no funciona?

Esto se basa en la respuesta de @Ryu

Su solución es excelente siempre que esté en un país donde los puntos se usan como separadores. Por defecto NSNumberFormatterusa la configuración regional de los dispositivos. Por lo tanto, esto fallará en todos los países donde se utiliza una coma como separador predeterminado (incluido Francia como @PeterK. Mencionado) si el número usa puntos como separadores (que normalmente es el caso). Para establecer la configuración regional de este NSNumberFormatter en EE. UU. Y, por lo tanto, usar puntos como separadores reemplaza la línea

return NSNumberFormatter().numberFromString(self)?.doubleValue

con

let numberFormatter = NSNumberFormatter()
numberFormatter.locale = NSLocale(localeIdentifier: "en_US_POSIX")
return numberFormatter.numberFromString(self)?.doubleValue

Por lo tanto, el código completo se convierte

extension String {
    func toDouble() -> Double? {
        let numberFormatter = NSNumberFormatter()
        numberFormatter.locale = NSLocale(localeIdentifier: "en_US_POSIX")
        return numberFormatter.numberFromString(self)?.doubleValue
    }
}

Para usar esto, solo llame "Your text goes here".toDouble()

Esto devolverá un opcional Double?

Como @Ryu mencionó, puedes forzar el desenvolvimiento:

println("The value is \(myDouble!)") // prints: The value is 4.2

o use una if letdeclaración:

if let myDouble = myDouble {
    println("The value is \(myDouble)") // prints: The value is 4.2
}

SWIFT 4

extension String {
    func toDouble() -> Double? {
        let numberFormatter = NumberFormatter()
        numberFormatter.locale = Locale(identifier: "en_US_POSIX")
        return numberFormatter.number(from: self)?.doubleValue
    }
}

Swift 4.0

prueba esto

 let str:String = "111.11"
 let tempString = (str as NSString).doubleValue
 print("String:-",tempString)

Swift: 4 y 5

Posiblemente hay dos formas de hacer esto:

1. Cadena -> Int -> Doble:

   let strNumber = "314"
   if let intFromString = Int(strNumber){
       let dobleFromInt = Double(intFromString)
       print(dobleFromInt)
   }

2. Cadena -> NSString -> Doble

   let strNumber1 = "314"
   let NSstringFromString = NSString(string: strNumber1)
   let doubleFromNSString = NSstringFromString.doubleValue
   print(doubleFromNSString)

Úselo de la manera que desee según la necesidad del código.

Por favor, compruébalo en el patio de recreo!

let sString = "236.86"

var dNumber = NSNumberFormatter().numberFromString(sString)
var nDouble = dNumber!
var eNumber = Double(nDouble) * 3.7

Por cierto en mi Xcode

.toDouble () - no existe

.doubleValue crea el valor 0.0 a partir de cadenas no numéricas ...

1)

let strswift = "12"
let double = (strswift as NSString).doubleValue

2)

var strswift= "10.6"
var double : Double = NSString(string: strswift).doubleValue 

Puede ser esta ayuda para ti.

Como ya se señaló, la mejor manera de lograr esto es con el casting directo:

(myString as NSString).doubleValue

A partir de eso, puede hacer una elegante extensión nativa de Swift String:

extension String {
    var doubleValue: Double {
        return (self as NSString).doubleValue
    }
}

Esto le permite usar directamente:

myString.doubleValue

Que realizará el casting por ti. Si Apple agrega un doubleValuea la cadena nativa, solo necesita eliminar la extensión y el resto de su código se compilará automáticamente.

SWIFT 3

Para borrar, hoy en día hay un método predeterminado:

public init?(_ text: String)de Doubleclase.

Se puede usar para todas las clases.

let c = Double("-1.0") let f = Double("0x1c.6") let i = Double("inf") etc.

Extensión con configuración regional opcional

Swift 2.2

extension String {
    func toDouble(locale: NSLocale? = nil) -> Double? {
        let formatter = NSNumberFormatter()
        if let locale = locale {
            formatter.locale = locale
        }
        return formatter.numberFromString(self)?.doubleValue
    }
}

Swift 3.1

extension String {
    func toDouble(_ locale: Locale) -> Double {
        let formatter = NumberFormatter()
        formatter.numberStyle = .decimal
        formatter.locale = locale
        formatter.usesGroupingSeparator = true
        if let result = formatter.number(from: self)?.doubleValue {
            return result
        } else {
            return 0
        }
    }
}

O podrías hacer:

var myDouble = Double((mySwiftString.text as NSString).doubleValue)

Puedes usar StringEx . Se extiende Stringcon conversiones de cadena a número incluidas toDouble().

extension String {
    func toDouble() -> Double?
}

Verifica la cadena y falla si no se puede convertir al doble.

Ejemplo:

import StringEx

let str = "123.45678"
if let num = str.toDouble() {
    println("Number: \(num)")
} else {
    println("Invalid string")
}

Swift 4

extension String {
    func toDouble() -> Double {
        let nsString = self as NSString
        return nsString.doubleValue
    }
}

Lo que también funciona:

// Init default Double variable
var scanned: Double()

let scanner = NSScanner(string: "String to Scan")
scanner.scanDouble(&scanned)

// scanned has now the scanned value if something was found.

Use este código en Swift 2.0

let strWithFloat = "78.65" let floatFromString = Double(strWithFloat)

Usar Scanneren algunos casos es una forma muy conveniente de extraer números de una cadena. Y es casi tan poderoso como NumberFormattercuando se trata de decodificar y manejar diferentes formatos de números y configuraciones regionales. Puede extraer números y monedas con diferentes separadores decimales y de grupo.

import Foundation
// The code below includes manual fix for whitespaces (for French case)
let strings = ["en_US": "My salary is $9,999.99",
               "fr_FR": "Mon salaire est 9 999,99€",
               "de_DE": "Mein Gehalt ist 9999,99€",
               "en_GB": "My salary is £9,999.99" ]
// Just for referce
let allPossibleDecimalSeparators = Set(Locale.availableIdentifiers.compactMap({ Locale(identifier: $0).decimalSeparator}))
print(allPossibleDecimalSeparators)
for str in strings {
    let locale = Locale(identifier: str.key)
    let valStr = str.value.filter{!($0.isWhitespace || $0 == Character(locale.groupingSeparator ?? ""))}
    print("Value String", valStr)

    let sc = Scanner(string: valStr)
    // we could do this more reliably with `filter` as well
    sc.charactersToBeSkipped = CharacterSet.decimalDigits.inverted
    sc.locale = locale

    print("Locale \(locale.identifier) grouping separator: |\(locale.groupingSeparator ?? "")| . Decimal separator: \(locale.decimalSeparator ?? "")")
    while !(sc.isAtEnd) {
        if let val = sc.scanDouble() {
            print(val)
        }

    }
}

Sin embargo, hay problemas con los separadores que podrían concebirse como delimitadores de palabras.

// This doesn't work. `Scanner` just ignores grouping separators because scanner tends to seek for multiple values
// It just refuses to ignore spaces or commas for example.
let strings = ["en_US": "$9,999.99", "fr_FR": "9999,99€", "de_DE": "9999,99€", "en_GB": "£9,999.99" ]
for str in strings {
    let locale = Locale(identifier: str.key)
    let sc = Scanner(string: str.value)
    sc.charactersToBeSkipped = CharacterSet.decimalDigits.inverted.union(CharacterSet(charactersIn: locale.groupingSeparator ?? ""))
    sc.locale = locale
    print("Locale \(locale.identifier) grouping separator: \(locale.groupingSeparator ?? "") . Decimal separator: \(locale.decimalSeparator ?? "")")
    while !(sc.isAtEnd) {
        if let val = sc.scanDouble() {
            print(val)
        }

    }
}
//     sc.scanDouble(representation: Scanner.NumberRepresentation) could help if there were .currency case

No hay problema para detectar automáticamente la configuración regional. Tenga en cuenta que el separador de agrupación en francés en la cadena "Mon salaire est 9 999,99 €" no es un espacio, aunque puede representar exactamente como espacio (aquí no lo hace). Es por eso que el siguiente código funciona bien sin !$0.isWhitespaceque se filtren los caracteres.

let stringsArr = ["My salary is $9,999.99",
                  "Mon salaire est 9 999,99€",
                  "Mein Gehalt ist 9.999,99€",
                  "My salary is £9,999.99" ]

let tagger = NSLinguisticTagger(tagSchemes: [.language], options: Int(NSLinguisticTagger.Options.init().rawValue))
for str in stringsArr {
    tagger.string = str
    let locale = Locale(identifier: tagger.dominantLanguage ?? "en")
    let valStr = str.filter{!($0 == Character(locale.groupingSeparator ?? ""))}
    print("Value String", valStr)

    let sc = Scanner(string: valStr)
    // we could do this more reliably with `filter` as well
    sc.charactersToBeSkipped = CharacterSet.decimalDigits.inverted
    sc.locale = locale

    print("Locale \(locale.identifier) grouping separator: |\(locale.groupingSeparator ?? "")| . Decimal separator: \(locale.decimalSeparator ?? "")")
    while !(sc.isAtEnd) {
        if let val = sc.scanDouble() {
            print(val)
        }

    }
}
// Also will fail if groupingSeparator == decimalSeparator (but don't think it's possible)

Encuentro más legible agregar una extensión a String de la siguiente manera:

extension String {
    var doubleValue: Double {
        return (self as NSString).doubleValue
    }
}

y luego podrías escribir tu código:

myDouble = myString.doubleValue

mi problema era una coma, así que lo resuelvo de esta manera:

extension String {
    var doubleValue: Double {
        return Double((self.replacingOccurrences(of: ",", with: ".") as NSString).doubleValue)
    }
}

var stringValue = "55"

var convertToDouble = Double((stringValue as NSString).doubleValue)

podemos usar el valor CDouble que será obtenido por myString.doubleValue