नीचे बताया गया है कि मैंने पहले कैसे दो दशमलव स्थानों पर एक फ्लोट किया था
NSLog(@" %.02f %.02f %.02f", r, g, b);मैंने डॉक्स और ई-पुस्तक की जाँच की लेकिन यह पता लगाने में सक्षम नहीं है। धन्यवाद!
नीचे बताया गया है कि मैंने पहले कैसे दो दशमलव स्थानों पर एक फ्लोट किया था
NSLog(@" %.02f %.02f %.02f", r, g, b);मैंने डॉक्स और ई-पुस्तक की जाँच की लेकिन यह पता लगाने में सक्षम नहीं है। धन्यवाद!
जवाबों:
डेविड की प्रतिक्रिया के बाद मेरा अब तक का सबसे अच्छा समाधान :
import Foundation
extension Int {
func format(f: String) -> String {
return String(format: "%\(f)d", self)
}
}
extension Double {
func format(f: String) -> String {
return String(format: "%\(f)f", self)
}
}
let someInt = 4, someIntFormat = "03"
println("The integer number \(someInt) formatted with \"\(someIntFormat)\" looks like \(someInt.format(someIntFormat))")
// The integer number 4 formatted with "03" looks like 004
let someDouble = 3.14159265359, someDoubleFormat = ".3"
println("The floating point number \(someDouble) formatted with \"\(someDoubleFormat)\" looks like \(someDouble.format(someDoubleFormat))")
// The floating point number 3.14159265359 formatted with ".3" looks like 3.142मुझे लगता है कि यह सबसे स्विफ्ट जैसा समाधान है, डेटा टाइप करने के लिए सीधे स्वरूपण संचालन को बांधता है। यह अच्छी तरह से हो सकता है कि कहीं-कहीं संचालन प्रारूप का एक अंतर्निहित पुस्तकालय है, या शायद यह जल्द ही जारी किया जाएगा। ध्यान रखें कि भाषा अभी भी बीटा में है।
एक सरल तरीका है:
import Foundation // required for String(format: _, _)
print(String(format: "hex string: %X", 123456))
print(String(format: "a float number: %.5f", 1.0321))println(String(format: "a float number: %.5f", 1.0321))
printfअलग-अलग एक्सटेंशन लिखने के बिना मानक सी-स्टाइल के बहुत करीब है ।
import Foundation
मुझे String.localizedStringWithFormatकाफी अच्छा काम करना पड़ा:
उदाहरण:
let value: Float = 0.33333
let unit: String = "mph"
yourUILabel.text = String.localizedStringWithFormat("%.2f %@", value, unit)यह एक बहुत तेज़ और सरल तरीका है जिसे जटिल समाधान की आवश्यकता नहीं है।
let duration = String(format: "%.01f", 3.32323242)
// result = 3.3Col 16: 'init' has been renamed to 'init(describing:)'
यहां अधिकांश उत्तर मान्य हैं। हालाँकि, यदि आप संख्या को अक्सर प्रारूपित करेंगे, तो एक स्वरूपित स्ट्रिंग लौटाने वाली विधि को जोड़ने के लिए फ्लोट वर्ग का विस्तार करने पर विचार करें। नीचे उदाहरण कोड देखें। यह एक नंबर फॉर्मेटर और एक्सटेंशन का उपयोग करके एक ही लक्ष्य को प्राप्त करता है।
extension Float {
func string(fractionDigits:Int) -> String {
let formatter = NSNumberFormatter()
formatter.minimumFractionDigits = fractionDigits
formatter.maximumFractionDigits = fractionDigits
return formatter.stringFromNumber(self) ?? "\(self)"
}
}
let myVelocity:Float = 12.32982342034
println("The velocity is \(myVelocity.string(2))")
println("The velocity is \(myVelocity.string(1))")कंसोल दिखाता है:
The velocity is 12.33
The velocity is 12.3extension Float {
func string(fractionDigits:Int) -> String {
let formatter = NumberFormatter()
formatter.minimumFractionDigits = fractionDigits
formatter.maximumFractionDigits = fractionDigits
return formatter.string(from: NSNumber(value: self)) ?? "\(self)"
}
}NSNumberFormatterइस उत्तर की तरह उपयोग करते । अन्य अत्यधिक मत वाले उत्तर केवल डिवाइस लोकेल सेटिंग्स को प्रतिबिंबित करने में विफल हो रहे हैं (जैसे कुछ स्थानों में, वे दशमलव स्थान पर अल्पविराम का उपयोग करते हैं; यह दर्शाता है कि; अन्य उत्तर नहीं हैं)।
NSNumberFormatterइसे शुरू करने के लिए काफी धीमी है। यदि संभव हो तो, यह एक को परिभाषित करने और पुन: उपयोग करने में मदद करता है। उस ने कहा, मैं यहां इस प्रश्न को पढ़ रहा हूं क्योंकि मेरे मामले में यह संभव नहीं है।
आप इसे (अभी तक) स्ट्रिंग इंटरपोलेशन के साथ नहीं कर सकते। आपका सर्वश्रेष्ठ दांव अभी भी NSString स्वरूपण होने जा रहा है:
println(NSString(format:"%.2f", sqrt(2.0)))अजगर से निकालना, ऐसा लगता है कि एक उचित वाक्यविन्यास हो सकता है:
@infix func % (value:Double, format:String) -> String {
return NSString(format:format, value)
}जो तब आपको उनका उपयोग करने की अनुमति देता है:
M_PI % "%5.3f" // "3.142"आप सभी संख्यात्मक प्रकारों के लिए समान ऑपरेटरों को परिभाषित कर सकते हैं, दुर्भाग्य से मुझे इसे जेनरिक के साथ करने का कोई तरीका नहीं मिला है।
स्विफ्ट 5 अपडेट
कम से कम स्विफ्ट 5 के रूप में, Stringसीधे format:इनिशियलाइज़र का समर्थन करता है, इसलिए इसका उपयोग करने की कोई आवश्यकता नहीं है NSStringऔर @infixविशेषता की अब आवश्यकता नहीं है जिसका अर्थ है कि ऊपर दिए गए नमूने निम्नानुसार लिखे जाने चाहिए:
println(String(format:"%.2f", sqrt(2.0)))
func %(value:Double, format:String) -> String {
return String(format:format, value)
}
Double.pi % "%5.3f" // "3.142"[NSString stringWithFormat...
इसे इतना जटिल क्यों बनाते हैं? आप इसके बजाय इसका उपयोग कर सकते हैं:
import UIKit
let PI = 3.14159265359
round( PI ) // 3.0 rounded to the nearest decimal
round( PI * 100 ) / 100 //3.14 rounded to the nearest hundredth
round( PI * 1000 ) / 1000 // 3.142 rounded to the nearest thousandthइसे खेल के मैदान में देखें।
पुनश्च: से समाधान: http://rrike.sh/xcode/rounding-various-decimal-places-swift/
माणिक / अजगर %ऑपरेटर को फिर से लिखना एक और अधिक सुंदर और सामान्य समाधान है :
// Updated for beta 5
func %(format:String, args:[CVarArgType]) -> String {
return NSString(format:format, arguments:getVaList(args))
}
"Hello %@, This is pi : %.2f" % ["World", M_PI]"Hello %@, This is pi : %.2f" % ["World", M_PI]काम करता है, लेकिन अजीब तरह से "%@ %@" % ["Hello", "World"]बढ़ा can't unsafeBitCast... लगता है कि अगले संस्करण में तय किया जाएगा।
,, स्विफ्ट और अधिकांश भाषाओं में एक मान्य वर्ण ऑपरेटर नहीं है। और imo, %ऑपरेटर का उपयोग करना बेहतर है जो पहले से ही अन्य भाषाओं में मौजूद है। डेवलपर
स्विफ्ट 4
let string = String(format: "%.2f", locale: Locale.current, arguments: 15.123)आप अभी भी स्विफ्ट में NSLog का उपयोग ऑब्जेक्टिव-सी के रूप में कर सकते हैं, केवल @ साइन के बिना।
NSLog("%.02f %.02f %.02f", r, g, b)संपादित करें: थोड़ी देर के बाद स्विफ्ट के साथ काम करने के बाद मैं इस भिन्नता को भी जोड़ना चाहूंगा
var r=1.2
var g=1.3
var b=1.4
NSLog("\(r) \(g) \(b)")आउटपुट:
2014-12-07 21:00:42.128 MyApp[1626:60b] 1.2 1.3 1.4(5.2).rounded()
// 5.0
(5.5).rounded()
// 6.0
(-5.2).rounded()
// -5.0
(-5.5).rounded()
// -6.0func राउंडेड (_ नियम: फ्लोटिंगपॉइंट राउंडिंगRule) -> डबल
let x = 6.5
// Equivalent to the C 'round' function:
print(x.rounded(.toNearestOrAwayFromZero))
// Prints "7.0"
// Equivalent to the C 'trunc' function:
print(x.rounded(.towardZero))
// Prints "6.0"
// Equivalent to the C 'ceil' function:
print(x.rounded(.up))
// Prints "7.0"
// Equivalent to the C 'floor' function:
print(x.rounded(.down))
// Prints "6.0"var x = 5.2
x.round()
// x == 5.0
var y = 5.5
y.round()
// y == 6.0
var z = -5.5
z.round()
// z == -6.0म्यूटिंग फेरी राउंड (_ नियम: फ्लोटिंगपॉइंट राउंडिंग नियम)
// Equivalent to the C 'round' function:
var w = 6.5
w.round(.toNearestOrAwayFromZero)
// w == 7.0
// Equivalent to the C 'trunc' function:
var x = 6.5
x.round(.towardZero)
// x == 6.0
// Equivalent to the C 'ceil' function:
var y = 6.5
y.round(.up)
// y == 7.0
// Equivalent to the C 'floor' function:
var z = 6.5
z.round(.down)
// z == 6.0extension Numeric {
private func _precision(number: NSNumber, formatter: NumberFormatter) -> Self? {
if let formatedNumString = formatter.string(from: number),
let formatedNum = formatter.number(from: formatedNumString) {
return formatedNum as? Self
}
return nil
}
private func toNSNumber() -> NSNumber? {
if let num = self as? NSNumber { return num }
guard let string = self as? String, let double = Double(string) else { return nil }
return NSNumber(value: double)
}
func precision(_ minimumFractionDigits: Int,
roundingMode: NumberFormatter.RoundingMode = NumberFormatter.RoundingMode.halfUp) -> Self? {
guard let number = toNSNumber() else { return nil }
let formatter = NumberFormatter()
formatter.minimumFractionDigits = minimumFractionDigits
formatter.roundingMode = roundingMode
return _precision(number: number, formatter: formatter)
}
func precision(with numberFormatter: NumberFormatter) -> String? {
guard let number = toNSNumber() else { return nil }
return numberFormatter.string(from: number)
}
}_ = 123.44.precision(2)
_ = 123.44.precision(3, roundingMode: .up)
let numberFormatter = NumberFormatter()
numberFormatter.minimumFractionDigits = 1
numberFormatter.groupingSeparator = " "
let num = 222.3333
_ = num.precision(2)func option1<T: Numeric>(value: T, numerFormatter: NumberFormatter? = nil) {
print("Type: \(type(of: value))")
print("Original Value: \(value)")
let value1 = value.precision(2)
print("value1 = \(value1 != nil ? "\(value1!)" : "nil")")
let value2 = value.precision(5)
print("value2 = \(value2 != nil ? "\(value2!)" : "nil")")
if let value1 = value1, let value2 = value2 {
print("value1 + value2 = \(value1 + value2)")
}
print("")
}
func option2<T: Numeric>(value: T, numberFormatter: NumberFormatter) {
print("Type: \(type(of: value))")
print("Original Value: \(value)")
let value1 = value.precision(with: numberFormatter)
print("formated value = \(value1 != nil ? "\(value1!)" : "nil")\n")
}
func test(with double: Double) {
print("===========================\nTest with: \(double)\n")
let float = Float(double)
let float32 = Float32(double)
let float64 = Float64(double)
let float80 = Float80(double)
let cgfloat = CGFloat(double)
// Exapmle 1
print("-- Option1\n")
option1(value: double)
option1(value: float)
option1(value: float32)
option1(value: float64)
option1(value: float80)
option1(value: cgfloat)
// Exapmle 2
let numberFormatter = NumberFormatter()
numberFormatter.formatterBehavior = .behavior10_4
numberFormatter.minimumIntegerDigits = 1
numberFormatter.minimumFractionDigits = 4
numberFormatter.maximumFractionDigits = 9
numberFormatter.usesGroupingSeparator = true
numberFormatter.groupingSeparator = " "
numberFormatter.groupingSize = 3
print("-- Option 2\n")
option2(value: double, numberFormatter: numberFormatter)
option2(value: float, numberFormatter: numberFormatter)
option2(value: float32, numberFormatter: numberFormatter)
option2(value: float64, numberFormatter: numberFormatter)
option2(value: float80, numberFormatter: numberFormatter)
option2(value: cgfloat, numberFormatter: numberFormatter)
}
test(with: 123.22)
test(with: 1234567890987654321.0987654321)===========================
Test with: 123.22
-- Option1
Type: Double
Original Value: 123.22
value1 = 123.22
value2 = 123.22
value1 + value2 = 246.44
Type: Float
Original Value: 123.22
value1 = nil
value2 = nil
Type: Float
Original Value: 123.22
value1 = nil
value2 = nil
Type: Double
Original Value: 123.22
value1 = 123.22
value2 = 123.22
value1 + value2 = 246.44
Type: Float80
Original Value: 123.21999999999999886
value1 = nil
value2 = nil
Type: CGFloat
Original Value: 123.22
value1 = 123.22
value2 = 123.22
value1 + value2 = 246.44
-- Option 2
Type: Double
Original Value: 123.22
formatted value = 123.2200
Type: Float
Original Value: 123.22
formatted value = 123.220001221
Type: Float
Original Value: 123.22
formatted value = 123.220001221
Type: Double
Original Value: 123.22
formatted value = 123.2200
Type: Float80
Original Value: 123.21999999999999886
formatted value = nil
Type: CGFloat
Original Value: 123.22
formatted value = 123.2200
===========================
Test with: 1.2345678909876544e+18
-- Option1
Type: Double
Original Value: 1.2345678909876544e+18
value1 = 1.23456789098765e+18
value2 = 1.23456789098765e+18
value1 + value2 = 2.4691357819753e+18
Type: Float
Original Value: 1.234568e+18
value1 = nil
value2 = nil
Type: Float
Original Value: 1.234568e+18
value1 = nil
value2 = nil
Type: Double
Original Value: 1.2345678909876544e+18
value1 = 1.23456789098765e+18
value2 = 1.23456789098765e+18
value1 + value2 = 2.4691357819753e+18
Type: Float80
Original Value: 1234567890987654400.0
value1 = nil
value2 = nil
Type: CGFloat
Original Value: 1.2345678909876544e+18
value1 = 1.23456789098765e+18
value2 = 1.23456789098765e+18
value1 + value2 = 2.4691357819753e+18
-- Option 2
Type: Double
Original Value: 1.2345678909876544e+18
formatted value = 1 234 567 890 987 650 000.0000
Type: Float
Original Value: 1.234568e+18
formatted value = 1 234 567 939 550 610 000.0000
Type: Float
Original Value: 1.234568e+18
formatted value = 1 234 567 939 550 610 000.0000
Type: Double
Original Value: 1.2345678909876544e+18
formatted value = 1 234 567 890 987 650 000.0000
Type: Float80
Original Value: 1234567890987654400.0
formatted value = nil
Type: CGFloat
Original Value: 1.2345678909876544e+18
formatted value = 1 234 567 890 987 650 000.0000extension Double {
func formatWithDecimalPlaces(decimalPlaces: Int) -> Double {
let formattedString = NSString(format: "%.\(decimalPlaces)f", self) as String
return Double(formattedString)!
}
}
1.3333.formatWithDecimalPlaces(2)अब तक दिए गए उत्तर, जिन्हें सबसे अधिक वोट प्राप्त हुए हैं, एनएसएसट्रिंग के तरीकों पर भरोसा कर रहे हैं और आपको आवश्यकता है कि आपने फाउंडेशन का आयात किया है।
हालांकि, आप अभी भी NSLog तक पहुँच प्राप्त कर चुके हैं।
इसलिए मुझे लगता है कि प्रश्न का उत्तर, यदि आप पूछ रहे हैं कि स्विफ्ट में NSLog का उपयोग कैसे जारी रखा जाए, तो यह है:
import Foundation
यहाँ एक "शुद्ध" स्विफ्ट समाधान है
var d = 1.234567
operator infix ~> {}
@infix func ~> (left: Double, right: Int) -> String {
if right == 0 {
return "\(Int(left))"
}
var k = 1.0
for i in 1..right+1 {
k = 10.0 * k
}
let n = Double(Int(left*k)) / Double(k)
return "\(n)"
}
println("\(d~>2)")
println("\(d~>1)")
println("\(d~>0)")विस्तार की शक्ति
extension Double {
var asNumber:String {
if self >= 0 {
var formatter = NSNumberFormatter()
formatter.numberStyle = .NoStyle
formatter.percentSymbol = ""
formatter.maximumFractionDigits = 1
return "\(formatter.stringFromNumber(self)!)"
}
return ""
}
}
let velocity:Float = 12.32982342034
println("The velocity is \(velocity.toNumber)")आउटपुट: वेग 12.3 है
गोलाई के साथ भी:
extension Float
{
func format(f: String) -> String
{
return NSString(format: "%\(f)f", self)
}
mutating func roundTo(f: String)
{
self = NSString(format: "%\(f)f", self).floatValue
}
}
extension Double
{
func format(f: String) -> String
{
return NSString(format: "%\(f)f", self)
}
mutating func roundTo(f: String)
{
self = NSString(format: "%\(f)f", self).doubleValue
}
}
x = 0.90695652173913
x.roundTo(".2")
println(x) //0.91नीचे विधि का उपयोग करें
let output = String.localizedStringWithFormat(" %.02f %.02f %.02f", r, g, b)
println(output)ऊपर अच्छे जवाबों से भरपूर, लेकिन कभी-कभी एक पैटर्न gobbledygook के "% .3f" प्रकार की तुलना में अधिक उपयुक्त होता है। यहाँ मेरी स्विफ्ट 3 में एक नंबरफ़ॉर्मर का उपयोग करना है।
extension Double {
func format(_ pattern: String) -> String {
let formatter = NumberFormatter()
formatter.format = pattern
return formatter.string(from: NSNumber(value: self))!
}
}
let n1 = 0.350, n2 = 0.355
print(n1.format("0.00#")) // 0.35
print(n2.format("0.00#")) // 0.355यहां मैं चाहता था कि 2 दशमलव हमेशा दिखाए जाएं, लेकिन तीसरा केवल अगर यह शून्य नहीं था।
स्विफ्ट 4 एक्सकोड 10 अपडेट
extension Double {
var asNumber:String {
if self >= 0 {
let formatter = NumberFormatter()
formatter.numberStyle = .none
formatter.percentSymbol = ""
formatter.maximumFractionDigits = 2
return "\(formatter.string(from: NSNumber(value: self)) ?? "")"
}
return ""
}
}डबल और CGFloat प्रकार के एक्सटेंशन के बारे में क्या:
extension Double {
func formatted(_ decimalPlaces: Int?) -> String {
let theDecimalPlaces : Int
if decimalPlaces != nil {
theDecimalPlaces = decimalPlaces!
}
else {
theDecimalPlaces = 2
}
let theNumberFormatter = NumberFormatter()
theNumberFormatter.formatterBehavior = .behavior10_4
theNumberFormatter.minimumIntegerDigits = 1
theNumberFormatter.minimumFractionDigits = 1
theNumberFormatter.maximumFractionDigits = theDecimalPlaces
theNumberFormatter.usesGroupingSeparator = true
theNumberFormatter.groupingSeparator = " "
theNumberFormatter.groupingSize = 3
if let theResult = theNumberFormatter.string(from: NSNumber(value:self)) {
return theResult
}
else {
return "\(self)"
}
}
}उपयोग:
let aNumber: Double = 112465848348508.458758344
Swift.print("The number: \(aNumber.formatted(2))")प्रिंट: 112 465 848 348 508.46
@infix func ^(left:Double, right: Int) -> NSNumber {
let nf = NSNumberFormatter()
nf.maximumSignificantDigits = Int(right)
return nf.numberFromString(nf.stringFromNumber(left))
}
let r = 0.52264
let g = 0.22643
let b = 0.94837
println("this is a color: \(r^3) \(g^3) \(b^3)")
// this is a color: 0.523 0.226 0.948मुझे दो दशमलव स्थानों के बारे में पता नहीं है , लेकिन यहां बताया गया है कि आप शून्य दशमलव स्थानों के साथ कैसे फ़्लोट प्रिंट कर सकते हैं, इसलिए मैं कल्पना करूंगा कि 2 स्थान, 3, स्थान हो सकते हैं ... (नोट: आपको CGFloat को डबल में परिवर्तित करना होगा स्ट्रिंग के लिए (प्रारूप :) या यह शून्य का मान देखेगा)
func logRect(r: CGRect, _ title: String = "") {
println(String(format: "[ (%.0f, %.0f), (%.0f, %.0f) ] %@",
Double(r.origin.x), Double(r.origin.y), Double(r.size.width), Double(r.size.height), title))
}स्विफ्ट 2 उदाहरण: आईओएस डिवाइस की स्क्रीन की चौड़ाई दशमलव को हटाने वाली फ्लोट को स्वरूपित करती है
print(NSString(format: "Screen width = %.0f pixels", CGRectGetWidth(self.view.frame)))@ क्रिसियन डायट्रिच:
के बजाय:
var k = 1.0
for i in 1...right+1 {
k = 10.0 * k
}
let n = Double(Int(left*k)) / Double(k)
return "\(n)"यह भी हो सकता है:
let k = pow(10.0, Double(right))
let n = Double(Int(left*k)) / k
return "\(n)"[सुधार:] भ्रम के लिए क्षमा करें * - बेशक यह डबल्स के साथ काम करता है। मुझे लगता है, सबसे अधिक व्यावहारिक (यदि आप चाहते हैं कि अंक गोल हो, कट न हो) तो यह कुछ इस तरह होगा:
infix operator ~> {}
func ~> (left: Double, right: Int) -> Double {
if right <= 0 {
return round(left)
}
let k = pow(10.0, Double(right))
return round(left*k) / k
}केवल फ्लोट के लिए, फ्लोट के साथ डबल को बदलें, पॉव के साथ पॉव और राउंडफ के साथ राउंड।
अपडेट: मैंने पाया कि स्ट्रिंग के बजाय रिटर्न टाइप डबल का उपयोग करना सबसे व्यावहारिक है। यह स्ट्रिंग आउटपुट के लिए समान काम करता है, अर्थात:
println("Pi is roughly \(3.1415926 ~> 3)")प्रिंट: पाई लगभग 3.142 है,
इसलिए आप इसे स्ट्रिंग्स के लिए उसी तरह उपयोग कर सकते हैं (आप अभी भी लिख सकते हैं: Println (d ~> 2)), लेकिन इसके अलावा आप इसे सीधे राउंड मानों के लिए भी उपयोग कर सकते हैं:
d = Double(slider.value) ~> 2या आपको जो भी चाहिए…