go中整型的用法小结

代码示例

// 整型的用法小结
// 注意：
//   整型变量在使用时，遵循保小不保大的原则
//   尽量使用占用空间小的数据类型
package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // int
    var a int
    // 64位系统
    fmt.Printf("a 的默认值是 %d, 类型是 %T, 取值范围是 -9223372036854775808 ~ 9223372036854775807\n", a, a) // a 的默认值是 0, 类型是 int, 取值范围是 -9223372036854775808 ~ 9223372036854775807
    // 默认是 int 类型
    var b = 1
    fmt.Printf("b 是 %T 类型, 值是 %d, 占 %d 个字节\n", b, b, unsafe.Sizeof(b)) // b 是 int 类型, 值是 1, 占 8 个字节

    // int8
    var c int8
    fmt.Printf("c 的默认值是 %d, 类型是 %T, 取值范围是 -128 ~ 127\n", c, c) // c 的默认值是 0, 类型是 int8, 取值范围是 -128 ~ 127
    var d int8 = 127
    fmt.Printf("d 是 %T 类型, 值是 %d, 占 %d 个字节\n", d, d, unsafe.Sizeof(d)) // d 是 int8 类型, 值是 127, 占 1 个字节

    // int16
    var e int16
    fmt.Printf("e 的默认值是 %d, 类型是 %T, 取值范围是 -32768 ~ 32767\n", e, e) // e 的默认值是 0, 类型是 int16, 取值范围是 -32768 ~ 32767
    var f int16 = -32768
    fmt.Printf("f 是 %T 类型, 值是 %d, 占 %d 个字节\n", f, f, unsafe.Sizeof(f)) // f 是 int16 类型, 值是 -32768, 占 2 个字节

    // int32
    var g int32
    fmt.Printf("g 的默认值是 %d, 类型是 %T, 取值范围是 -2147483648 ~ 2147483647\n", g, g) // g 的默认值是 0, 类型是 int32, 取值范围是 -2147483648 ~ 2147483647
    var h int32 = 2147483647
    fmt.Printf("h 是 %T 类型, 值是 %d, 占 %d 个字节\n", h, h, unsafe.Sizeof(h)) // h 是 int32 类型, 值是 2147483647, 占 4 个字节

    // int64
    var i int64
    fmt.Printf("i 的默认值是 %d, 类型是 %T, 取值范围是 -9223372036854775808 ~ 9223372036854775807\n", i, i) // i 的默认值是 0, 类型是 int64, 取值范围是 -9223372036854775808 ~ 9223372036854775807
    var j int64 = 9223372036854775807
    fmt.Printf("j 是 %T 类型, 值是 %d, 占 %d 个字节\n", j, j, unsafe.Sizeof(j)) // j 是 int64 类型, 值是 9223372036854775807, 占 8 个字节

    // rune 与 int32 相同
    var k rune
    fmt.Printf("k 的默认值是 %d, 类型是 %T, 取值范围是 -2147483648 ~ 2147483647\n", k, k) // k 的默认值是 0, 类型是 int32, 取值范围是 -2147483648 ~ 2147483647
    var k1 rune = '\u0075'
    fmt.Printf("k1 是 %T 类型, 值是 %d, 占 %d 个字节\n", k1, k1, unsafe.Sizeof(k1)) // k1 是 int32 类型, 值是 117, 占 4 个字节
    var k2 rune = '\x75'
    fmt.Printf("k2 是 %T 类型, 值是 %d, 占 %d 个字节\n", k2, k2, unsafe.Sizeof(k2)) // k2 是 int32 类型, 值是 117, 占 4 个字节
    var k3 rune = 075
    fmt.Printf("k3 是 %T 类型, 值是 %d, 占 %d 个字节\n", k3, k3, unsafe.Sizeof(k3)) // k3 是 int32 类型, 值是 61, 占 4 个字节
    var k4 rune = 100
    fmt.Printf("k4 是 %T 类型, 值是 %d, 占 %d 个字节\n", k4, k4, unsafe.Sizeof(k4)) // k4 是 int32 类型, 值是 100, 占 4 个字节
    var k5 rune = '\015'
    fmt.Printf("k5 是 %T 类型, 值是 %d, 占 %d 个字节\n", k5, k5, unsafe.Sizeof(k5)) // k5 是 int32 类型, 值是 13, 占 4 个字节
    k6 := '\u00ff'
    fmt.Printf("k6 是 %T 类型, 值是 %d, 占 %d 个字节\n", k6, k6, unsafe.Sizeof(k6)) // k6 是 int32 类型, 值是 255, 占 4 个字节
    k7 := '\xff'
    fmt.Printf("k7 是 %T 类型, 值是 %d, 占 %d 个字节\n", k7, k7, unsafe.Sizeof(k7)) // k7 是 int32 类型, 值是 255, 占 4 个字节
    k8 := 'a'
    fmt.Printf("k8 是 %T 类型, 值是 %d, 占 %d 个字节\n", k8, k8, unsafe.Sizeof(k8)) // k8 是 int32 类型, 值是 97, 占 4 个字节

    // uint
    // 64位系统
    var l uint
    fmt.Printf("l 的默认值是 %d, 类型是 %T, 取值范围是 0 ~ 18446744073709551615\n", l, l) // l 的默认值是 0, 类型是 uint, 取值范围是 0 ~ 18446744073709551615
    var m uint = 188
    fmt.Printf("m 是 %T 类型, 值是 %d, 占 %d 个字节\n", m, m, unsafe.Sizeof(m)) //  是 uint 类型, 值是 188, 占 8 个字节

    // uint8
    var n uint8
    fmt.Printf("n 的默认值是 %d, 类型是 %T, 取值范围是 0 ~ 255\n", n, n) // n 的默认值是 0, 类型是 uint8, 取值范围是 0 ~ 255
    var o uint8 = 255
    fmt.Printf("o 是 %T 类型, 值是 %d, 占 %d 个字节\n", o, o, unsafe.Sizeof(o)) // o 是 uint8 类型, 值是 255, 占 1 个字节

    // uint16
    var p uint16
    fmt.Printf("p 的默认值是 %d, 类型是 %T, 取值范围是 0 ~ 65535\n", p, p) // p 的默认值是 0, 类型是 uint16, 取值范围是 0 ~ 65535
    var q uint16 = 65535
    fmt.Printf("q 是 %T 类型, 值是 %d, 占 %d 个字节\n", q, q, unsafe.Sizeof(q)) // q 是 uint16 类型, 值是 65535, 占 2 个字节

    // uint32
    var r uint32
    fmt.Printf("r 的默认值是 %d, 类型是 %T, 取值范围是 0 ~ 4294967295\n", r, r) // r 的默认值是 0, 类型是 uint32, 取值范围是 0 ~ 4294967295
    var s uint32 = 232323
    fmt.Printf("s 是 %T 类型, 值是 %d, 占 %d 个字节\n", s, s, unsafe.Sizeof(s)) // s 是 uint32 类型, 值是 232323, 占 4 个字节

    // uint64
    var u uint64
    fmt.Printf("u 的默认值是 %d, 类型是 %T, 取值范围是 0 ~ 18446744073709551615\n", u, u) // u 的默认值是 0, 类型是 uint64, 取值范围是 0 ~ 18446744073709551615
    var v uint64 = 4645458
    fmt.Printf("v 是 %T 类型, 值是 %d, 占 %d 个字节\n", v, v, unsafe.Sizeof(v)) // v 是 uint64 类型, 值是 4645458, 占 8 个字节

    // byte
    var w byte
    fmt.Printf("w 的默认值是 %d, 类型是 %T, 取值范围是 0 ~ 255\n", w, w) // w 的默认值是 0, 类型是 uint8, 取值范围是 0 ~ 255
    var x byte = 255
    fmt.Printf("x 是 %T 类型, 值是 %d, 占 %d 个字节\n", x, x, unsafe.Sizeof(x)) // x 是 uint8 类型, 值是 255, 占 1 个字节
    var x1 byte = 'a'
    fmt.Printf("x1 是 %T 类型, 值是 %d, 占 %d 个字节\n", x1, x1, unsafe.Sizeof(x1)) // x1 是 uint8 类型, 值是 97, 占 1 个字节

    // uintptr
    var y uintptr
    fmt.Printf("y 的默认值是 %d, 类型是 %T\n", y, y) // y 的默认值是 0, 类型是 uintptr
}

整理的整型的思维导图(加强记忆)

来源：https://www.cnblogs.com/goujian/p/11762595.html