golang floate64保留2位小数

在Go语言中保留float64类型数值的两位小数有多种方法，具体选择哪种方法取决于实际需求。以下是几种常见的方法：

使用 fmt.Sprintf 函数来格式化输出浮点数。这个方法适用于只需要显示结果而不需要进一步计算的场合。
go 复制代码
```
package main

import (
    "fmt"
)

func main() {
    num := 3.141592653389793
    formatted := fmt.Sprintf("%.2f", num)
    fmt.Println(formatted) // 输出: 3.14
}
```
这种方法虽然简单，但返回的是字符串类型，如果需要继续进行数值计算，则需要将字符串转换回浮点数[2][4]。
使用 math.Pow10 和 math.Trunc 函数进行截断。这种方法适用于需要在保留小数位数后继续进行数值计算的情况。
go 复制代码
```
package main

import (
    "fmt"
    "math"
)

func TruncateFloat(f float64, prec int) float64 {
    x := math.Pow10(prec)
    return math.Trunc(f*x) / x
}

func main() {
    num := 3.141592653589793
    truncated := TruncateFloat(num, 2)
    fmt.Println(truncated) // 输出: 3.14
}
```
这个方法中，我们首先将浮点数乘以10的prec次幂，然后使用 math.Trunc 函数截断小数部分，最后再除以10的prec次幂，从而实现保留指定小数位数的效果[4]。
使用 strconv.FormatFloat 和 strconv.ParseFloat 函数。这种方法可以更灵活地控制小数位数，并且可以处理四舍五入的情况。
go 复制代码
```
package main

import (
    "fmt"
    "strconv"
)

func FormatFloat(f float64, prec int) float64 {
    formattedStr := strconv.FormatFloat(f, 'f', prec, 64)
    result, _ := strconv.ParseFloat(formattedStr, 64)
    return result
}

func main() {
    num := 3.141592653589793
    formatted := FormatFloat(num, 2)
    fmt.Println(formatted) // 输出: 3.14
}
```
在这个例子中，strconv.FormatFloat 将浮点数格式化为字符串，'f' 表示固定小数点格式，prec 表示保留的小数位数。然后使用 strconv.ParseFloat 将字符串转换回浮点数[4]。

使用 shopspring/decimal 包。这个包提供了更强大的数值计算功能，能够避免浮点数运算中的精度损失，适用于金融和科学计算场景。

go 复制代码

package main

import (
    "fmt"
    "github.com/shopspring/decimal"
)

func DecimalRound(f float64, prec int) decimal.Decimal {
    d := decimal.NewFromFloat(f)
    return d.Round(prec)
}

func main() {
    num := 3.141592653589793
    rounded := DecimalRound(num, 2)
    fmt.Println(rounded.String()) // 输出: 3.14
}

这个例子中，decimal.NewFromFloat 将浮点数转换为 decimal.Decimal 类型，然后使用 Round 方法进行四舍五入[4][5]。

对于不四舍五入的情况，可以使用 math.Floor 或 math.Trunc 函数：

使用 math.Floor 函数向下取整来保留两位小数：

go 复制代码

package main

import (
    "fmt"
    "math"
)

func main() {
    num := 3.14159
    result := math.Floor(num*100) / 100
    fmt.Println(result) // 输出: 3.14
}

使用 math.Trunc 函数直接截断来保留两位小数：
go 复制代码
```
package main

import (
    "fmt"
    "math"
)

func main() {
    num := 3.14159
    result := math.Trunc(num*100) / 100
    fmt.Println(result) // 输出: 3.14
}
```
这两种方法都不会对数值进行四舍五入，而是直接向下取整或截断[2][4]。

此外，如果需要去除末尾的0，可以通过字符串处理来实现：

go 复制代码

package main

import (
    "fmt"
    "strings"
)

func main() {
    num := 3.14000
    result := fmt.Sprintf("%.2f", num)
    result = strings.TrimRight(result, "0")
    result = strings.TrimRight(result, ".")
    fmt.Println(result) // 输出: 3.14
}

这种方法首先使用 fmt.Sprintf 格式化浮点数，然后通过 strings.TrimRight 去除末尾的0[2][5]。

综上所述，Go语言提供了多种方法来保留float64类型数值的两位小数，包括四舍五入和不四舍五入的情况。对于需要高精度计算的场景，推荐使用shopspring/decimal库[2][4][5]。

Reference

[1]通过函数将golang float64 保留2位小数 - CSDN博客

[2]Golang实现浮点数精确保留两位小数的多种方法详解 - 云 ...

[3]go语言中float64 保留2位小数 - CSDN博客

[4]如何在Golang中将float64类型数值保留指定小数位数 - 云 ...

[5]使用Golang实现精确保留两位小数的技巧与实践 - 云原生实践