go var 一个整数_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

}

总结