Go 语言具有严格的静态类型限制，运算符操作的数字类型必须是相同类型数据。且数字操作不能超出该类型的取值范围，不然计算溢出得到的结果就是错的。
一、加减乘除、取模
package main
import "fmt"
func main() {
// 加 +
var ui1, ui2 uint8
ui1 = 1
ui2 = 2
ui := ui1 + ui2
fmt.Println(ui) // 输出：3
ui += 255
fmt.Println(ui) // 溢出后计算的值就是错的，输出：2
// 减 -
var i, j int32
i = 10
j = 5
fmt.Println(i - j) // 输出：5
// 乘 *
var f1, f2 float32
f1 = 1.2
f2 = 0.2
// 浮点型的数字计算有精度问题，float32 精度6位小数，float64 精度15位小数，
fmt.Println(f1 * f2) // 输出：0.24000001
// 除 /
n1 := 10
n2 := 3
fmt.Println(n1 / n2) // 输出：3，小数被丢弃
// 求模、取余 %
fmt.Println(n1 % n2) // 输出余数：1
}
二、位运算
位运算是直接对数字在内存中存储的二进制数进行操作，所以性能上来讲是最快的运算方式。位运算一般常见于需要性能优化或复杂的算法中。位运算只作用于整数类型上。
Go 语言中的位运算符：
| 运算符 | 释义 | 运算规则 |
|---|---|---|
| & | 按位与，两个数对应的二进制位相与 | 同时为1，则为1，否则为0 |
| | | 按位或，两个数对应的二进制位相或 | 有一个为1，则为1，否则为0 |
| ^ | 按位异或，两个数对应的二进制位相异或 | 二进制位不同，则为1，否则为0 |
| &^ | 按位清空 | x&^y 如果ybit位上的数是0则取x上对应位置的值，如果ybit位上为1则结果位上取0 |
| << | 左移 | 所有二进制位左移运算符右边指定的位数，高位丢弃，低位补0。左移n位就是乘以2的n次方 |
| >> | 右移 | 所有二进制位右移运算符右边指定的位数，高位补0，低位丢弃。右移n位就是除以2的n次方 |
package main
import "fmt"
func main() {
var i1, i2, n uint8 // 1个字节
// 按位与 &
i1 = 2 // 二进制：0000 0010
i2 = 3 // 二进制：0000 0011
n = i1 & i2 // 按位与：0000 0010
fmt.Println(n) // 输出：2
// 按位或 |
i1 = 10 // 二进制：0000 1010
i2 = 20 // 二进制：0001 0100
n = i1 | i2 // 按位或：0001 1110
fmt.Println(n) // 输出：30
// 按位异或 ^
i1 = 3 // 二进制：0000 0011
i2 = 4 // 二进制：0000 0100
n = i1 ^ i2 // 按位异或：0000 0111
fmt.Println(n) // 输出：7
// 按位清空 &^
i1 = 10 // 二进制：0000 1010
i2 = 20 // 二进制：0001 0100
n = i1 &^ i2 // 按位清空：0000 1010
fmt.Println(n) // 输出：10
// 左移 <<
i1 = 5 // 二进制 0000 0101
n = i1 << 2 // 左移2位：0001 0100
fmt.Println(n) // 输出：20
// 右移 >>
i2 = 15 // 二进制：0000 1111
n = i2 >> 2 // 右移2位：0000 0011
fmt.Println(n) // 输出：3
}
三、比较大小
大小比较得到的类型时布尔型。运算符：>大于、>=大于等于、<小于、<=小于等于、==等于。
package main
import "fmt"
func main() {
fmt.Println(2 > 1) // 输出：true
fmt.Println(1 == 2) // 输出：false
}
四、数字类型转换
整型从高位类型转低位类型会有精度丢失，浮点型转整型会丢失小数点后的值，复数型转非复数整型时符号丢失。数据类型转换格式：目标类型(转换类型)
package main
import "fmt"
func main() {
// 整型转浮点型
var i int = 1
fmt.Printf("%f\n", float32(i)) // 输出：1.000000
// 浮点型转整型
var f float32 = 3.1415926
fmt.Printf("%d\n", int(f)) // 输出：3，小数后丢失
// float32 转 float64
fmt.Printf("%v\n", float64(f)) // 输出：3.141592502593994，6位后的小数精度是错误的
// float64 转 float32
var f2 float64 = 3.141592653589793
fmt.Println("%v\n", float32(f2)) // 输出：3.1415927，6位后的小数精度是错误的
}
五、数字转字符串
使用 strconv 包中定义的函数做数字和字符串转换。
package main
import (
"fmt"
"strconv"
)
func main() {
// int 转 string
var i int = 111
var s string
s = strconv.Itoa(i) // 数字转字符串
fmt.Println(s)
// string 转 int
i2, err := strconv.ParseInt(s, 10, 64) // 把 s 转为10进制64位数
if err == nil {
fmt.Println(i2) // 输出：111
}
// float 转 string
var f float64 = 3.1415926535
s1 := strconv.FormatFloat(f, 'f', -1, 64)
fmt.Println(s1) // 输出：3.1415926535
// 第二个参数选项，含义如下：
// 'b' (-ddddp±ddd，二进制指数)
// 'e' (-d.dddde±dd，十进制指数)
// 'E' (-d.ddddE±dd，十进制指数)
// 'f' (-ddd.dddd，没有指数)
// 'g' ('e':大指数，'f':其它情况)
// 'G' ('E':大指数，'f':其它情况)
// string 转 float
str := `3.1415926535`
v1, err := strconv.ParseFloat(str, 32) // ParseFloat 函数默认返回float64类型数据，转成folat32可能会有精度丢失
if err == nil {
fmt.Printf("%v\n", v1) // 输出：3.1415927410125732
}
v2, err := strconv.ParseFloat(str, 64)
if err == nil {
fmt.Printf("%v\n", v2) // 输出：3.1415926535
}
}
