对于许多应用程序，需要精确的小数位数来舍入。

对于其他一些，您没有这样的限制，并希望“压缩”输出大小，但仍然希望避免将数字转换为字符串(反之亦然)，就像导出具有数百万个数字的JSON一样。

在这种情况下，你可以使用'trick'来四舍五入显数(尾数)，而不是整数。在这种情况下，你会得到最后的小数点 大多数数字仍然最多保留3位小数点后(如果需要的话)，而有些数字会稍微多一些。

这是你在使用十进制数时所期望的结果:

5.2472 5.2516 5.2556 5.26 5.264

而不是:

5.24731462499949 5.251488374999099 5.25566283399894 5.259839374999501 5.264012208999702

let value = 5.24731462499949

print(value)
// 5.24731462499949

let valueSignificandRounded = round((1000 * 10) * value.significand) / (1000 * 10)

let valueRounded = CGFloat(sign: v.sign, exponent: v.exponent, significand: valueSignificandRounded)

print(valueRounded)
// 5.2472

如果你想四舍五入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
    }
}

然后，你可以像这样得到四舍五入的十进制值:

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)
}

对于许多应用程序，需要精确的小数位数来舍入。

对于其他一些，您没有这样的限制，并希望“压缩”输出大小，但仍然希望避免将数字转换为字符串(反之亦然)，就像导出具有数百万个数字的JSON一样。

在这种情况下，你可以使用'trick'来四舍五入显数(尾数)，而不是整数。在这种情况下，你会得到最后的小数点 大多数数字仍然最多保留3位小数点后(如果需要的话)，而有些数字会稍微多一些。

这是你在使用十进制数时所期望的结果:

5.2472 5.2516 5.2556 5.26 5.264

而不是:

5.24731462499949 5.251488374999099 5.25566283399894 5.259839374999501 5.264012208999702

let value = 5.24731462499949

print(value)
// 5.24731462499949

let valueSignificandRounded = round((1000 * 10) * value.significand) / (1000 * 10)

let valueRounded = CGFloat(sign: v.sign, exponent: v.exponent, significand: valueSignificandRounded)

print(valueRounded)
// 5.2472

我想知道是否有可能纠正用户的输入。也就是说，如果他们输入三个小数而不是两个小数来表示一美元的金额。比如说1.111而不是1.11，你能通过四舍五入来修复它吗?出于很多原因，答案是否定的!对于金钱，任何超过0.001的东西最终都会在真正的支票簿上产生问题。

下面是一个函数，用于检查用户输入的句点之后是否有太多值。但是它允许1。、1.1和1.11。

假设已经检查了该值，以成功地从String转换为Double。

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


}

二重值舍入到小数的x位 不。小数点后的数

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 

var x = 1.5657676754
var y = (x*10).rounded()/10
print(y)  // 1.6

格式化double属性的最好方法是使用Apple预定义的方法。

mutating func round(_ rule: FloatingPointRoundingRule)

FloatingPointRoundingRule是一个枚举，有以下几种可能

枚举的案例:

案例awayFromZero 四舍五入到最接近的允许值，其大小大于或等于源的大小。

情况下 四舍五入到小于或等于源的最接近的允许值。

案例toNearestOrAwayFromZero 四舍五入到最接近的允许值;如果两个值相等接近，则选择大小较大的值。

案例toNearestOrEven 四舍五入到最接近的允许值;如果两个值相等接近，则选择偶数。

案例towardZero 四舍五入到最接近的允许值，其大小小于或等于源的大小。

情况下了 四舍五入到最接近的允许值，该值大于或等于源。

var aNumber : Double = 5.2
aNumber.rounded(.up) // 6.0