Преобразование текста из строки в двойную [дубликат]

Swift: - 4

Возможно, есть два способа сделать это:

1. String -> Int -> Double:

   let strNumber = "314"
   let intFromString = Int(strNumber)
   let dobleFromInt = Double(intFromString!)
   print(dobleFromInt)
   

2. String -> NSString -> Double

   let strNumber = "314"
   let NSstringFromString = NSString(string: strNumber as! NSString)
   let doubleFromNSString = NSstringFromString.doubleValue
   print(doubleFromNSString)
   

Используйте его так, как вам нравится, в соответствии с вашим кодом.

мы можем использовать значение CDouble, которое будет получено myString.doubleValue

Что также работает:

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

Попробуйте следующее:

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

ПРИМЕЧАНИЕ

Удалено в бета-версии 5. Это больше не работает?

1.

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

2.

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

Может быть, эта помощь для вас.

Для немного более быстрого ощущения, используя NSFormatter(), избегает кастинга NSString и возвращает nil, когда строка не содержит значения Double (например, «тест» не вернет 0.0).

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

Альтернативно, расширяя тип String Swift:

extension String {
    func toDouble() -> Double? {
        return NSNumberFormatter().numberFromString(self)?.doubleValue
    }
}

и используйте его как toInt():

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

Это возвращает необязательно Double?, который необходимо развернуть.

Либо с принудительной разверткой:

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

, либо с помощью инструкции if let:

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

Update : Для локализации очень легко применять локали к NSFormatter следующим образом:

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

Наконец, вы можете использовать NSNumberFormatterCurrencyStyle в форматировании, если работаете с валютами, где строка содержит валюту символ.

Как уже указывалось, лучший способ достичь этого - с прямым литьем:

(myString as NSString).doubleValue

Построим из этого, вы можете сделать плавное родное расширение Swift String:

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

Это позволяет вам прямо использовать:

myString.doubleValue

Который выполнит кастинг для вас. Если Apple добавит doubleValue к родной String, вам просто нужно удалить расширение, а остальная часть вашего кода будет автоматически компилироваться.

var stringValue = "55"

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

Обновление Swift 2 Есть новые отказоустойчивые инициализаторы, которые позволяют вам делать это более идиоматичным и безопасным способом (как было отмечено многими ответами, двойное значение NSString не очень безопасно, потому что оно возвращает 0 для значений без номера. Это означает, что doubleValue из "foo" и "0" одинаковы.)

let myDouble = Double(myString)

Это возвращает необязательный параметр, поэтому в случаях, например, в "foo", где doubleValue вернул 0, failable intializer вернет nil. Вы можете использовать guard, if-let или map для обработки Optional<Double>

Исходная запись: вам не нужно использовать конструктор NSString, как предлагает принятый ответ. Вы можете просто нарисовать его так:

(swiftString as NSString).doubleValue

В SWIFT 3 вы можете использовать:

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

Примечание: - Если строка содержит любые символы, отличные от числовых цифр или подходящие для локали группы или десятичные разделители, синтаксический анализ завершится с ошибкой. - Любые символы разделителя пробелов или строк в строке игнорируются. Например, строки «5», «5» и «5» производят номер 5.

Из документации: https://developer.apple.com/reference/ основа / NumberFormatter / 1408845 номер

Или вы могли бы сделать:

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

Другим вариантом здесь является преобразование этого в NSString и использование этого:

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

Пожалуйста, проверьте это на детской площадке!

let sString = "236.86"

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

Кстати, в моем Xcode

.toDouble () - не существует

.doubleValue создать значение 0.0 из не числовых строк ...

Используйте этот код в Swift 2.0

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

Расширение с дополнительным языком

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

Вот метод расширения, который позволяет вам просто вызвать doubleValue () в строке Swift и получить двойную обратную сторону (пример выводится первым)

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

Вот способ расширения:

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

Нет проверки ошибок, но вы можете добавить его, если вам это нужно.

моя проблема была запятой, поэтому я решаю ее следующим образом:

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

С Swift 1.1 вы можете напрямую передать параметр String в const char *.

import Foundation

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

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

Если вам не нравятся устаревшие atof:

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

Одно предупреждение: поведение преобразования отличается от NSString.doubleValue.

atof и strtod принять 0x префикс шестнадцатеричной строки:

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

Если вы предпочитают поведение .doubleValue, мы все еще можем использовать мост CFString:

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

Вы можете использовать StringEx . Он расширяет String с преобразованием строк в число, включая toDouble().

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

Он проверяет строку и терпит неудачу, если ее нельзя преобразовать в double.

Пример:

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 numberFormatter = NumberFormatter()
        numberFormatter.locale = Locale(identifier: "en_US_POSIX")
        return numberFormatter.number(from: self)?.doubleValue
    }
}

Я не видел ответа, который я искал. Я просто размещаю здесь свой, если он может помочь кому угодно. Этот ответ действителен только в том случае, если вам не нужен конкретный формат.

Swift 3

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

В Swift 2.0 лучший способ - не думать, как разработчик Objective-C. Таким образом, вы не должны «преобразовывать строку в двойную», но вам следует «инициализировать Double from the String». Apple doc здесь: https://developer.apple.com/library/ios//documentation/Swift/Reference/Swift_Double_Structure/index.html#//apple_ref/swift/structctr/Double/s:FSdcFMSdFSSGSqSd_

Это необязательный init, поэтому вы можете использовать оператор объединения nil (??) для установки значения по умолчанию. Пример:

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

Swift 4.0

попробуйте это

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

SWIFT 3

Чтобы очистить, в настоящее время существует метод по умолчанию:

public init?(_ text: String) класса Double.

Его можно использовать для все классы.

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