NSLog(@" %.02f %.02f %.02f", r, g, b);
我检查了文档和电子书，但无法弄清楚。谢谢！
#1 楼
迄今为止，我最好的解决方案来自David的回答：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
我认为这是最类似于Swift的解决方案，将格式化操作直接与数据类型相关联。可能是某处有一个内置的格式化操作库，或者它可能很快就会发布。请记住，该语言仍处于测试阶段。
#2 楼
一个简单的方法是：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：“ float number：％.5f”，1.0321））
– zaph
2014年7月29日在3:31
我认为这是一个比公认答案更好的答案。它更接近于标准c样式printf，而无需编写单独的扩展名。
–基思·莫里斯（Keith Morris）
2014年9月20日下午2:35
不要忘记文件顶部的“导入基础”。
–克里斯·格雷格（Chris Gregg）
2014年11月3日在1:28
这比公认的答案更好，但仍在使用Foundation方法（桥接到Swift）。
–user4233369
2015年1月4日在17:16
确保导入基金会
– NaN
16年4月30日在0:12
#3 楼
我发现String.localizedStringWithFormat运作良好：示例：
let value: Float = 0.33333
let unit: String = "mph"
yourUILabel.text = String.localizedStringWithFormat("%.2f %@", value, unit)
评论
这个问题与处理单元无关。 localizedStringWithFormat很不错，但是没有关系。
– AmitP
16年11月14日在12:08
我同意AmitP，有人问过String（format：...，arguments：...）是否可用
–华伦丁
16年11月14日在12:11
#4 楼
这是一种非常快速且简单的方法，不需要复杂的解决方案。let duration = String(format: "%.01f", 3.32323242)
// result = 3.3
评论
这不会编译（在IBM的Swift沙箱中使用3.0.2）：第16列：“ init”已重命名为“ init（describing :)”
– Peter Dillinger
17年1月30日在16:35
@PeterDillinger您传递的是可选值，而不是未包装的值。
–迈克尔
18年2月27日在11:37
#5 楼
这里的大多数答案都是有效的。但是，如果您经常格式化数字，请考虑扩展Float类以添加一个返回格式化字符串的方法。请参见下面的示例代码。通过使用数字格式化程序和扩展名，可以达到相同的目的。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.3
SWIFT 3.1更新
extension Float {
func string(fractionDigits:Int) -> String {
let formatter = NumberFormatter()
formatter.minimumFractionDigits = fractionDigits
formatter.maximumFractionDigits = fractionDigits
return formatter.string(from: NSNumber(value: self)) ?? "\(self)"
}
}
评论
我希望更多的人会使用NSNumberFormatter，像这样的答案。其他投票率很高的答案只是无法反映设备的语言环境设置（例如，在某些语言环境中，它们使用逗号表示小数点;这反映了这一点;其他答案则没有）。
–Rob
15年3月31日在12:56
我唯一想看到的改进就是为任何给定的数字存储了格式化程序-NSNumberFormatters的构建成本很高。
–肯德尔·赫尔姆斯特·盖尔纳（Kendall Helmstetter Gelner）
2015年4月2日在7:04
确切地说，我在寻找什么！谢谢
– Gunjot singh
16-11-19在11:00
我知道这是一个有点老的问题，但是NSNumberFormatter初始化起来很慢。如果可能，它有助于定义一个并重用它。就是说，我在这里阅读这个问题，因为在我的情况下这是不可能的。
– promacuser
17年6月22日在13:35
#6 楼
您还不能通过字符串插值来做到这一点。最好的选择仍然是NSString格式：println(NSString(format:"%.2f", sqrt(2.0)))
从python推算出来，似乎合理的语法可能是：
@infix func % (value:Double, format:String) -> String {
return NSString(format:format, value)
}
然后，您可以将它们用作：
M_PI % "%5.3f" // "3.142"
您可以为所有数字类型定义类似的运算符，很遗憾，我还没有
Swift 5 Update
至少从Swift 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（format：“ formatString”，val）'。我在Apple的iBooks文档中没有看到它。
–邓肯C
2014年6月5日14:51
这与从Swift构造任何Objective-C对象相同。它是[NSString stringWithFormat ...的快速版本。
– David Berry
2014年6月5日15:25
知道了我还没有在Swift iBook中走那么远。
–邓肯C
2014年6月5日20:46
Swift iBook中没有的IIRC。这是在WWDC会议中的一届。快速的深度互操作性
– ahruss
2014年6月8日7:33
如果要像在Python中那样实现％，那应该是另一种方式。 “％5.3f”％M_PI
–安迪·邓特（Andy Dent）
2014年6月19日在2:47
#7 楼
为什么要这么复杂？您可以改用它：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
在Playground中查看其工作。
PS：解决方案来自：http://rrike.sh/ xcode /舍入各种小数位数转换/
评论
到目前为止，这是最好的解决方案，我不知道这不是最重要的。
– pjtnt11
15年7月25日在23:06
nitpicky的东西。1.500000000只会是“ 1.5”，而不是“ 1.50”
–styler1972
15年9月22日在16:08
#8 楼
import Foundation
extension CGFloat {
var string1: String {
return String(format: "%.1f", self)
}
var string2: String {
return String(format: "%.2f", self)
}
}
用法
let offset = CGPoint(1.23, 4.56)
print("offset: \(offset.x.string1) x \(offset.y.string1)")
// offset: 1.2 x 4.6
#9 楼
一个更优雅，更通用的解决方案是重写ruby / python%运算符：// 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]
评论
可悲的是，它在beta 6中消失了：致命错误：不同大小类型之间不能unsafeBitCast。
– Binarymochi
2014年8月22日上午8:15
@binarymochi使用Beta 6：“ Hello％@，这是pi：％.2f”％[“ World”，M_PI]确实有效，但是奇怪的是“％@％@”％[“ Hello”，“ World”]加注可以't unsafeBitCast ...猜猜将在下一版本中修复。
– Vincent Guerci
2014年8月22日在9:23
您能否在使用的运算符中加上“，”？ '@infix func，（…'），然后像“ Hello％@，这是pi：％.2f”，[“ you”，M_PI]这样写字符串？
–里克
2014年10月19日，2：09
@Rick不行，在Swift和大多数语言中，它不是有效的字符运算符。而imo，最好使用其他语言中已经存在的％运算符。参见developer.apple.com/library/ios/documentation/Swift/Conceptual/…
– Vincent Guerci
2014-10-23 12:34
#10 楼
详细信息Xcode 9.3，Swift 4.1
Xcode 10.2.1（10E1001），Swift 5
解决方案1
func rounded（）-> Double
(5.2).rounded()
// 5.0
(5.5).rounded()
// 6.0
(-5.2).rounded()
// -5.0
(-5.5).rounded()
// -6.0
func rounded（_规则：FloatingPointRoundingRule）-> Double
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"
变异函数round（）
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
变异函数round（_规则：FloatingPointRoundingRule）
// 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.0
解决方案2
extension 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.0000
#11 楼
Swift 4let string = String(format: "%.2f", locale: Locale.current, arguments: 15.123)
评论
let temp：Float = div * 100 let string = String（format：“％.2f”，locale：Locale.current，arguments：temp）这给了我错误。无法将类型“ Float”的值转换为预期的参数类型“ [CVarArg]
–钱德尼
18年5月17日在7:26
您需要将15.123放入数组以使其正常工作
–多里安·罗伊（Dorian Roy）
18-09-26在16:11
对我来说有效：let string = String（format：“％.2f”，myString）
– Grzegorz R. Kulesza
19 Mar 19 '19在10:36
#12 楼
您仍然可以像在Objective-C中一样在Swift中使用NSLog，而无需使用@符号。NSLog("%.02f %.02f %.02f", r, g, b)
编辑：使用Swift一段时间后，我还要添加此变化形式
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
#13 楼
extension Double {
func formatWithDecimalPlaces(decimalPlaces: Int) -> Double {
let formattedString = NSString(format: "%.\(decimalPlaces)f", self) as String
return Double(formattedString)!
}
}
1.3333.formatWithDecimalPlaces(2)
#14 楼
到目前为止，获得最多投票的答案依赖于NSString方法，并且要求您已导入Foundation。尽管如此，您仍然可以访问NSLog。
因此，如果您要问如何继续在Swift中使用NSLog，我认为问题的答案很简单：
import Foundation #15 楼
//It will more help, by specify how much decimal Point you want.
let decimalPoint = 2
let floatAmount = 1.10001
let amountValue = String(format: "%0.*f", decimalPoint, floatAmount)
#16 楼
这是一个“纯”的快速解决方案 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)")
#17 楼
扩展力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
#18 楼
更少的打字方式：func fprint(format: String, _ args: CVarArgType...) {
print(NSString(format: format, arguments: getVaList(args)))
}
#19 楼
Double和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
#20 楼
您还可以通过这种方式创建运算符operator infix <- {}
func <- (format: String, args:[CVarArg]) -> String {
return String(format: format, arguments: args)
}
let str = "%d %.1f" <- [1453, 1.123]
#21 楼
还可以取整：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
#22 楼
使用以下方法let output = String.localizedStringWithFormat(" %.02f %.02f %.02f", r, g, b)
println(output)
#23 楼
Vincent Guerci的ruby / python％运算符的版本，已针对Swift 2.1进行了更新：func %(format:String, args:[CVarArgType]) -> String {
return String(format:format, arguments:args)
}
"Hello %@, This is pi : %.2f" % ["World", M_PI]
#24 楼
上面有很多不错的答案，但是有时候模式比“％.3f”这样的傻瓜更合适。这是我在Swift 3中使用NumberFormatter的方法。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个小数，但只有第三个不为零时才显示。 />
#25 楼
Swift 4 Xcode 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 ""
}
}
#26 楼
@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
#27 楼
我不知道小数点后两位，但是这是打印小数点后零位的浮点数的方法，因此我想可以是2位，3位...（注意：您必须将CGFloat转换为Double才能通过转换为字符串（格式：），否则将看到零值）。#28 楼
Swift2示例：格式化Float并删除小数的iOS设备的屏幕宽度print(NSString(format: "Screen width = %.0f pixels", CGRectGetWidth(self.view.frame)))
#29 楼
@Christian Dietrich：而不是：
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)"
[更正：]
抱歉造成混淆*-当然，这适用于Doubles。我认为，最实用的方法（如果您希望数字四舍五入而不是被截断）将是这样的：
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
}
仅对于Float，只需将Double替换为浮点数，powf与powf，pow与roundf.Update：我发现使用返回类型Double而不是String最为实用。它对于String输出的工作方式相同，即：
println("Pi is roughly \(3.1415926 ~> 3)")
，因此您可以对String使用相同的方式（您可以甚至仍然写：println（d〜> 2）），但是除此之外，您还可以直接使用它来舍入值，即：
d = Double(slider.value) ~> 2
或任何您需要的内容…… br />
评论
这显然是要发表评论，我知道您需要更多的空间来提出要点，这很有价值，但是如果您要将其写为一个完整的答案，请使其独立地有用。您可以添加完整的代码，例如，然后添加注释并向Christian表示感谢。
–哈努曼
2015年2月23日下午0:10
@JaimeGómez：我不允许评论以上答案。但是无论如何，我有一些错误的解释*。不知道是值得保留还是应该删除。当然，这可以类似的方式用于舍入（不带字符串转换），并且可以轻松转换为其他编程语言。 *我假设使用Double将其四舍五入到大约8位数字，这当然是错误的，因为我用Float对其进行了四舍五入并将其偶然地转换为Double。
– Stuepfnick
2015年2月23日在8:28
PS：我更喜欢一般使用类似的方法进行四舍五入，而不是String输出，所以返回类型Double（和常规方法？）旁注：如果您以这种方式（例如，从Slider）对Float进行四舍五入并将结果转换为String，会很好，例如“ 0.1”，但是如果将该Float转换为Double然后转换为String *，它将是：“ 0.100000001490116”，因为Float无法完全存储0.1，只能非常接近。我猜这与Double相同，只是具有double精度;）因此，在四舍五入之前总是将其转换为Double，因此它将尽可能精确，并且也可以转换为String。
– Stuepfnick
2015年3月2日，0：10
PPS：当然，对于双精度返回类型，有时会有些不同，即，如果需要设置标签文本，则需要编写：myLabel.text =“ \（d〜> 2）”而不是myLabel。 text = d〜> 2，但我仍然认为，该功能更实用。 （当然每个人都可以做，他们想要什么，只是我的想法……）
– Stuepfnick
2015年3月7日在2:45
#30 楼
使用CGFloat
或
Float.roundTo(places:2)
评论
CGFloat没有成员轮可以参加
–钱德尼
18年5月17日在7:29
评论
这不必要地复杂。 Realityone的答案很有效，而且更为简洁。
–史蒂文·马洛（Steven Marlowe）
2014年12月20日下午5:41
确保只使用一次。但是，如果您想使用字符串内插（更具可读性）来使用更多格式选项，则可以将所有格式扩展名放在其他文件中，并在整个项目中对其进行引用。当然，理想情况下，Apple应该提供格式库。
– Anton Tcholakov
2014年12月20日上午8:02
如果不将结果强制转换为String，此解决方案将无法在Swift 1.2中使用。
– ibesora
2015年4月10日在6:32
不错，但不是Swift 2 Friend。
– LastMove
16-2-29在13:34
在SwiftUI中，使用Text（“ \（someDouble，说明符：”％.3f“）”）
–众多
10月2日15:51