Convertir Float a Int en Swift

Quiero convertir una Floata una Inten Swift. Moldeo básico como este no funciona debido a que estos tipos no son primitivas, a diferencia de floats y intS en Objective-C

var float: Float = 2.2
var integer: Int = float as Float

Pero esto produce el siguiente mensaje de error:

'Flotar' no es convertible a 'Int'

¿Alguna idea de cómo convertir de propiedad Floata Int?

Puede convertir Floata Inten Swift así:

var myIntValue:Int = Int(myFloatValue)
println "My value is \(myIntValue)"

También puede lograr este resultado con el comentario de @paulm:

var myIntValue = Int(myFloatValue)

Conversión explícita

La conversión a Int perderá cualquier precisión (redondeando efectivamente hacia abajo). Al acceder a las bibliotecas de matemáticas, puede realizar conversiones explícitas. Por ejemplo:

Si desea redondear hacia abajo y convertir a entero:

let f = 10.51
let y = Int(floor(f))

el resultado es 10.

Si desea redondear y convertir a entero:

let f = 10.51
let y = Int(ceil(f))

el resultado es 11.

Si desea redondear explícitamente al entero más cercano

let f = 10.51
let y = Int(round(f))

el resultado es 11.

En el último caso, esto puede parecer pedante, pero es semánticamente más claro ya que no hay conversión implícita ... importante si está haciendo procesamiento de señal, por ejemplo.

La conversión es simple:

let float = Float(1.1) // 1.1
let int = Int(float) // 1

Pero no es seguro:

let float = Float(Int.max) + 1
let int = Int(float)

Will debido a un buen accidente:

fatal error: floating point value can not be converted to Int because it is greater than Int.max

Así que he creado una extensión que maneja el desbordamiento:

extension Double {
    // If you don't want your code crash on each overflow, use this function that operates on optionals
    // E.g.: Int(Double(Int.max) + 1) will crash:
    // fatal error: floating point value can not be converted to Int because it is greater than Int.max
    func toInt() -> Int? {
        if self > Double(Int.min) && self < Double(Int.max) {
            return Int(self)
        } else {
            return nil
        }
    }
}


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

Espero que esto pueda ayudar a alguien

Hay muchas formas de redondear números con precisión. Eventualmente, debe usar el método de biblioteca estándar de swift rounded()para redondear el número flotante con la precisión deseada.

Para redondear , use la .upregla:

let f: Float = 2.2
let i = Int(f.rounded(.up)) // 3

Para redondear , use la .downregla:

let f: Float = 2.2
let i = Int(f.rounded(.down)) // 2

Para redondear al entero más cercano, use la .toNearestOrEvenregla:

let f: Float = 2.2
let i = Int(f.rounded(.toNearestOrEven)) // 2

Tenga en cuenta el siguiente ejemplo:

let f: Float = 2.5
let i = Int(roundf(f)) // 3
let j = Int(f.rounded(.toNearestOrEven)) // 2

Me gusta esto:

var float:Float = 2.2 // 2.2
var integer:Int = Int(float) // 2 .. will always round down.  3.9 will be 3
var anotherFloat: Float = Float(integer) // 2.0

Puede obtener una representación entera de su flotador pasando el flotador al método de inicializador de enteros.

Ejemplo:

Int(myFloat)

Tenga en cuenta que cualquier número después del punto decimal será una pérdida. Es decir, 3.9 es un Int de 3 y 8.99999 es un entero de 8.

Utilice una conversión de estilo de función (que se encuentra en la sección denominada "Conversión de enteros y coma flotante" de " El lenguaje de programación Swift " [enlace de iTunes])

  1> Int(3.4)
$R1: Int = 3

Puedes escribir cast así:

 var float:Float = 2.2
 var integer:Int = Int(float)

Solo usa tipo casting

 var floatValue:Float = 5.4
 var integerValue:Int = Int(floatValue)

 println("IntegerValue = \(integerValue)")

mostrará el valor de redondeo, por ejemplo: IntegerValue = 5 significa que el punto decimal será pérdida

var i = 1 as Int

var cgf = CGFLoat(i)

var floatValue = 10.23
var intValue = Int(floatValue)

Esto es suficiente para convertir de floataInt

Supongamos que almacena el valor flotante "X"y almacena el valor entero "Y".

Var Y = Int(x);

o

var myIntValue = Int(myFloatValue)

Usar en Int64lugar de Int. Int64puede almacenar grandes valores int.