谁能告诉我如何在Swift中将double值舍入到x个小数位?
我有:
var totalWorkTimeInHours = (totalWorkTime/60/60)
totalWorkTime
是第二个NSTimeInterval(双倍)。
totalWorkTimeInHours
会给我几个小时,但它给了我这么长的精确数字的时间,例如1.543240952039 ......
当我打印totalWorkTimeInHours
时,如何将其舍入到1.543?
您可以使用Swift的round
函数来完成此任务。
要以3位精度舍入Double
,首先将其乘以1000,将其四舍五入并将舍入结果除以1000:
let x = 1.23556789
let y = Double(round(1000*x)/1000)
print(y) // 1.236
除了任何类型的printf(...)
或String(format: ...)
解决方案,此操作的结果仍然是Double
类型。
编辑: 关于它有时不起作用的评论,请阅读:
What Every Computer Scientist Should Know About Floating-Point Arithmetic
在Swift 3.0和Xcode 8.0中:
extension Double {
func roundTo(places: Int) -> Double {
let divisor = pow(10.0, Double(places))
return (self * divisor).rounded() / divisor
}
}
像这样使用此扩展,
let doubleValue = 3.567
let roundedValue = doubleValue.roundTo(places: 2)
print(roundedValue) // prints 3.56
一个方便的方法可以是使用Double类型的扩展
extension Double {
var roundTo2f: Double {return Double(round(100 *self)/100) }
var roundTo3f: Double {return Double(round(1000*self)/1000) }
}
用法:
let regularPie: Double = 3.14159
var smallerPie: Double = regularPie.roundTo3f // results 3.142
var smallestPie: Double = regularPie.roundTo2f // results 3.14
使用内置的Foundation Darwin库
SWIFT 3
extension Double {
func round(to places: Int) -> Double {
let divisor = pow(10.0, Double(places))
return Darwin.round(self * divisor) / divisor
}
}
用法:
let number:Double = 12.987654321
print(number.round(to: 3))
产出:12.988
这是一种长期的解决方法,如果您的需求稍微复杂一些,它可能会派上用场。您可以在Swift中使用数字格式化程序。
let numberFormatter: NSNumberFormatter = {
let nf = NSNumberFormatter()
nf.numberStyle = .DecimalStyle
nf.minimumFractionDigits = 0
nf.maximumFractionDigits = 1
return nf
}()
假设您要打印的变量是
var printVar = 3.567
这将确保以所需的格式返回:
numberFormatter.StringFromNumber(printVar)
这里的结果将是“3.6”(四舍五入)。虽然这不是最经济的解决方案,但我给它是因为OP提到了打印(在这种情况下,String不是不合需要的),并且因为这个类允许设置多个参数。
我会用
print(String(format: "%.3f", totalWorkTimeInHours))
并将.3f更改为您需要的任意数量的十进制数
这是一种更灵活的舍入到N位有效数字的算法
Swift 3解决方案
extension Double {
// Rounds the double to 'places' significant digits
func roundTo(places:Int) -> Double {
guard self != 0.0 else {
return 0
}
let divisor = pow(10.0, Double(places) - ceil(log10(fabs(self))))
return (self * divisor).rounded() / divisor
}
}
// Double(0.123456789).roundTo(places: 2) = 0.12
// Double(1.23456789).roundTo(places: 2) = 1.2
// Double(1234.56789).roundTo(places: 2) = 1200
格式化double属性的最佳方法是使用Apple预定义方法。
mutating func round(_ rule: FloatingPointRoundingRule)
FloatingPointRoundingRule是一个具有以下可能性的枚举
查点案例:
case awayFromZero舍入到最接近的允许值,其大小大于或等于源的大小。
case down舍入到小于或等于源的最近允许值。
case toNearestOrAwayFromZero舍入到最接近的允许值;如果两个值相等,则选择幅度更大的值。
case toNearestOrEven舍入到最接近的允许值;如果两个值相等,则选择偶数。
case toZero Round to the allowed allow value,其大小小于或等于source的值。
case up舍入到大于或等于源的最近允许值。
var aNumber : Double = 5.2
aNumber.rounded(.up) // 6.0
如果你想要舍入Double
值,你可能想要使用Swift Decimal
,这样你就不会引入任何在尝试使用这些舍入值进行数学运算时可能出现的错误。如果使用Decimal
,它可以准确地表示该舍入浮点值的十进制值。
所以你可以这样做:
extension Double {
/// Convert `Double` to `Decimal`, rounding it to `scale` decimal places.
///
/// - Parameters:
/// - scale: How many decimal places to round to. Defaults to `0`.
/// - mode: The preferred rounding mode. Defaults to `.plain`.
/// - Returns: The rounded `Decimal` value.
func roundedDecimal(to scale: Int = 0, mode: NSDecimalNumber.RoundingMode = .plain) -> Decimal {
var decimalValue = Decimal(self)
var result = Decimal()
NSDecimalRound(&result, &decimalValue, scale, mode)
return result
}
}
然后,您可以像这样获得舍入的Decimal
值:
let foo = 427.3000000002
let value = foo.roundedDecimal(to: 2) // results in 427.30
如果你想用指定的小数位数显示它(以及为用户的当前语言环境本地化字符串),你可以使用NumberFormatter
:
let formatter = NumberFormatter()
formatter.maximumFractionDigits = 2
formatter.minimumFractionDigits = 2
if let string = formatter.string(for: value) {
print(string)
}
或者:
String(format:)
:
使用Double
格式说明符将tpecxswpoi引入String
,然后返回%.3f
Double
或者扩展Double(String(format: "%.3f", 10.123546789))!
来处理N-Decimal位置:
Double
extension Double {
func rounded(toDecimalPlaces n: Int) -> Double {
return Double(String(format: "%.\(n)f", self))!
}
}
或者扩展(1000 * 10.123546789).rounded()/1000
来处理N-Decimal位置:
Double
不是斯威夫特,但我相信你明白了。
extension Double {
func rounded(toDecimalPlaces n: Int) -> Double {
let multiplier = pow(10, Double(n))
return (multiplier * self).rounded()/multiplier
}
}
更通用的解决方案是以下扩展,适用于Swift 2和iOS 9:
extension Double {
/// Rounds the double to decimal places value
func roundToPlaces(places:Int) -> Double {
let divisor = pow(10.0, Double(places))
return round(self * divisor) / divisor
}
}
在Swift 3中,round
被rounded
取代:
extension Double {
/// Rounds the double to decimal places value
func rounded(toPlaces places:Int) -> Double {
let divisor = pow(10.0, Double(places))
return (self * divisor).rounded() / divisor
}
}
返回Double舍入到4位小数的示例:
let x = Double(0.123456789).roundToPlaces(4) // x becomes 0.1235 under Swift 2
let x = Double(0.123456789).rounded(toPlaces: 4) // Swift 3 version
将double值舍入为x的十进制数 没有。十进制后的数字
pow10np = pow(10,num_places);
val = round(val*pow10np) / pow10np;
var x = 1.5657676754
var y = (x*10000).rounded()/10000
print(y) // 1.5658
var x = 1.5657676754
var y = (x*100).rounded()/100
print(y) // 1.57
我发现这是否有可能纠正用户的输入。也就是说,如果他们输入三位小数而不是两位小数金额。说1.111而不是1.11你能通过四舍五入来解决它吗?答案有很多原因,不是!随着钱超过0.001即最终会导致真正的支票簿出现问题。
这是一个在句点之后检查用户输入是否有太多值的函数。但这将允许1,1.1和1.11。
假设已经检查了该值是否成功从String转换为Double。
var x = 1.5657676754
var y = (x*10).rounded()/10
print(y) // 1.6
//func need to be where transactionAmount.text is in scope
func checkDoublesForOnlyTwoDecimalsOrLess()->Bool{
var theTransactionCharacterMinusThree: Character = "A"
var theTransactionCharacterMinusTwo: Character = "A"
var theTransactionCharacterMinusOne: Character = "A"
var result = false
var periodCharacter:Character = "."
var myCopyString = transactionAmount.text!
if myCopyString.containsString(".") {
if( myCopyString.characters.count >= 3){
theTransactionCharacterMinusThree = myCopyString[myCopyString.endIndex.advancedBy(-3)]
}
if( myCopyString.characters.count >= 2){
theTransactionCharacterMinusTwo = myCopyString[myCopyString.endIndex.advancedBy(-2)]
}
if( myCopyString.characters.count > 1){
theTransactionCharacterMinusOne = myCopyString[myCopyString.endIndex.advancedBy(-1)]
}
if theTransactionCharacterMinusThree == periodCharacter {
result = true
}
if theTransactionCharacterMinusTwo == periodCharacter {
result = true
}
if theTransactionCharacterMinusOne == periodCharacter {
result = true
}
}else {
//if there is no period and it is a valid double it is good
result = true
}
return result
}
//find the distance between two points
let coordinateSource = CLLocation(latitude: 30.7717625, longitude:76.5741449 )
let coordinateDestination = CLLocation(latitude: 29.9810859, longitude: 76.5663599)
let distanceInMeters = coordinateSource.distance(from: coordinateDestination)
let valueInKms = distanceInMeters/1000
let preciseValueUptoThreeDigit = Double(round(1000*valueInKms)/1000)
self.lblTotalDistance.text = "Distance is : \(preciseValueUptoThreeDigit) kms"
用法:
extension String{
var roundedValue:String {
return String(format: "%.3f", self)
}}
您可以添加此扩展程序:
totalWorkTimeInHours.roundedValue
并称之为:
extension Double {
var clean: String {
return self.truncatingRemainder(dividingBy: 1) == 0 ? String(format: "%.0f", self) : String(format: "%.2f", self)
}
}
当我打印
totalWorkTimeInHours
时,如何将其舍入到1.543?
要将totalWorkTimeInHours
舍入为3位进行打印,请使用带有String
字符串的format
构造函数:
print(String(format: "%.3f", totalWorkTimeInHours))
使用Swift 5,根据您的需要,您可以选择以下9种样式中的一种,以便从Double
获得圆润的结果。
FloatingPoint
rounded()
方法在最简单的情况下,您可以使用Double
round()
方法。
let roundedValue1 = (0.6844 * 1000).rounded() / 1000
let roundedValue2 = (0.6849 * 1000).rounded() / 1000
print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685
FloatingPoint
rounded(_:)
方法let roundedValue1 = (0.6844 * 1000).rounded(.toNearestOrEven) / 1000
let roundedValue2 = (0.6849 * 1000).rounded(.toNearestOrEven) / 1000
print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685
round
函数基金会通过达尔文提供round
功能。
import Foundation
let roundedValue1 = round(0.6844 * 1000) / 1000
let roundedValue2 = round(0.6849 * 1000) / 1000
print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685
Double
和round
函数构建的pow
扩展自定义方法如果您想多次重复上一个操作,重构代码可能是个好主意。
import Foundation
extension Double {
func roundToDecimal(_ fractionDigits: Int) -> Double {
let multiplier = pow(10, Double(fractionDigits))
return Darwin.round(self * multiplier) / multiplier
}
}
let roundedValue1 = 0.6844.roundToDecimal(3)
let roundedValue2 = 0.6849.roundToDecimal(3)
print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685
NSDecimalNumber
rounding(accordingToBehavior:)
方法如果需要,NSDecimalNumber
为舍入十进制数提供了一个冗长但功能强大的解决方案。
import Foundation
let scale: Int16 = 3
let behavior = NSDecimalNumberHandler(roundingMode: .plain, scale: scale, raiseOnExactness: false, raiseOnOverflow: false, raiseOnUnderflow: false, raiseOnDivideByZero: true)
let roundedValue1 = NSDecimalNumber(value: 0.6844).rounding(accordingToBehavior: behavior)
let roundedValue2 = NSDecimalNumber(value: 0.6849).rounding(accordingToBehavior: behavior)
print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685
NSDecimalRound(_:_:_:_:)
函数import Foundation
let scale = 3
var value1 = Decimal(0.6844)
var value2 = Decimal(0.6849)
var roundedValue1 = Decimal()
var roundedValue2 = Decimal()
NSDecimalRound(&roundedValue1, &value1, scale, NSDecimalNumber.RoundingMode.plain)
NSDecimalRound(&roundedValue2, &value2, scale, NSDecimalNumber.RoundingMode.plain)
print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685
NSString
init(format:arguments:)
初始化程序如果你想从舍入操作返回NSString
,使用NSString
初始化器是一个简单但有效的解决方案。
import Foundation
let roundedValue1 = NSString(format: "%.3f", 0.6844)
let roundedValue2 = NSString(format: "%.3f", 0.6849)
print(roundedValue1) // prints 0.684
print(roundedValue2) // prints 0.685
String
init(format:_:)
初始化程序Swift的String
类型与Foundation的NSString
类桥接。因此,您可以使用以下代码从舍入操作返回String
:
import Foundation
let roundedValue1 = String(format: "%.3f", 0.6844)
let roundedValue2 = String(format: "%.3f", 0.6849)
print(roundedValue1) // prints 0.684
print(roundedValue2) // prints 0.685
NumberFormatter
如果您期望通过舍入操作获得String?
,NumberFormatter
提供高度可定制的解决方案。
import Foundation
let formatter = NumberFormatter()
formatter.numberStyle = NumberFormatter.Style.decimal
formatter.roundingMode = NumberFormatter.RoundingMode.halfUp
formatter.maximumFractionDigits = 3
let roundedValue1 = formatter.string(from: 0.6844)
let roundedValue2 = formatter.string(from: 0.6849)
print(String(describing: roundedValue1)) // prints Optional("0.684")
print(String(describing: roundedValue2)) // prints Optional("0.685")
在Yogi的回答基础上,这是一个完成工作的Swift函数:
func roundToPlaces(value:Double, places:Int) -> Double {
let divisor = pow(10.0, Double(places))
return round(value * divisor) / divisor
}
这是完全有效的代码
Swift 3.0 / 4.0,Xcode 9.0 GM / 9.2
let doubleValue : Double = 123.32565254455
self.lblValue.text = String(format:"%.f", doubleValue)
print(self.lblValue.text)
输出 - 123
self.lblValue_1.text = String(format:"%.1f", doubleValue)
print(self.lblValue_1.text)
输出 - 123.3
self.lblValue_2.text = String(format:"%.2f", doubleValue)
print(self.lblValue_2.text)
输出 - 123.33
self.lblValue_3.text = String(format:"%.3f", doubleValue)
print(self.lblValue_3.text)
输出 - 123.326
小数后面的特定数字的代码是:
var a = 1.543240952039
var roundedString = String(format: "%.3f", a)
这里%.3f告诉swift将这个数字舍入到3个小数位。如果你想要双号,你可以使用这个代码:
// String为Double
var roundedString = Double(String(format: "%.3f", b))
Swift 4,Xcode 10
yourLabel.text = String(format:"%.2f", yourDecimalValue)