Округление двойного значения до x количества десятичных знаков в swift

Для этого вы можете использовать функцию Swift round.

Чтобы округлить Double с точностью до 3 цифр, сначала умножьте его на 1000, округлите и разделите результат округления на 1000:

let x = 1.23556789
let y = Double(round(1000*x)/1000)
print(y)  // 1.236

За исключением любых решений printf(...) или String(format: ...), результат этой операции по-прежнему имеет тип Double.

РЕДАКТИРОВАТЬ:
Что касается комментариев, которые иногда не работают, прочтите следующее:

Что каждый программист должен знать об арифметике с плавающей запятой

Расширение для Swift 2

Более общим решением является следующее расширение, которое работает со 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

В 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

Как округлить это значение, скажем, до 1,543 при печати totalWorkTimeInHours?

Чтобы округлить totalWorkTimeInHours до 3 цифр для печати, используйте конструктор String, который принимает строку format:

print(String(format: "%.3f", totalWorkTimeInHours))

В Swift 5, в соответствии с вашими потребностями, вы можете выбрать один из 9 следующих стилей, чтобы получить округленный результат от Double.

№1. Использование метода FloatingPoint rounded()

В простейшем случае вы можете использовать метод Double rounded().

let roundedValue1 = (0.6844 * 1000).rounded() / 1000
let roundedValue2 = (0.6849 * 1000).rounded() / 1000
print(roundedValue1) // returns 0.684
print(roundedValue2) // returns 0.685

№2. Использование метода 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

№3. Использование функции Дарвина round

Foundation предлагает 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

№4. Использование пользовательского метода расширения 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

№5. Использование метода 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

№6. Использование функции 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

№7. Использование инициализатора 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

№8. Использование инициализатора String init(format:_:)

Тип String Swift связан с классом NSString Foundation. Следовательно, вы можете использовать следующий код, чтобы вернуть 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

№9. Использование 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")

В Swift 5.3 и Xcode 12:

let pi: Double = 3.14159265358979
String(format:"%.2f", pi)

Пример:

PS.: It still the same since Swift 2.0 and Xcode 7.2

Это полностью отработанный код

Swift 3.0 / 4.0 / 5.0, Xcode 9.0 GM / 9.2 и выше

let doubleValue : Double = 123.32565254455
self.lblValue.text = String(format:"%.f", doubleValue)
print(self.lblValue.text)

выход - 123

let doubleValue : Double = 123.32565254455
self.lblValue_1.text = String(format:"%.1f", doubleValue)
print(self.lblValue_1.text)

выход - 123,3

let doubleValue : Double = 123.32565254455
self.lblValue_2.text = String(format:"%.2f", doubleValue)
print(self.lblValue_2.text)

выход - 123,33

let doubleValue : Double = 123.32565254455
self.lblValue_3.text = String(format:"%.3f", doubleValue)
print(self.lblValue_3.text)

выпуск - 123,326

Основываясь на ответе Йоги, вот функция Swift, которая выполняет эту работу:

func roundToPlaces(value:Double, places:Int) -> Double {
    let divisor = pow(10.0, Double(places))
    return round(value * divisor) / divisor
}

В 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

Swift 4, Xcode 10

yourLabel.text =  String(format:"%.2f", yourDecimalValue)

Код для конкретных цифр после десятичных знаков:

var a = 1.543240952039
var roundedString = String(format: "%.3f", a)

Здесь% .3f сообщает Swift округлить это число до трех знаков после запятой. Если вам нужно двойное число, вы можете использовать этот код:

// Строка для удвоения

var roundedString = Double(String(format: "%.3f", b))

Используйте встроенную библиотеку 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

Если вы хотите округлить 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)
}

Удобным способом может быть использование расширения типа 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

Это своего рода долгий обходной путь, который может пригодиться, если ваши потребности немного сложнее. В 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 не является нежелательным), и потому что этот класс позволяет устанавливать несколько параметров.

Или:

1. Использование String(format:):

   • Приведите тип Double в String с %.3f спецификатором формата, а затем обратно в Double

     Double(String(format: "%.3f", 10.123546789))!
     

   • Или расширите Double для обработки N десятичных знаков:

     extension Double {
         func rounded(toDecimalPlaces n: Int) -> Double {
             return Double(String(format: "%.\(n)f", self))!
         }
     }
     

2. По расчету

   • умножьте на 10 ^ 3, округлите и затем разделите на 10 ^ 3 ...

     (1000 * 10.123546789).rounded()/1000
     

   • Или расширите Double для обработки N десятичных знаков:

     extension Double {    
         func rounded(toDecimalPlaces n: Int) -> Double {
             let multiplier = pow(10, Double(n))
             return (multiplier * self).rounded()/multiplier
         }
     }
     

я хотел бы использовать

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 по направлению к нулю. Округление до ближайшего допустимого значения, величина которого меньше или равна значению источника.

case up Округлить до ближайшего допустимого значения, которое больше или равно исходному.

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

округлить двойное значение до десятичного числа x
NO. цифр после запятой

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

Не Свифт, но я уверен, что вы уловили идею.

pow10np = pow(10,num_places);
val = round(val*pow10np) / pow10np;

Кажется, это работает в Swift 5.

Очень удивлен, что для этого уже нет стандартной функции.

// Усечение двойного числа до n десятичных знаков с округлением

extension Double {

    func truncate(to places: Int) -> Double {
    return Double(Int((pow(10, Double(places)) * self).rounded())) / pow(10, Double(places))
    }

}

Чтобы избежать дефектов Float, используйте Decimal

extension Float {
    func rounded(rule: NSDecimalNumber.RoundingMode, scale: Int) -> Float {
        var result: Decimal = 0
        var decimalSelf = NSNumber(value: self).decimalValue
        NSDecimalRound(&result, &decimalSelf, scale, rule)
        return (result as NSNumber).floatValue
    }
}

Пример
1075,58 округляет до 1075,57 при использовании Float со шкалой: 2 и .down
1075,58 округляет до 1075,58 при использовании Decimal со шкалой: 2 и .down

Мне интересно, можно ли исправить ввод пользователя. Это если они вводят три десятичных знака вместо двух для суммы в долларах. Скажем, 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


}

Вы можете добавить это расширение:

extension Double {
    var clean: String {
        return self.truncatingRemainder(dividingBy: 1) == 0 ? String(format: "%.0f", self) : String(format: "%.2f", self)
    }
}

и назовите это так:

let ex: Double = 10.123546789
print(ex.clean) // 10.12

extension String{
  var roundedValue:String {
     return String(format: "%.3f", self)
}}

Использование :

totalWorkTimeInHours.roundedValue

Вот один для SwiftUI, если вам нужен текстовый элемент с числовым значением.

struct RoundedDigitText : View {
    let digits : Int
    let number : Double

    var body : some View {
        Text(String(format: "%.\(digits)f", number))
    }
}

var n = 123.111222333
n = Double(Int(n * 10.0)) / 10.0

Результат: n = 123,1

Измените 10.0 (1 десятичный разряд) на любое из 100.0 (2 десятичных знака), 1000.0 (3 десятичных знака) и так далее для количества цифр после запятой.

Если вы хотите, чтобы после запятой оставалось только 0 для раунда, посмотрите на этот пример ниже:

extension Double {
    func isInteger() -> Any {
        let check = floor(self) == self
        if check {
            return Int(self)
        } else {
            return self
        }
    }
}

let toInt: Double = 10.0
let stillDouble: Double = 9.12

print(toInt.isInteger) // 10
print(stillDouble.isInteger) // 9.12