Converti un float64 in un int in Go

Come si converte un float64 in un int in Go? So che il strconvpacchetto può essere utilizzato per convertire qualsiasi cosa in o da una stringa, ma non tra tipi di dati in cui uno non è una stringa. So di poterlo usare fmt.Sprintfper convertire qualsiasi cosa in una stringa e poi strconvnel tipo di dati di cui ho bisogno, ma questa conversione extra sembra un po 'goffa: c'è un modo migliore per farlo?

package main
import "fmt"
func main() {
  var x float64 = 5.7
  var y int = int(x)
  fmt.Println(y)  // outputs "5"
}

Il semplice casting su un int tronca il float, che se il tuo sistema rappresenta internamente 2.0 come 1.9999999999, non otterrai ciò che ti aspetti. Le varie conversioni printf si occupano di questo e arrotondano correttamente il numero durante la conversione. Quindi, per ottenere un valore più accurato, la conversione è ancora più complicata di quanto potresti aspettarti:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    floats := []float64{1.9999, 2.0001, 2.0}
    for _, f := range floats {
        t := int(f)
        s := fmt.Sprintf("%.0f", f)
        if i, err := strconv.Atoi(s); err == nil {
            fmt.Println(f, t, i)
        } else {
            fmt.Println(f, t, err)
        }
    }
}

Codice su Go Playground

Se è semplicemente da float64 a int, dovrebbe funzionare

package main

import (
    "fmt"
)

func main() {
    nf := []float64{-1.9999, -2.0001, -2.0, 0, 1.9999, 2.0001, 2.0}

    //round
    fmt.Printf("Round : ")
    for _, f := range nf {
        fmt.Printf("%d ", round(f))
    }
    fmt.Printf("\n")

    //rounddown ie. math.floor
    fmt.Printf("RoundD: ")
    for _, f := range nf {
        fmt.Printf("%d ", roundD(f))
    }
    fmt.Printf("\n")

    //roundup ie. math.ceil
    fmt.Printf("RoundU: ")
    for _, f := range nf {
        fmt.Printf("%d ", roundU(f)) 
    }
    fmt.Printf("\n")

}

func roundU(val float64) int {
    if val > 0 { return int(val+1.0) }
    return int(val)
}

func roundD(val float64) int {
    if val < 0 { return int(val-1.0) }
    return int(val)
}

func round(val float64) int {
    if val < 0 { return int(val-0.5) }
    return int(val+0.5)
}

Uscite:

Round : -2 -2 -2 0 2 2 2 
RoundD: -2 -3 -3 0 1 2 2 
RoundU: -1 -2 -2 0 2 3 3 

Ecco il codice nel playground: https://play.golang.org/p/HmFfM6Grqh

È possibile utilizzare la int()funzione per convertire i float64dati di tipo in un file int. Allo stesso modo puoi usarefloat64()

Esempio:

func check(n int) bool { 
    // count the number of digits 
    var l int = countDigit(n)
    var dup int = n 
    var sum int = 0 

    // calculates the sum of digits 
    // raised to power 
    for dup > 0 { 
        **sum += int(math.Pow(float64(dup % 10), float64(l)))** 
        dup /= 10 
    } 

    return n == sum
} 

Probabilmente si desidera un arrotondamento corretto.

Quindi math.Round () è il tuo amico veloce (!). Gli approcci con fmt.Sprintf e strconv.Atois () erano 2 ordini di grandezza più lenti secondo i miei test con una matrice di valori float64 che dovevano diventare valori int arrotondati correttamente.

package main
import (
    "fmt"
    "math"
)
func main() {
    var x float64 = 5.51
    var y float64 = 5.50
    var z float64 = 5.49
    fmt.Println(int(math.Round(x)))  // outputs "6"
    fmt.Println(int(math.Round(y)))  // outputs "6"
    fmt.Println(int(math.Round(z)))  // outputs "5"
}

math.Round () restituisce un valore float64 ma con int () applicato successivamente, non sono riuscito a trovare alcuna mancata corrispondenza finora.