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
}

总结