6.Golang数字操作

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 语言中的位运算符：

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