Converti Float in Int in Swift

Voglio convertire un Floatin un Intin Swift. Fusione di base come questo non funziona, perché questi tipi non sono primitivi, a differenza di floats e ints in Objective-C

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

Ma questo produce il seguente messaggio di errore:

'Float' non è convertibile in 'Int'

Qualche idea su come convertire le proprietà Floatin Int?

È possibile convertire Floatin Intin Swift in questo modo:

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

Puoi anche ottenere questo risultato con il commento di @ paulm:

var myIntValue = Int(myFloatValue)

Conversione esplicita

La conversione in Int perderà qualsiasi precisione (arrotondando per difetto). Accedendo alle librerie matematiche è possibile eseguire conversioni esplicite. Per esempio:

Se si desidera arrotondare per eccesso e convertire in numero intero:

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

il risultato è 10.

Se si desidera arrotondare e convertire in numero intero:

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

il risultato è 11.

Se si desidera arrotondare esplicitamente al numero intero più vicino

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

il risultato è 11.

In quest'ultimo caso, questo potrebbe sembrare pedante, ma è semanticamente più chiaro in quanto non esiste una conversione implicita ... importante se si sta eseguendo l'elaborazione del segnale, ad esempio.

La conversione è semplice:

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

Ma non è sicuro:

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

Sarà a causa di un bel crash:

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

Quindi ho creato un'estensione che gestisce l'overflow:

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

Spero che questo possa aiutare qualcuno

Esistono molti modi per arrotondare il numero con precisione. Dovresti infine utilizzare il metodo di libreria standard di swift rounded()per arrotondare il numero float con la precisione desiderata.

Per tutto l' up uso .upregola:

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

Per arrotondare , usa la .downregola:

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

Per arrotondare al numero intero più vicino usa la .toNearestOrEvenregola:

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

Prestare attenzione al seguente esempio:

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

Come questo:

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

Puoi ottenere una rappresentazione intera del tuo float passando il float nel metodo di inizializzazione Integer.

Esempio:

Int(myFloat)

Tieni presente che qualsiasi numero dopo il punto decimale sarà una perdita. Significato, 3.9 è un Int di 3 e 8.99999 è un numero intero di 8.

Utilizzare una conversione di stile di funzione (disponibile nella sezione "Conversione di numeri interi e virgola mobile" da " Il linguaggio di programmazione Swift " . [Collegamento iTunes])

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

Puoi digitare cast in questo modo:

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

Usa il tipo casting

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

 println("IntegerValue = \(integerValue)")

mostrerà il valore di arrotondamento, ad es .: IntegerValue = 5 significa che il punto decimale sarà perdita

var i = 1 as Int

var cgf = CGFLoat(i)

var floatValue = 10.23
var intValue = Int(floatValue)

Questo è sufficiente per convertire da floataInt

Supponiamo di memorizzare il valore float "X"e di memorizzare il valore intero "Y".

Var Y = Int(x);

o

var myIntValue = Int(myFloatValue)

Usa Int64invece di Int. Int64può memorizzare valori int di grandi dimensioni.