Convertir Float en Int dans Swift

Je veux convertir un Floatà un Intà Swift. Le casting de base comme celui-ci ne fonctionne pas car ces types ne sont pas des primitives, contrairement aux floats et ints dans Objective-C

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

Mais cela produit le message d'erreur suivant:

«Float» n'est pas convertible en «Int»

Une idée de la façon de convertir une propriété Floaten Int?

Vous pouvez convertir Floatà IntSwift comme ceci:

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

Vous pouvez également obtenir ce résultat avec le commentaire de @ paulm:

var myIntValue = Int(myFloatValue)

Conversion explicite

La conversion en Int perdra toute précision (en arrondissant efficacement). En accédant aux bibliothèques mathématiques, vous pouvez effectuer des conversions explicites. Par exemple:

Si vous souhaitez arrondir et convertir en nombre entier:

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

le résultat est 10.

Si vous souhaitez arrondir et convertir en nombre entier:

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

le résultat est 11.

Si vous souhaitez arrondir explicitement à l'entier le plus proche

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

le résultat est 11.

Dans ce dernier cas, cela peut sembler pédant, mais c'est sémantiquement plus clair car il n'y a pas de conversion implicite ... important si vous faites du traitement du signal par exemple.

La conversion est simple:

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

Mais ce n'est pas sûr:

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

Sera due à un joli crash:

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

J'ai donc créé une extension qui gère le débordement:

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

J'espère que cela peut aider quelqu'un

Il existe de nombreuses façons d'arrondir les nombres avec précision. Vous devriez éventuellement utiliser la méthode de bibliothèque standard de swift rounded()pour arrondir le nombre flottant avec la précision souhaitée.

Pour arrondir la.up règle d' utilisation :

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

Pour arrondir la.down règle d' utilisation :

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

Pour arrondir à la règle d' utilisation de l'entier le plus proche.toNearestOrEven :

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

Soyez conscient de l'exemple suivant:

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

Comme ça:

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

Vous pouvez obtenir une représentation entière de votre float en passant le float dans la méthode d'initialisation Integer.

Exemple:

Int(myFloat)

Gardez à l'esprit que tout nombre après la virgule sera une perte. Cela signifie que 3,9 est un entier de 3 et 8,99999 est un entier de 8.

Utilisez une conversion de style de fonction (trouvée dans la section intitulée «Conversion de nombres entiers et à virgule flottante» de « The Swift Programming Language » . [Lien iTunes])

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

Vous pouvez taper cast comme ceci:

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

Utilisez simplement la conversion de type

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

 println("IntegerValue = \(integerValue)")

il affichera la valeur d'arrondi, par exemple: IntegerValue = 5 signifie que le point décimal sera une perte

var i = 1 as Int

var cgf = CGFLoat(i)

var floatValue = 10.23
var intValue = Int(floatValue)

Cela suffit pour convertir de floatenInt

Supposons que vous stockiez la valeur flottante dans "X"et que vous stockiez la valeur entière dans "Y".

Var Y = Int(x);

ou

var myIntValue = Int(myFloatValue)

Utilisez Int64au lieu de Int. Int64peut stocker de grandes valeurs int.