go使用decimal

在公司项目中看到关于钱的数据在接口展示、添加修改的各种情况下结构体中相应字段用的都是string类型。觉得不太合理，因此查阅了一些资料，整理如下。

创新互联建站服务紧随时代发展步伐，进行技术革新和技术进步，经过十载的发展和积累，已经汇集了一批资深网站策划师、设计师、专业的网站实施团队以及高素质售后服务人员，并且完全形成了一套成熟的业务流程，能够完全依照客户要求对网站进行成都网站设计、网站制作、建设、维护、更新和改版，实现客户网站对外宣传展示的首要目的，并为客户企业品牌互联网化提供全面的解决方案。

在网上搜到一篇博客:

在程序计算中涉及到钱的时候，为什么要用Decimal而不是Float

博客中介绍，如果用float类型再转为decimal类型时会造成精度丢失。转为string后再转为decimal则可以解决问题，保证精度。看着好像是很完美的回答了我想要了解的问题，但仔细一看用的语言是python，于是我便亲自试了下：

结果确实如此，但看版本是2.7，我怀疑是不是python2.7版本落后，因此存在问题，于是又换了python3，再次测试：

结论依然是一样。好吧，证实了，对于python确实应该先转为string再转为decimal。

但是，python是这样，难道go也是这样吗，于是我又开始了进一步测试：

go中decimal使用第三方库

这里是直接用float64转为decimal，并没有通过string中转，结果输出如下：

乍一看，看着好像是精度丢失了似的，但是对比后我们发现，float64和decimal前后都是一致的，也就是说float64转为decimal之后，保持了原样。那些看起来小数点后位数很多的结果，是因为float64浮点类型计算产生的问题，跟转换并没有关系。

为了验证这一结论，我又写了下面的测试：

不使用浮点类型相加，而用decimal类型相加，这样输出结果果然没问题了：

因此我们可以得出结论：对于go语言，在把float转换为decimal类型时，并不需要像python一样通过string中转，也依然可以保持精度。进一步，我们也可以想到上面的问题，对于钱，在结构体字段中，我们完全可以直接使用float类型，并不需要用string类型。而且好处时，使用float数值类型，无论对于前端还是后端，在进行数值范围验证的时候，会更方便，不必把string转为float后再验证了。

上面提到了decimal包，我们这里简单看下，里面的常用的方法：

定义decimal的几种方式：

decimal数值运算

比较：

我们再看下浮点精度运算不准确的原因，这篇文章讲解的比较细

浮点精度（float、double）运算不精确的原因

精度运算不准确这是为什么呢？我们接下来就需要从计算机所有数据的表现形式二进制说起了。如果大家很了解二进制与十进制的相互转换，那么就能轻易的知道精度运算不准确的问题原因是什么了。

接下来我们看一个简单的例子 2.1 这个十进制数转成二进制是什么样子的。

落入无限循环结果为 10.0001100110011........ ， 我们的计算机在存储小数时肯定是有长度限制的，所以会进行截取部分小数进行存储，从而导致计算机存储的数值只能是个大概的值，而不是精确的值。从这里看出来我们的计算机根本就无法使用二进制来精确的表示 2.1 这个十进制数字的值，连表示都无法精确表示出来，计算肯定是会出现问题的。

1、为什么数值表示用decimal 不用double

2、在程序计算中涉及到钱的时候，为什么要用Decimal而不是Float

3、MySQL数据类型DECIMAL用法

4、浮点精度（float、double）运算不精确的原因

go的uint64转换成java的哪种类型

Golang 和java/c不同，Go在不同类型的变量之间赋值时需要显式转换。也就是说Golang中数据类型不能自动转换。

基本语法

表达式T（v））将值v 转换为类型T

T∶就是数据类型，比如int32，int64，float32等等

v∶ 就是需要转换的变量

var i int = 100

var b float64 = float64(i)

var c int64 = int64(b)

fmt.Printf("b=%f,c=%d",b,c)

b=100.000000,c=100

登录后复制

细节说明

1）Go中，数据类型的转换可以是从表示范围小-表示范围大，也可以范围大一范围小

2） 被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化!

3） 在转换中，比如将 int64 转成int8，编译时不会报错，只是转换的结果是按溢出处理，和

我们希望的结果不一样。（在转换的时候需要注意范围）

var a int64 = 10000000

var b int8 = int8(a)

fmt.Printf("%d",b)

-128

登录后复制

可以看到在转换的时候，一定要保证转换大数据要是对方可以接受的范围。

n1类型是int32，那么➕20整个就是int32类型，可是n2是int64，这样就会编译错误。

题二n4是12 + 127溢出超过了范围，运行的时候按照溢出处理。n3是直接编译不通过，128已经超过了int8类型的范围

基本数据类型和string的转换

字符串格式化

Go语言用于控制文本输出常用的标准库是fmt

fmt中主要用于输出的函数有:

Print: 输出到控制台,不接受任何格式化操作

Println: 输出到控制台并换行

Printf : 只可以打印出格式化的字符串。只可以直接输出字符串类型的变量（不可以输出别的类型）

Sprintf：格式化并返回一个字符串而不带任何输出

Fprintf：来格式化并输出到 io.Writers 而不是 os.Stdout

整数类型

格 式 描 述

%b 整型以二进制方式显示

%o 整型以八进制方式显示

%d 整型以十进制方式显示

%x 整型以十六进制方式显示

%X 整型以十六进制、字母大写方式显示

%c 相应Unicode码点所表示的字符

%U Unicode 字符, Unicode格式：123，等同于 "U+007B"

浮点数

格 式 描 述

%e 科学计数法，例如 -1234.456e+78

%E 科学计数法，例如 -1234.456E+78

%f 有小数点而无指数，例如 123.456

%g 根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出

%G 根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出

布尔

格 式 描 述

%t true 或 false

字符串

格 式 描 述

%s 字符串或切片的无解译字节

%q 双引号围绕的字符串，由Go语法安全地转义

%x 十六进制，小写字母，每字节两个字符

%X 十六进制，大写字母，每字节两个字符

指针

格 式 描 述

%p 十六进制表示，前缀 0x

var num1 int64 = 99

var num2 float64 = 23.99

var b bool = true

var mychar byte = 'h'

str1 := fmt.Sprintf("%d",num1)

str2 := fmt.Sprintf("%f",num2)

bool1 := fmt.Sprintf("%t",b)

mychar1 := fmt.Sprintf("%c",mychar)

fmt.Printf("%T,%T,%T,str1=%v,str2=%v,bool1=%v,mychar1=%v",str1,bool1,str2,str1,str2,bool1,mychar1)

string,string,string,string,str1=99,str2=23.990000,bool1=true,mychar1=h

登录后复制



使用strconv包 基本类型 - string类型

num1 := 99

str1 := strconv.FormatInt(int64(num1),10)

fmt.Printf("%T,%v",str1,str1)

num2 := 99.99

str2 := strconv.FormatFloat(num2,'f',10,64)

fmt.Printf("%T,%v\n",str2,str2)

登录后复制

strconv包提供了字符串与简单数据类型之间的类型转换功能，可以将简单类型转换为字符串，也可以将字符串转换为其它简单类型

string和int转换

int转string的方法是: Itoa()

str := strconv.Itoa(100)

fmt.Printf("type %v, value: %s\n", reflect.TypeOf(str), str)

登录后复制

2.string转int的方法是:

i, err := strconv.Atoi("100")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登录后复制

并不是所有string都能转化为int, 所以可能会报错:

i, err := strconv.Atoi("100x")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登录后复制

使用strconv包 string转其他类型

strconv包提供的Parse类函数用于将字符串转化为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint() 由于字符串转换为其它类型可能会失败，所以这些函数都有两个返回值，第一个返回值保存转换后的值，第二个返回值判断是否转换成功。

1.转bool

b, err := strconv.ParseBool("true")

fmt.Println(b, err)

登录后复制

2.转float

f1, err := strconv.ParseFloat("3.1", 32)

fmt.Println(f1, err)

f2, err := strconv.ParseFloat("3.1", 64)

fmt.Println(f2, err)

登录后复制

由于浮点数的小数部分 并不是所有小数都能在计算机中精确的表示, 这就造成了浮点数精度问题, 比如下面

var n float64 = 0

for i := 0; i 1000; i++ {

n += .01

}

fmt.Println(n)

关于浮点数精度问题: c计算机不都是0101吗，你有想过计算机是怎么表示的小数吗, 简单理解就是:

将其整数部分与小树部分分开, 比如5.25

对于整数部分 5 ，我们使用"不断除以2取余数"的方法，得到 101

对于小数部分 .25 ，我们使用"不断乘以2取整数"的方法，得到 .01

听说有一个包可以解决这个问题: github.com/shopspring/decimal

3.转int

func ParseInt(s string, base int, bitSize int) (i int64, err error)

base: 进制，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制方式解析

bitSize: 多少位，有效值为0、8、16、32、64。当bitSize=0的时候，表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8

fmt.Println(bInt8(-1)) // 0000 0001(原码) - 1111 1110(反码) - 1111 1111

// Parse 二进制字符串

i, err := strconv.ParseInt("11111111", 2, 16)

fmt.Println(i, err)

// Parse 十进制字符串

i, err = strconv.ParseInt("255", 10, 16)

fmt.Println(i, err)

// Parse 十六进制字符串

i, err = strconv.ParseInt("4E2D", 16, 16)

fmt.Println(i, err)

4.转uint

func ParseUint(s string, base int, bitSize int) (uint64, error)

用法和转int一样, 只是转换后的数据类型是uint64

u, err := strconv.ParseUint("11111111", 2, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("255", 10, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("4E2D", 16, 16)

fmt.Println(u, err)

其他类型转string

将给定类型格式化为string类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

fmt.Println(strconv.FormatBool(true))

// 问题又来了

fmt.Println(strconv.FormatInt(255, 2))

fmt.Println(strconv.FormatInt(255, 10))

fmt.Println(strconv.FormatInt(255, 16))

fmt.Println(strconv.FormatUint(255, 2))

fmt.Println(strconv.FormatUint(255, 10))

fmt.Println(strconv.FormatUint(255, 16))

fmt.Println(strconv.FormatFloat(3.1415, 'E', -1, 64))

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指数为二进制）、'e'（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）、'g'（指数很大时用'e'格式，否则'f'格式）、'G'（指数很大时用'E'格式，否则'f'格式）。

prec控制精度（排除指数部分）：对'f'、'e'、'E'，它表示小数点后的数字个数；对'g'、'G'，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。

Golang Float高精度计算，无误差

Golang Float乘Float高精度，转Int高精度。

使用big.Float

bigF1 := new(big.Float).SetFloat64(f1)

bigF2 := new(big.Float).SetFloat64(f2)

mul := new(big.Float).Mul(bigF1, bigF2)

转Int，先用上面的方法转为big.Float，再用.String转为字符串。

new(big.Int).SetString(bigFloat, 10) // 即可转为big.Int

// big.Int可转为常用的int类型。

// big.Float可转为常用的Float类型。

// big.Float不能直接转为Int类型。

func Sub(x float64, y float64, more ...float64) float64 {

floatX := new(big.Float).SetFloat64(x)

floatY := new(big.Float).SetFloat64(y)

result := new(big.Float).Sub(floatX, floatY)

if len(more) 0 {

  for _, m := range more {

    floatM := new(big.Float).SetFloat64(m)

    result = new(big.Float).Sub(result, floatM)

}

}

f, _ := strconv.ParseFloat(result.String(), 64)

return f

}

go类型转换

type_name(expression)

float跟int可以互转，但是会丢失所有精度。

func AppendBool(dst []byte, b bool) []byte

AppendBool 根据 b 的值将“true”或“false”附加到 dst 并返回扩展缓冲区。

func AppendFloat(dst []byte, f float64, fmt byte, prec, bitSize int) []byte

AppendFloat 将由 FormatFloat 生成的浮点数 f 的字符串形式附加到 dst 并返回扩展缓冲区。

func AppendInt(dst []byte, i int64, base int) []byte

AppendInt 将由 FormatInt 生成的整数i的字符串形式附加到 dst 并返回扩展缓冲区。

func AppendQuote(dst []byte, s string) []byte

AppendQuote 将由 Quote 生成的代表 s 的双引号 Go 字符串文字附加到 dst 并返回扩展缓冲区。

func AppendQuoteRune(dst []byte, r rune) []byte

AppendQuoteRune 将由 QuoteRune 生成的表示符文的单引号 Go 字符文字附加到 dst 并返回扩展缓冲区。

func AppendQuoteRuneToASCII(dst []byte, r rune) []byte

AppendQuoteRuneToASCII 将由 QuoteRuneToASCII 生成的代表该符文的单引号 Go 字符文字附加到 dst 并返回扩展缓冲区。

func AppendQuoteRuneToGraphic(dst []byte, r rune) []byte

AppendQuoteRuneToGraphic 将由 QuoteRuneToGraphic 生成的表示符文的单引号 Go 字符文字附加到 dst 并返回扩展缓冲区。

func AppendQuoteToASCII(dst []byte, s string) []byte

AppendQuoteToASCII 将由 QuoteToASCII 生成的代表 s 的双引号 Go 字符串文字附加到 dst 并返回扩展缓冲区。

func AppendQuoteToGraphic(dst []byte, s string) []byte

AppendQuoteToGraphic 将由 QuoteToGraphic 生成的代表 s 的双引号 Go 字符串文字附加到 dst 并返回扩展缓冲区。

func AppendUint(dst []byte, i uint64, base int) []byte

AppendUint 将由 FormatUint 生成的无符号整数 i 的字符串形式附加到 dst 并返回扩展缓冲区。

func Atoi(s string) (int, error)

Atoi 返回 ParseInt(s, 10, 0) 转换为 int 类型的结果。

func CanBackquote(s string) bool

CanBackquote 报告字符串 s 是否可以不改变为单行反引号字符串，而不包含 tab 以外的控制字符。

func FormatBool(b bool) string

FormatBool 根据 b 的值返回“true”或“false”

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

FormatFloat 根据格式 fmt 和 precision prec 将浮点数f转换为字符串。它将结果进行四舍五入，假设原始数据是从 bitSize 位的浮点值获得的（float32为32，float64为64）。

格式 fmt 是 'b'（-ddddp±ddd，二进制指数），'e'（-d.dddde±dd，十进制指数），'E'（-d.ddddE±dd，十进制指数），'f'（-ddd.dddd，无指数），'g'（'e'表示大指数，'f'表示否则）或 'G'（'E'表示大指数，否则'f'）。

precision prec 控制由 'e'，'E'，'f'，'g' 和 'G' 格式打印的位数（不包括指数）。对于 'e'，'E' 和 'f'，它是小数点后的位数。对于 'g' 和 'G' 这是总位数。特殊精度-1使用必需的最小位数，以便 ParseFloat 完全返回 f 。

func FormatInt(i int64, base int) string

FormatInt 返回给定基数中的i的字符串表示，对于2 = base = 36.结果对于数字值 = 10使用小写字母 'a' 到 'z' 。

func FormatUint(i uint64, base int) string

FormatUint 返回给定基数中的 i 的字符串表示，对于2 = base = 36.结果对于数字值 = 10使用小写字母 'a' 到 'z' 。

func IsGraphic(r rune) bool

IsGraphic 报告符文是否被 Unicode 定义为 Graphic。这些字符包括类别 L，M，N，P，S 和 Z 中的字母，标记，数字，标点，符号和空格。

func IsPrint(r rune) bool

IsPrint 报告该符文是否被 Go 定义为可打印，其定义与 unicode.IsPrint 相同：字母，数字，标点，符号和 ASCII 空格。

func Itoa(i int) string

Itoa 是 FormatInt(int64(i), 10) 的缩写。

func ParseBool(str string) (bool, error)

ParseBool 返回字符串表示的布尔值。它接受1，t，T，TRUE，true，True，0，f，F，FALSE，false，False。任何其他值都会返回错误。

func ParseFloat(s string, bitSize int) (float64, error)

ParseFloat 将字符串 s 转换为浮点数，精度由 bitSize：32指定，float32为64; float64为64。当 bitSize = 32时，结果仍然具有 float64 类型，但可以在不更改其值的情况下将其转换为 float32。

如果s格式良好且接近有效的浮点数，则 ParseFloat 返回使用 IEEE754 无偏舍入舍入的最近浮点数。

ParseFloat 返回的错误具有具体类型 * NumError 并包含 err.Num = s。

如果 s 在语法上不是格式良好的，ParseFloat 返回 err.Err = ErrSyntax。

如果 s 在语法上格式良好，但距离给定大小的最大浮点数大于1/2 ULP，则 ParseFloat 返回 f =±Inf，err.Err = ErrRange。

func ParseInt(s string, base int, bitSize int) (i int64, err error)

ParseInt 解释给定基础（2到36）中的字符串 s 并返回相应的值 i。如果 base == 0，则基数由字符串的前缀隐含：base 16代表“0x”，base 8代表“0”，否则以10为底数。

bitSize 参数指定结果必须适合的整数类型。位大小 0,8,16,32 和 64 对应于 int，int8，int16，int32 和 int64。

ParseInt 返回的错误具有具体类型 * NumError 并包含err.Num = s。如果s为空或包含无效数字，则 err.Err = ErrSyntax，返回值为0; 如果与s对应的值不能用给定大小的有符号整数表示，则 err.Err = ErrRange，返回的值是相应 bitSize 和符号的最大幅度整数。

func ParseUint(s string, base int, bitSize int) (uint64, error)

ParseUint 就像 ParseInt，但是对于无符号数字。

func Quote(s string) string

Quote 返回一个双引号的 Go 字符串字面表示s。返回的字符串使用 Go 转义序列 (\t, \n, \xFF, \u0100) 作为 IsPrint 定义的控制字符和非可打印字符。

func QuoteRune(r rune) string

QuoteRune 返回一个表示符文的单引号 Go 字符。返回的字符串使用 Go 转义序列(\t, \n, \xFF, \u0100) 作为 IsPrint 定义的控制字符和非可打印字符。

func QuoteRuneToASCII(r rune) string

QuoteRuneToASCII 返回表示符文的单引号 Go 字符。对于非 ASCII 字符和 IsPrint 定义的非可打印字符，返回的字符串使用 Go 转义序列 (\t, \n, \xFF, \u0100)。

func QuoteRuneToGraphic(r rune) string

QuoteRuneToGraphic 返回代表符文的单引号 Go 字符。对于非 ASCII 字符和 IsGraphic 定义的非可打印字符，返回的字符串使用Go转义序列 (\t, \n, \xFF, \u0100)。

func QuoteToASCII(s string) string

QuoteToASCII 返回一个代表 s 的双引号 Go 字符串。对于非 ASCII 字符和 IsPrint 定义的非可打印字符，返回的字符串使用 Go 转义序列 (\t, \n, \xFF, \u0100) 。

func QuoteToGraphic(s string) string

QuoteToGraphic 返回一个代表 s 的双引号 Go 字符串。对于非 ASCII 字符和 IsGraphic 定义的非可打印字符，返回的字符串使用 Go 转义序列 (\t, \n, \xFF, \u0100)。

func Unquote(s string) (string, error)

Unquote 将 s 解释为单引号，双引号或反引号的 Go 字符串文字，返回引用的字符串值。（如果 s 是单引号，它将是一个 Go 字符字面量； Unquote 会返回相应的一个字符字符串。）

网页标题：go语言整形转换浮点型 go语言byte转int
分享网址：http://pwwzsj.com/article/dohieji.html