示例
// 整型的用法小结
// 注意：
// 整型变量在使用时，遵循保小不保大的原则
// 尽量使用占用空间小的数据类型
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
}
总结
