신속하게 x 값을 소수점 이하 자릿수로 반올림

누구든지 Swift에서 x 값을 소수점 이하 자릿수로 반올림하는 방법을 말해 줄 수 있습니까?

나는 가지고있다:

var totalWorkTimeInHours = (totalWorkTime/60/60)

부착 totalWorkTime제에 NSTimeInterval를 (두 번) 인.

totalWorkTimeInHours 나에게 시간을 줄 것이다. 그러나 그것은 나에게 1.543240952039와 같은 긴 정확한 숫자로 시간을 준다.

인쇄 할 때 이것을 1.543으로 어떻게 반올림 totalWorkTimeInHours합니까?

round이를 위해 Swift의 기능을 사용할 수 있습니다 .

Double3 자리 정밀도로 반올림하려면 먼저 1000을 곱하고 반올림 한 다음 반올림 결과를 1000으로 나눕니다.

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

모든 종류 printf(...)또는 String(format: ...)솔루션 이외 의이 작업의 결과는 여전히 유형 Double입니다.

편집 :
때로는 작동하지 않는 의견에 대해서는 다음을 읽으십시오.

부동 소수점 산술에 대해 모든 프로그래머가 알아야 할 사항

스위프트 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
    }
}

스위프트 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
    }
}

소수점 이하 4 자리로 반올림 한 Double을 반환하는 예 :

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

#삼. 다윈 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. DoubleDarwin 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:)방법을 사용하여

필요한 경우 NSDecimalNumber10 진수를 반올림하는 상세하지만 강력한 솔루션을 제공합니다.

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유형은 재단의 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

# 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 2.0 및 Xcode 7.2에서 :

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

예:

이것은 완전히 작동하는 코드입니다

스위프트 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

Yogi의 답변을 바탕으로 다음은 작업을 수행하는 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

스위프트 4, Xcode 10

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

소수점 이하 자릿수 코드는 다음과 같습니다.

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

여기서 % .3f는이 숫자를 소수점 이하 3 자리로 반올림하도록 신속하게 지시합니다. 더블 숫자를 원하면 다음 코드를 사용할 수 있습니다.

// 문자열을 두 배로

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

내장 된 Foundation Darwin 라이브러리 사용

스위프트 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 유형 의 확장 을 사용하는 것입니다

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

Double값 을 반올림 하려는 경우 Swift를 사용 Decimal하여 반올림 된 값으로 수학을 시도 할 때 발생할 수있는 오류가 발생하지 않도록 할 수 있습니다. 를 사용하면 Decimal해당 둥근 부동 소수점 값의 10 진수 값을 정확하게 나타낼 수 있습니다.

그래서 당신은 할 수 있습니다 :

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

이것은 일종의 긴 해결 방법으로, 요구 사항이 좀 더 복잡 할 경우 유용 할 수 있습니다. 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를 필요한 수의 소수로 변경하십시오.

어느 한 쪽:

1. 사용 String(format:):

   • 형식 지정자 Double를 사용 String하여 타입 캐스트 %.3f한 다음Double

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

   • 또는 DoubleN- 소수점을 처리 하도록 확장하십시오 .

     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

   • 또는 DoubleN- 소수점을 처리 하도록 확장하십시오 .

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

이것은 N 유효 숫자로 반올림하는보다 유연한 알고리즘입니다.

스위프트 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

이중 속성을 포맷하는 가장 좋은 방법은 Apple 사전 정의 된 방법을 사용하는 것입니다.

mutating func round(_ rule: FloatingPointRoundingRule)

FloatingPointRoundingRule은 다음과 같은 가능성을 가진 열거 형입니다.

열거 사례 :

case awayFromZero 소스의 크기보다 크거나 같은 가장 가까운 허용 값으로 반올림합니다.

case down 소스보다 작거나 같은 가장 가까운 허용 값으로 반올림합니다.

case toNearestOrAwayFromZero 가장 가까운 허용 값으로 반올림합니다. 두 값이 동일하게 가까운 경우 더 큰 크기의 값이 선택됩니다.

case toNearestOrEven 가장 가까운 허용 값으로 반올림합니다. 두 값이 똑같이 가까운 경우 짝수 값이 선택됩니다.

case throughZero 소스의 크기보다 작거나 같은 가장 가까운 허용 값으로 반올림합니다.

case up 소스보다 크거나 같은 가장 가까운 허용 값으로 반올림합니다.

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

double 값을 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;

이것은 스위프트 5에서 작동하는 것 같습니다.

이미 표준 기능이 없다는 것이 놀랍습니다.

// 반올림으로 n에서 10 진수로 자르기

extension Double {

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

}

이 확장명을 추가 할 수 있습니다 :

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

전의.
스케일과 함께 Float를 사용할 때 1075.58은
1075.57로 반올림 : 2 ​​및 .down 스케일과 함께 Decimal을 사용할 경우 1075.58은 1075.58로 반올림합니다.

사용자의 입력을 수정할 수 있는지 궁금합니다. 즉, 1 달러로 2 대신 3을 입력하면됩니다. 1.11 대신 1.111이라고 말하면 반올림하여 수정할 수 있습니까? 여러 가지 이유에 대한 답은 없습니다! 0.001 이상의 돈은 결국 실제 수표 장에서 문제를 일으킬 것입니다.

기간이 지난 후 사용자 입력에 너무 많은 값이 있는지 확인하는 기능입니다. 그러나 이것은 1., 1.1 및 1.11을 허용합니다.

문자열에서 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


}

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

다음은 숫자 값이있는 Text 요소가 필요한 경우 SwiftUI를위한 것입니다.

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

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