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

Question

इससे पहले कि मैं xCode 6 को अपडेट करता, मुझे एक स्ट्रिंग को डबल कास्टिंग करने में कोई समस्या नहीं थी, लेकिन अब यह मुझे एक त्रुटि देता है

var a: Double = 1.5
var b: String = String(a)

यह मुझे त्रुटि संदेश देता है "डबल स्ट्रिंग के लिए परिवर्तनीय नहीं है"। क्या इसका कोई और तरीका है?

Comments

यह सिर्फ इसे परिभाषित करने के लिए भी उपयोगी हो सकता है जैसेvar b = "\(a)"

— erdekhayser

Answer 1

यह कास्टिंग नहीं है, यह एक प्रारूप के साथ एक मूल्य से एक स्ट्रिंग बना रहा है।

let a: Double = 1.5
let b: String = String(format: "%f", a)

print("b: \(b)") // b: 1.500000

एक अलग प्रारूप के साथ:

let c: String = String(format: "%.1f", a)

print("c: \(c)") // c: 1.5

formatयदि कोई स्वरूपण आवश्यक नहीं है, तो आप संपत्ति को छोड़ भी सकते हैं ।

Comments

एक बड़े अंश अंकों के साथ एक डबल के बारे में क्या? जैसे a = 2.34934340320 को stringValue = स्ट्रिंग (प्रारूप: "% f"), a) 2.349343

— Nico

डिस्प्ले को प्रिंटफ़ प्रारूपण विकल्पों के साथ नियंत्रित किया जा सकता है, देखें: स्ट्रिंग प्रारूप विनिर्देशक और प्रिंटफ़ (3) ।

— ज़ाफ

आप अंक की मात्रा को नियंत्रित करने के लिए अपने स्वरूप बदलने के लिए है बस: format:"%.1f" = 1 digit // 1.5; format:"%.5f" = 5 digits // 1.50000

— मेगाट्रॉन

कृपया अपना उत्तर अपडेट करें, स्विफ्ट 2.1 में आपको बस करना है String(yourDouble)।

— अलेक्जेंड्रे जी।

आप var की जगह let का उपयोग कर सकते हैं। इसे कई बार कॉल करने की आवश्यकता नहीं है।

— ऑलेक्ज़ेंडर

Answer 2

let double = 1.5 
let string = double.description

अपडेट Xcode 7.1 • स्विफ्ट 2.1:

अब डबल स्ट्रिंग के लिए भी परिवर्तनीय है ताकि आप इसे अपनी इच्छानुसार उपयोग कर सकें:

let double = 1.5
let doubleString = String(double)   // "1.5"

स्विफ्ट 3 या बाद में हम LosslessStringConvertibleइसे सामान्य बना सकते हैं

Xcode 11.3 • स्विफ्ट 5.1 या बाद में

extension LosslessStringConvertible { 
    var string: String { .init(self) } 
}

---

let double = 1.5 
let string = double.string  //  "1.5"

---

अंश अंकों की एक निश्चित संख्या के लिए हम FloatingPointप्रोटोकॉल का विस्तार कर सकते हैं :

extension FloatingPoint {
    func fixedFraction(digits: Int) -> String {
        return String(format: "%.*f", digits, self as! CVarArg)
    }
}

---

यदि आपको अपने संख्या प्रारूप (न्यूनतम और अधिकतम अंश अंक और गोलाई मोड) पर अधिक नियंत्रण की आवश्यकता है तो आप नंबरफ़ॉर्मर का उपयोग कर सकते हैं:

extension Formatter {
    static let number = NumberFormatter()
}

---

extension FloatingPoint {
    func fractionDigits(min: Int = 2, max: Int = 2, roundingMode: NumberFormatter.RoundingMode = .halfEven) -> String {
        Formatter.number.minimumFractionDigits = min
        Formatter.number.maximumFractionDigits = max
        Formatter.number.roundingMode = roundingMode
        Formatter.number.numberStyle = .decimal
        return Formatter.number.string(for: self) ?? ""
    }
}

---

2.12345.fractionDigits()                                    // "2.12"
2.12345.fractionDigits(min: 3, max: 3, roundingMode: .up)   // "2.124"

Comments

क्या यह हैक है या यह इसे करने का एक कानूनी तरीका है? यह विभिन्न आईओएस संस्करणों के साथ किसी भी समस्या का कारण होगा?

— एसकरौर्थ

नहीं, आपको अलग-अलग आईओएस संस्करणों के साथ कोई समस्या नहीं होगी। यह OSX के लिए भी काम करता है। BTW यह वही है जो आपको एक डबल या इंट के साथ स्ट्रिंग इंटरपोलेशन करते समय मिलता है।

— सिंह Dabus

बहुत उपयोगी। आप% f की तरह प्रारूपित नहीं कर सकते। और यह Int के लिए भी काम करता है इसलिए आपके पास इसे दो तरह से करने का एक तरीका है।

— पेट्रिक वबेरर

यह 0.00001 के लिए काम नहीं करेगा, यह एक स्ट्रिंग के रूप में "1e-05" बन जाता है।

— एलेक्स

के String(format: "%.\(digits)f", self as! CVarArg)साथ बदलेंString(format: "%.*f", digits, self as! CVarArg)

— 18

Answer 3

@Zaph उत्तर के अलावा, आप बना सकते हैं extension:

extension Double {
    func toString() -> String {
        return String(format: "%.1f",self)
    }
}

---

उपयोग:

var a:Double = 1.5
println("output: \(a.toString())")  // output: 1.5

Comments

@MaximShoustin ओपी के पास वोट और जवाब देने के लिए पर्याप्त प्रतिनिधि नहीं है, 15 की आवश्यकता है। मैं एक एक्सटेंशन बनाने से भी असहमत हूं, जब बयान: a.toString()किसी अन्य डेवलपर द्वारा देखा जाता है तो निश्चित रूप से एक डब्ल्यूटीएफ क्षण होगा।

— zaph

@Zaph क्यों नहीं। सुनिश्चित करें कि आप कुछ उपसर्ग जोड़ सकते हैं और इसे बदल सकते हैंmyToString() सुनिश्चित करें कि इसकी कस्टम परिभाषा। लेकिन अन्य भाषाओं की तरह प्रोटोटाइपिंग से कोड डुप्लिकेट और अच्छे रखरखाव से बचा जाता है।

— मैक्सिम Shoustin

@MaximShoustin नौसिखिया सवाल: क्या अंतर है println("output: \(a.toString())")और println("output: \(a)")। दूसरा विकल्प संकलन त्रुटियों का कारण नहीं बनता है। क्या यह विकल्प एक बुरा अभ्यास है?

— एलेक्स गुएरेरो

क्या डबल या फ्लोटिंगपॉइंट के लिए इस तरह के विस्तार को लिखने का एक चतुर तरीका है जो एक खाली स्ट्रिंग को वापस करने के लिए वैकल्पिक डबल पर काम करेगा?

— किनेर्ज

@ एलर्जीyourDouble?.toString() ?? ""

— लियो डबस

Answer 4

स्विफ्ट 3+: कोड की इन लाइन को आज़माएं

let num: Double = 1.5

let str = String(format: "%.2f", num)

Answer 5

कुछ भी तेजी से एक स्ट्रिंग बनाने के लिए हो सकता है सिवाय इसके कि एनम वैल्यू बस वही करें जो आप प्रिंटनल () विधि में करते हैं

उदाहरण के लिए:

var stringOfDBL = "\(myDouble)"

Answer 6

स्विफ्ट 4 : निम्नलिखित कोड का उपयोग करें

let number = 2.4
let string = String(format: "%.2f", number)

Comments

यह उसी तरह का समाधान है जैसा @ shiv-kumar stackoverflow.com/

— Eric Aya

Answer 7

यह फ़ंक्शन आपको दिखाने के लिए दशमलव स्थानों की संख्या निर्दिष्ट करने देगा:

func doubleToString(number:Double, numberOfDecimalPlaces:Int) -> String {
    return String(format:"%."+numberOfDecimalPlaces.description+"f", number)
}

उपयोग:

let numberString = doubleToStringDecimalPlacesWithDouble(number: x, numberOfDecimalPlaces: 2)

Comments

बदलें String(format:"%."+numberOfDecimalPlaces.description+"f", number)के साथString(format:"%.*f", numberOfDecimalPlaces, number)

— rmaddy

Answer 8

यहाँ कई उत्तर हैं जो विभिन्न प्रकार की तकनीकों का सुझाव देते हैं। लेकिन जब यूआई में नंबर पेश करते हैं, तो आप हमेशा उपयोग करना चाहते हैं NumberFormatterताकि परिणाम ठीक से स्वरूपित, गोल और स्थानीयकृत हों:

let value = 10000.5

let formatter = NumberFormatter()
formatter.numberStyle = .decimal

guard let string = formatter.string(for: value) else { return }
print(string) // 10,000.5

यदि आप दशमलव स्थानों की निश्चित संख्या चाहते हैं, जैसे मुद्रा मूल्यों के लिए

let value = 10000.5

let formatter = NumberFormatter()
formatter.numberStyle = .decimal
formatter.maximumFractionDigits = 2
formatter.minimumFractionDigits = 2

guard let string = formatter.string(for: value) else { return }
print(string) // 10,000.50

लेकिन इस दृष्टिकोण की सुंदरता यह है कि यह ठीक से स्थानीयकृत होगा, जिसके परिणामस्वरूप 10,000.50अमेरिका में लेकिन 10.000,50जर्मनी में होगा। विभिन्न स्थानों में संख्याओं के लिए अलग-अलग पसंदीदा प्रारूप हैं, और हमें NumberFormatterयूआई के भीतर संख्यात्मक मान प्रस्तुत करते समय अंतिम उपयोगकर्ता द्वारा पसंद किए गए प्रारूप का उपयोग करने देना चाहिए ।

NumberFormatterयूआई के भीतर स्ट्रिंग प्रतिनिधित्व तैयार करते समय कहने के लिए आवश्यक नहीं है, यह तब उपयोग नहीं किया जाना चाहिए जब लगातार मान भंडारण, वेब सेवाओं के साथ इंटरफ़ेस, आदि के लिए संख्यात्मक मान लिखते हैं।

Comments

इसे सही उत्तर के रूप में चिह्नित किया जाना चाहिए

— असद खान

Answer 9

स्विफ्ट 3 में:

var a: Double = 1.5
var b: String = String(a)

Answer 10

स्विफ्ट 3 में यह नीचे दिए गए अनुसार सरल है

let stringDouble =  String(describing: double)

Comments

यह "Optional(6.1696108999999995)"मेरे लिए उदाहरण देता है।

— मैकुलसिवन डी'एंडर

Answer 11

var b = String(stringInterpolationSegment: a)

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

Answer 12

स्विफ्ट 4 में अगर आप यूआई में टेक्स्टलेबेल "स्ट्रिंग" के रूप में डबल को संशोधित करना और उपयोग करना पसंद करते हैं, तो आप इसे अपनी फ़ाइल के अंत में जोड़ सकते हैं:

    extension Double {
func roundToInt() -> Int{
    return Int(Darwin.round(self))
}

}

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

currentTemp.text = "\(weatherData.tempCelsius.roundToInt())"

या इसे इंट के रूप में प्रिंट करें:

print(weatherData.tempCelsius.roundToInt())

Answer 13

मैं NSNumber और NumberFormatter एप्रोच (जहां जरूरत हो) को प्राथमिकता दूंगा, यू भी ब्लोटिंग कोड से बचने के लिए एक्सटेंशन का उपयोग कर सकता है

extension Double {

   var toString: String {
      return NSNumber(value: self).stringValue
   }

}

यू को रिवर्स दृष्टिकोण की भी आवश्यकता हो सकती है

extension String {

    var toDouble: Double {
        return Double(self) ?? .nan
    }

}

Comments

क्यों आप वैकल्पिक लौट रहे हैं लेकिन असाइन कर रहे हैं। यदि शून्य है? आपको एक या दूसरे को करना चाहिए। दोनों नहीं। स्ट्रिंग प्रारंभक का उपयोग करने के साथ गलत Btw क्या? आप LossLessStringConvertibleextension LosslessStringConvertible { var string: String { return .init(self) } }

— लियो डबस

यू डबल लौट रहे हैं? मना कर दिया है क्योंकि मैं पहले से ही जाँच कर रहा हूँ कि यह शून्य है और NaN लौटाता है

— Giuseppe Mazzilli

Answer 14

स्विफ्ट 5 : निम्नलिखित कोड का उपयोग करें

extension Double {

    func getStringValue(withFloatingPoints points: Int = 0) -> String {
        let valDouble = modf(self)
        let fractionalVal = (valDouble.1)
        if fractionalVal > 0 {
            return String(format: "%.*f", points, self)
        }
        return String(format: "%.0f", self)
    }
}

Comments

इसके String(format: "%.\(points)f", self)साथ बदलेंString(format: "%.*f", points, self)

— rammdy