road - swift vxi




स्विफ्ट-स्ट्रिंग टू डबल को कैसे परिवर्तित करें (18)

स्विफ्ट 4.0

इसे इस्तेमाल करे

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

मैं तेजी से भाषा में एक बीएमआई प्रोग्राम लिखने की कोशिश कर रहा हूँ। और मुझे यह समस्या मिली: एक स्ट्रिंग को एक डबल में कैसे परिवर्तित करें?

उद्देश्य-सी में, मैं ऐसा कर सकता हूं:

double myDouble = [myString doubleValue];

लेकिन मैं इसे स्विफ्ट भाषा में कैसे प्राप्त कर सकता हूं?


1।

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

2।

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

आपके लिए यह मदद हो सकती है।


इसे इस्तेमाल करे:

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

ध्यान दें

बीटा 5 में हटाया गया। यह अब काम नहीं करता है?


क्या काम करता है:

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

जैसा कि पहले से ही बताया गया है, इसे प्राप्त करने का सबसे अच्छा तरीका प्रत्यक्ष कास्टिंग के साथ है:

(myString as NSString).doubleValue

उस से बिल्डिंग, आप एक स्लिम देशी स्विफ्ट स्ट्रिंग एक्सटेंशन बना सकते हैं:

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

यह आपको सीधे उपयोग करने की अनुमति देता है:

myString.doubleValue

जो आपके लिए कास्टिंग करेगा। यदि ऐप्पल देशी स्ट्रिंग में doubleValue है तो आपको केवल एक्सटेंशन को हटाने की आवश्यकता है और आपका शेष कोड स्वचालित रूप से ठीक हो जाएगा!


मेरी समस्या अल्पविराम थी इसलिए मैं इसे इस तरह हल करता हूं:

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

यह @Ryu द्वारा जवाब पर निर्माण कर रहा है

उनका समाधान तब तक बढ़िया है जब तक आप ऐसे देश में हों जहां डिपर्स को विभाजक के रूप में उपयोग किया जाता है। डिफ़ॉल्ट रूप से NSNumberFormatter डिवाइस लोकेल का उपयोग करता है। इसलिए यह उन सभी देशों में असफल हो जाएगा जहां अल्पविराम को अलग-अलग विभाजक (फ्रांस सहित @ पीटरके के रूप में वर्णित किया गया है) के रूप में उपयोग किया जाता है यदि संख्या अलग-अलग के रूप में डॉट्स का उपयोग करती है (जो आमतौर पर मामला है)। इस NSNumberFormatter के लोकेल को यूएस होने के लिए सेट करने के लिए और इस प्रकार डॉट्स का उपयोग करें क्योंकि विभाजक लाइन को प्रतिस्थापित करते हैं

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

साथ में

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

इसलिए पूरा कोड बन जाता है

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

इसका उपयोग करने के लिए, बस "Your text goes here".toDouble() कॉल करें "Your text goes here".toDouble()

यह एक वैकल्पिक Double? वापस करेगा 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
}

यहां एक और विकल्प इसे एनएसएसटींग में परिवर्तित कर रहा है और इसका उपयोग कर रहा है:

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

या आप कर सकते हैं:

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

वैकल्पिक लोकेल के साथ विस्तार

स्विफ्ट 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
    }
}

स्विफ्ट 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
        }
    }
}

स्विफ्ट 1.1 के रूप में, आप सीधे String को const char * पैरामीटर पास कर सकते हैं।

import Foundation

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

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

यदि आप को बहिष्कृत पसंद नहीं है:

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

एक चेतावनी: रूपांतरण का व्यवहार NSString.doubleValue से अलग है।

atof और strtod 0x prefixed हेक्स स्ट्रिंग स्वीकार करते हैं:

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

स्विफ्ट 2.0 में इस कोड का प्रयोग करें

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


हम सीडीबल वैल्यू का उपयोग कर सकते हैं जो myString.doubleValue द्वारा प्राप्त किया जाएगा


NSFormatter() का उपयोग करके NSFormatter() का उपयोग करने से थोड़ा अधिक स्विफ्ट महसूस करने के लिए, और स्ट्रिंग में Double मान नहीं होता है (उदाहरण के लिए "टेस्ट" 0.0 वापस नहीं करेगा)।

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

वैकल्पिक रूप से, स्विफ्ट के String प्रकार का विस्तार:

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 myDouble = myDouble {
    println("The value is \(myDouble)") // prints: The value is 4.2
}

अद्यतन: स्थानीयकरण के लिए, एनएसएफॉर्मेटर को स्थानीय रूप से लागू करना बहुत आसान है:

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

अंत में, आप NSNumberFormatterCurrencyStyle पर NSNumberFormatterCurrencyStyle उपयोग कर सकते हैं यदि आप मुद्राओं के साथ काम कर रहे हैं जहां स्ट्रिंग में मुद्रा चिह्न होता है।


स्विफ्ट 2+ स्ट्रिंग डबल करने के लिए

स्ट्रिंग और न्यूमेरिक प्रकारों (डबल, फ्लोट, इंट) के बीच कनवर्ट करने के लिए आपको नए प्रकार के प्रारंभकर्ताओं का उपयोग करना चाहिए। यह एक वैकल्पिक प्रकार (डबल?) वापस करेगा, जिसमें स्ट्रिंग एक संख्या नहीं थी, तो सही मूल्य या शून्य होगा।

नोट: NSString DoubleValue प्रॉपर्टी की अनुशंसा नहीं की जाती है क्योंकि मान को परिवर्तित नहीं किया जा सकता है (यानी: खराब उपयोगकर्ता इनपुट)।

स्विफ्ट 2+ विधि का प्रयोग करें

let lessPrecisePI = Float("3.14")

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

मानों का उपयोग करके उन्हें उपयोग करने के लिए मूल्यों को अनवरोधित करें

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

स्ट्रिंग से डबल प्रकारों को परिवर्तित करने के बारे में मेरे ब्लॉग पोस्ट पर और पढ़ें।


स्विफ्ट 3 पर , आप इसका उपयोग कर सकते हैं:

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

नोट: - यदि किसी स्ट्रिंग में संख्यात्मक अंक या लोकेल-उपयुक्त समूह या दशमलव विभाजक के अलावा कोई वर्ण शामिल है, तो पार्सिंग विफल हो जाएगी। - स्ट्रिंग में किसी भी अग्रणी या पिछली जगह विभाजक वर्णों को नजरअंदाज कर दिया जाता है। उदाहरण के लिए, तार "5", "5", और "5" सभी संख्या 5 उत्पन्न करते हैं।

प्रलेखन से लिया गया: https://developer.apple.com/reference/foundation/numberformatter/1408845-number


स्विफ्ट 4

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

स्विफ्ट: - 4

ऐसा करने के लिए संभवतः दो तरीके हैं:

  1. स्ट्रिंग -> Int -> डबल:

    let strNumber = "314"
    let intFromString = Int(strNumber)
    let dobleFromInt = Double(intFromString!)
    print(dobleFromInt)
    
  2. स्ट्रिंग -> एनएसएसटींग -> डबल

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

वैसे भी इसका प्रयोग करें जैसा कि आपको कोड की आवश्यकता के हिसाब से पसंद है।





swift