Swift - Come convertire String in Double

Sto cercando di scrivere un programma BMI in un linguaggio veloce. E ho avuto questo problema: come convertire una stringa in un doppio?

In Objective-C, posso fare così:

double myDouble = [myString doubleValue];

Ma come posso raggiungere questo obiettivo in linguaggio Swift?

Swift 4.2+ String to Double

È necessario utilizzare i nuovi inizializzatori di tipi per convertire tra tipi String e numerici (Double, Float, Int). Restituirà un tipo opzionale (doppio?) Che avrà il valore corretto o nullo se la stringa non fosse un numero.

Nota: la proprietà NSString doubleValue non è consigliata perché restituisce 0 se il valore non può essere convertito (ovvero: input utente errato).

let lessPrecisePI = Float("3.14")

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

Scartare i valori per usarli 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!)")
}

Puoi convertire numeri e valuta formattati usando la NumberFormatterclasse.

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

Formati di valuta

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")

Maggiori informazioni sul mio post sul blog sulla conversione di stringhe in tipi doppi (e valuta) .

Swift 2 Aggiornamento Ci sono nuovi inizializzatori failable che ti permettono di fare questo in modo più idiomatica e sicuro (come molte risposte hanno notato, il valore doppio di NSString non è molto sicuro perché restituisce 0 per i valori non numerici. Ciò significa che il doubleValuedi "foo"e "0"sono lo stesso.)

let myDouble = Double(myString)

Questo restituisce un facoltativo, quindi in casi come passare "foo"dove doubleValueavrebbe restituito 0, verrà restituito l'intializer disponibile nil. È possibile utilizzare una guard, if-leto mapper gestire ilOptional<Double>

Messaggio originale: non è necessario utilizzare il costruttore NSString come propone la risposta accettata. Puoi semplicemente collegarlo in questo modo:

(swiftString as NSString).doubleValue

Per un po 'più di sensibilità Swift, l'uso NSFormatter()evita il casting NSStringe restituisce nilquando la stringa non contiene un Doublevalore (ad es. "Test" non ritorna 0.0).

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

In alternativa, estendere il Stringtipo di Swift :

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

e usalo come toInt():

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

Questo restituisce un optional Double?che deve essere scartato.

In caso di scartamento forzato:

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

o con un'istruzione if let:

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

Aggiornamento: per la localizzazione, è molto semplice applicare le impostazioni locali al NSFormatter come segue:

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

Infine, è possibile utilizzare NSNumberFormatterCurrencyStylesul formatter se si lavora con valute in cui la stringa contiene il simbolo di valuta.

Un'altra opzione qui è convertire questo in un NSStringe usarlo:

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

Ecco un metodo di estensione che ti consente di chiamare semplicemente doubleValue () su una stringa Swift e ottenere un doppio back (l'output di esempio viene prima)

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

Ecco il metodo di estensione:

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
    }
}

Nessun controllo errori, ma puoi aggiungerlo se ne hai bisogno.

A partire da Swift 1.1, puoi passare direttamente Stringal const char *parametro.

import Foundation

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

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

Se non ti piace deprecato atof:

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

Un avvertimento: il comportamento della conversione è diverso da NSString.doubleValue.

atofe strtodaccetta la 0xstringa esadecimale con prefisso:

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

Se preferisci il .doubleValuecomportamento, possiamo comunque usare il CFStringbridge:

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

In Swift 2.0 il modo migliore è evitare di pensare come uno sviluppatore di Objective-C. Quindi non dovresti "convertire una stringa in una doppia" ma dovresti "inizializzare una doppia da una stringa". Documento Apple qui: https://developer.apple.com/library/ios//documentation/Swift/Reference/Swift_Double_Structure/index.html#//apple_ref/swift/structctr/Double/s:FSdcFMSdFSSGSqSd_

È un init opzionale, quindi puoi usare l'operatore di coalescenza zero (??) per impostare un valore predefinito. Esempio:

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

Su SWIFT 3 , puoi utilizzare:

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

Nota: - Se una stringa contiene caratteri diversi da cifre numeriche, gruppi appropriati per la locale o separatori decimali, l'analisi avrà esito negativo. - Qualsiasi carattere di separazione spazio iniziale o finale in una stringa viene ignorato. Ad esempio, le stringhe “5”, “5” e “5” producono tutte il numero 5.

Tratto dalla documentazione: https://developer.apple.com/reference/foundation/numberformatter/1408845-number

Non ho visto la risposta che cercavo. Ho appena pubblicato qui il mio nel caso in cui possa aiutare chiunque. Questa risposta è valida solo se non è necessario un formato specifico .

Swift 3

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

Prova questo:

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

NOTA

Rimosso in Beta 5. Questo non funziona più?

Questo si basa sulla risposta di @Ryu

La sua soluzione è eccezionale fintanto che ti trovi in ​​un paese in cui i punti vengono utilizzati come separatori. Per impostazione predefinita NSNumberFormatterutilizza la locale dei dispositivi. Pertanto, ciò fallirà in tutti i paesi in cui una virgola viene utilizzata come separatore predefinito (inclusa la Francia come @PeterK. Menzionato) se il numero utilizza punti come separatori (che è normalmente il caso). Per impostare la locale di questo NSNumberFormatter su US e quindi utilizzare i punti come separatori sostituiscono la linea

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

con

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

Pertanto, il codice completo diventa

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

Per usare questo, basta chiamare "Your text goes here".toDouble()

Questo restituirà un facoltativo Double?

Come accennato da @Ryu, puoi forzare lo scartamento:

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

o usa una if letdichiarazione:

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

prova questo

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

Swift: 4 e 5

Esistono due modi per farlo:

1. String -> Int -> Double:

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

2. String -> NSString -> Double

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

Usalo comunque come preferisci in base alle necessità del codice.

Si prega di controllare nel parco giochi!

let sString = "236.86"

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

A proposito nel mio Xcode

.toDouble () - non esiste

.doubleValue crea valore 0.0 da stringhe non numeriche ...

1.

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

2.

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

Potrebbe essere questo aiuto per te.

Come già sottolineato, il modo migliore per raggiungere questo obiettivo è con il casting diretto:

(myString as NSString).doubleValue

Partendo da questo, puoi creare un'estensione nativa di Swift String:

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

Ciò ti consente di utilizzare direttamente:

myString.doubleValue

Che eseguirà il casting per te. Se Apple aggiunge doubleValuea alla stringa nativa, devi solo rimuovere l'estensione e il resto del codice verrà automaticamente compilato correttamente!

SWIFT 3

Per cancellare, al giorno d'oggi esiste un metodo predefinito:

public init?(_ text: String)di Doubleclasse.

Può essere utilizzato per tutte le classi.

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

Estensione con impostazioni internazionali opzionali

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
        }
    }
}

Oppure potresti fare:

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

Puoi usare StringEx . Si estende Stringcon conversioni da stringa a numero incluso toDouble().

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

Verifica la stringa e non riesce se non può essere convertita in double.

Esempio:

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
    }
}

Cosa funziona anche:

// 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.

Usa questo codice in Swift 2.0

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

L'uso Scannerin alcuni casi è un modo molto conveniente per estrarre numeri da una stringa. Ed è quasi potente quanto NumberFormatterquando si tratta di decodificare e gestire diversi formati numerici e locali. Può estrarre numeri e valute con separatori decimali e di gruppo diversi.

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)
        }

    }
}

Tuttavia, ci sono problemi con i separatori che potrebbero essere concepiti come delimitatori di parole.

// 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

Non ci sono problemi per il rilevamento automatico delle impostazioni internazionali. Si noti che il raggruppamento Separatore in locale francese nella stringa "Mon salaire est 9 999,99 €" non è uno spazio, sebbene possa essere visualizzato esattamente come spazio (qui non lo è). Ecco perché il codice seguente funziona bene senza che i !$0.isWhitespacecaratteri vengano filtrati.

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)

Trovo più leggibile per aggiungere un'estensione a String come segue:

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

e poi potresti semplicemente scrivere il tuo codice:

myDouble = myString.doubleValue

il mio problema era la virgola quindi lo risolvo in questo modo:

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

var stringValue = "55"

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

possiamo usare il valore CDouble che sarà ottenuto da myString.doubleValue