示例

// 整型的用法小结

// 注意：

//   整型变量在使用时，遵循保小不保大的原则

//   尽量使用占用空间小的数据类型

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

}

总结