如何在swift中将double转换为int

所以我想弄明白，当我不需要小数点时，如何让我的程序在一个整数后丢失.0

@IBOutlet weak var numberOfPeopleTextField: UITextField!
@IBOutlet weak var amountOfTurkeyLabel: UILabel!
@IBOutlet weak var cookTimeLabel: UILabel!
@IBOutlet weak var thawTimeLabel: UILabel!


var turkeyPerPerson = 1.5
var hours: Int = 0
var minutes = 0.0

func multiply (#a: Double, b: Double) -> Double {
    return a * b
}

func divide (a: Double , b: Double) -> Double {
    return a / b
}

@IBAction func calculateButton(sender: AnyObject) {
    var numberOfPeople = numberOfPeopleTextField.text.toInt()
    var amountOfTurkey = multiply(a: 1.5, b: Double(numberOfPeople!))
    var x: Double = amountOfTurkey
    var b: String = String(format:"%.1f", x)
    amountOfTurkeyLabel.text = "Amount of Turkey: " + b + "lbs"

    var time = multiply(a: 15, b:  amountOfTurkey)
    var x2: Double = time
    var b2: String = String(format:"%.1f", x2)
    if (time >= 60) {
        time = time - 60
        hours = hours + 1
        minutes = time
        var hours2: String = String(hours)
        var minutes2: String = String(format: "%.1f", minutes)

        cookTimeLabel.text = "Cook Time: " + hours2 + " hours and " + minutes2 + " minutes"
    }else {
        cookTimeLabel.text = "Cook Time: " + b2 + "minutes"
    }

}

}

我是否需要使用if语句将Double转换为Int才能工作？

您可以使用：

Int(yourDoubleValue)

这将把double转换为int

或者使用字符串格式时，请使用0而不是1：

String(format: "%.0f", yourDoubleValue)

---

这将只显示不带小数点的双精度值，而不将其转换为int。

在

双精度

值的字符串表示形式中，抑制（仅）0小数点的更通用方法是使用

NSNumberFormatter

。它还考虑当前区域设置的数字格式

let x : Double = 2.0
let doubleAsString = NumberFormatter.localizedString(from: (NSNumber(value: x), numberStyle: .decimal) 
// --> "2"

---

最好在转换前验证

Double

值的大小，否则可能会崩溃

extension Double {
    func toInt() -> Int? {
        if self >= Double(Int.min) && self < Double(Int.max) {
            return Int(self)
        } else {
            return nil
        }
    }
}

双分机{
functiont（）->Int{
如果self>=Double（Int.min）和&self

---

崩溃很容易演示，只需使用

Int（Double.greatestfinitemagnity）

Swift 4-Xcode 9

let value = doubleToInteger(data:"ENTER DOUBLE VALUE")

func doubleToInteger(data:Double)-> Int {
            let doubleToString = "\(data)"
            let stringToInteger = (doubleToString as NSString).integerValue

            return stringToInteger
        }

---

这些答案实际上没有考虑到双精度表达式Int.max和Int.min的局限性。整数是64位的，但双精度的尾数只有52位精度

更好的答案是：

extension Double {
    func toInt() -> Int? {
        guard (self <= Double(Int.max).nextDown) && (self >= Double(Int.min).nextUp) else {
            return nil
        }

        return Int(self)
    }
}

双分机{
functiont（）->Int{
防护装置（自身=Double（Int.min）.nextUp）其他{
归零
}
返回Int（self）
}
}

Swift 4-Xcode 10

如果double值超过int边界（因此不可表示），请使用此代码避免崩溃：

将此专用扩展添加到类：

private extension Int {

    init?(doubleVal: Double) {
        guard (doubleVal <= Double(Int.max).nextDown) && (doubleVal >= Double(Int.min).nextUp) else {
        return nil
    }

    self.init(doubleVal)
}

这应该是可行的：

//将您的双人间四舍五入，使其完全可转换
如果let converted=Int（确切地说：double.rounded（））{
doSomethingWithInteger（已转换）
}否则{
//double不可兑换是有原因的，它可能会溢出
reportAnError（“\（双精度）不可转换”）
}

init（精确：）

与

init（：）

几乎相同，唯一的区别是

init（精确：）

不会崩溃，而

init（：）

在失败时可以调用

fatalError（：）

您可以在这里检查它们的实现

---

测试结果

for i in stride(from: 0.5, to: 10, by: 0.5) {
  print("\(i): \(i.prettyWeight)")
}

0.5: 0.5kg
1.0: 1kg
1.5: 1.5kg
2.0: 2kg
2.5: 2.5kg
3.0: 3kg
3.5: 3.5kg
4.0: 4kg
4.5: 4.5kg
5.0: 5kg
5.5: 5.5kg
6.0: 6kg
6.5: 6.5kg
7.0: 7kg
7.5: 7.5kg
8.0: 8kg
8.5: 8.5kg
9.0: 9kg
9.5: 9.5kg

另一种方式

extension Double {

    func toInt() -> Int? {
        let roundedValue = rounded(.toNearestOrEven)
        return Int(exactly: roundedValue)
    }

}

  

---

如果您不喜欢非常大的值，请使用此代码将

Doubl钳制为max/min

Int`值

let bigDouble   = Double.greatestFiniteMagnitude
let smallDouble = -bigDouble

extension Double {
    func toIntTruncated() -> Int {
        let maxTruncated  = min(self, Double(Int.max).nextDown) // Nota bene: crashes without `nextDown`
        let bothTruncated = max(maxTruncated, Double(Int.min))
        return Int(bothTruncated)
    }
}

let bigDoubleInt   = bigDouble.toIntTruncated()
let smalDoublelInt = smallDouble.toIntTruncated()

---

使用DOUBLEVALUE的toInt（）函数名称。toInt（）这不是一个好方法，如果超过

Int

的边界，它将崩溃。例如，

Int（Double.greatestfinitemagnity）

呼应托马斯·林哈特。这种方法不安全。示例：

Int（Double.infinity）//崩溃

Current right way:NumberFormatter.localizedString（from:NSNumber（value:self），number:decimal）

Int（justice:）

将无法将无法精确转换为整数的

Double

值转换为整数。例如，

Int（确切地说：3.1）

将返回

nil

@isaacoracker如果您是对的，则信息不正确。我删除了它。严格地说，

=

和

@BaseZen No.：-）将崩溃。@TomášLinhart舍入崩溃仅在正的一侧，其中-1偏移会导致麻烦<代码>双精度

可以精确表示2^63或9223372036854775808（一个过高）或9223372036854774784（511过低），但不能介于两者之间。然而，2^-63在两种表示法中都是精确的（毕竟都是二进制的），而且

=

确实有效。他们通过使用<而不是

extension Double {

    func toInt() -> Int? {
        let roundedValue = rounded(.toNearestOrEven)
        return Int(exactly: roundedValue)
    }

}

  

let bigDouble   = Double.greatestFiniteMagnitude
let smallDouble = -bigDouble

extension Double {
    func toIntTruncated() -> Int {
        let maxTruncated  = min(self, Double(Int.max).nextDown) // Nota bene: crashes without `nextDown`
        let bothTruncated = max(maxTruncated, Double(Int.min))
        return Int(bothTruncated)
    }
}

let bigDoubleInt   = bigDouble.toIntTruncated()
let smalDoublelInt = smallDouble.toIntTruncated()