基本数据类型

布尔型：

    bool，存储占1位，但是8位对齐所以占1个字节

数值型：

    无符号整型：

• uint8，  存储占8位，  1个字节

• uint16，存储占16位， 2个字节

• uint32，存储占32位，4个字节

• uint64，存储占64位，8个字节

    有符号整型：

• int8，  存储占8位，  1个字节

• int16，存储占16位， 2个字节

• int32，存储占32位，4个字节

• int64，存储占64位，8个字节

    浮点型：

• float32，存储占32位，4个字节

• float64，存储占64位，8个字节

    复数：

• complex64，存储占32位实数和32位虚数，8个字节

• complex128，存储占64位实数和64位虚数，16个字节

别名：

• int：有符号整型，32位操作系统占32位，4个字节；64位操作系统占64位，8个字节；

• uint：无符号整型，32位操作系统占32位，4个字节；64位操作系统占64位，8个字节；

• byte：uint8的别名

• rune：int32的别名

通过代码验证：

func baseType() {
    var b bool
    var ui8 uint8
    var ui16 uint16
    var ui32 uint32
    var ui64 uint64
    var i8 int8
    var i16 int16
    var i32 int32
    var i64 int64
    var f32 float32
    var f64 float64
    var c64 complex64
    var c128 complex128
    var i int
    var ui uint
    var by byte
    var r rune
    
    fmt.Printf("bool:       占用内存 %d 个字节\n", unsafe.Sizeof(b))
    fmt.Println()
    
    fmt.Printf("uint8:      占用内存 %d 个字节\n", unsafe.Sizeof(ui8))
    fmt.Printf("uint16:     占用内存 %d 个字节\n", unsafe.Sizeof(ui16))
    fmt.Printf("uint32:     占用内存 %d 个字节\n", unsafe.Sizeof(ui32))
    fmt.Printf("uint64:     占用内存 %d 个字节\n", unsafe.Sizeof(ui64))
    fmt.Println()
    
    fmt.Printf("int8:       占用内存 %d 个字节\n", unsafe.Sizeof(i8))
    fmt.Printf("int16:      占用内存 %d 个字节\n", unsafe.Sizeof(i16))
    fmt.Printf("int32:      占用内存 %d 个字节\n", unsafe.Sizeof(i32))
    fmt.Printf("int64:      占用内存 %d 个字节\n", unsafe.Sizeof(i64))
    fmt.Println()
    
    fmt.Printf("float32:    占用内存 %d 个字节\n", unsafe.Sizeof(f32))
    fmt.Printf("float64:    占用内存 %d 个字节\n", unsafe.Sizeof(f64))
    fmt.Println()
    
    fmt.Printf("complex64:  占用内存 %d 个字节\n", unsafe.Sizeof(c64))
    fmt.Printf("complex128: 占用内存 %d 个字节\n", unsafe.Sizeof(c128))
    fmt.Println()
    
    fmt.Printf("int:        占用内存 %d 个字节\n", unsafe.Sizeof(i))
    fmt.Printf("uint:       占用内存 %d 个字节\n", unsafe.Sizeof(ui))
    fmt.Printf("byte:       占用内存 %d 个字节\n", unsafe.Sizeof(by))
    fmt.Printf("rune:       占用内存 %d 个字节\n", unsafe.Sizeof(r))
    fmt.Println()
}

输出结果：

大数计算

当需要计算的数据超过了int64或float64能存储的最大值，我们可以使用math/big库进行计算。

先看例子再看实现原理，以big.Int为例：

func bigNumber() {
    var maxInt64 int64 = math.MaxInt64
    fmt.Printf("int64最大值:    %d\n", maxInt64)
    
    a := big.NewInt(maxInt64)
    b := big.NewInt(maxInt64)
    a.Add(a, b)
    fmt.Printf("大数相加后的值: %v\n", a)
}

输出结果：

从结果可以看出大数相加后的值是int64最大值的2倍

big.Int类型是一个结构体 

type Int struct {
    neg bool // sign
    abs nat  // absolute value of the integer
}

type nat []Word

type Word uint

neg表示符号，bool类型

abs是大整数的绝对值，nat类型表示的是uint切片。

由于存储大数的值是uint类型的切片，因此理论上可以认为大数是无限扩容的。

更多【分布式专辑】【架构实战专辑】系列文章，请关注公众号