golang 中的基本数据类型

目录

整数类型

int 类型的分类

uint 类型的分类

浮点类型

字符类型

布尔类型

字符串类型

总结

---

整数类型

整数类型用来表示整数

类型	符号	占用空间	表示范围	备注
int	有	32位系统 4B 64位系统 8B	- 2^63 - 2^63-1
uint	无	32位系统 4B 64位系统 8B	0 - 2^64-1
rune	有	4B	- 2^31 - 2^31 -1	rune === int32
byte	无	1B	0 - 255	byte === unit8

 代码示例 : 

package main

import (
	"fmt"
	"unsafe"
)
func main()  {
	var n1 int = 1111111111111
	fmt.Printf("n1的类型是: %T, n1占用的字节数是: %d\n", n1,unsafe.Sizeof(n1))
	var n2 uint = 33232
	fmt.Printf("n2的类型是: %T, n2占用的字节数是: %d\n", n2,unsafe.Sizeof(n2))
	var n3 rune = 33232
	fmt.Printf("n3的类型是: %T, n3占用的字节数是: %d\n", n3,unsafe.Sizeof(n3))
	var n4 byte = 123
	fmt.Printf("n4的类型是: %T, n4占用的字节数是: %d\n", n4,unsafe.Sizeof(n4))
}

int 类型的分类

类型	符号	占用空间	表示范围
int8	有	1B	- 128 - 127
int16	有	2B	- 2^15 - 2^15 -1
int32	有	4B	- 2^31 - 2^31 -1
int64	有	8B	- 2^63 - 2^63 -1

 代码演示

package main
import (
	"fmt"
	"unsafe"
)

func main()  {
	var n1 int8 = 127
	var n2 int16= 128
	var n3 int32= 32768
	var n4 int64= 32768
	fmt.Printf("n1的类型: %T, n1占用的字节数为: %d\n",n1,unsafe.Sizeof(n1))
	fmt.Printf("n2的类型: %T, n2占用的字节数为: %d\n",n2,unsafe.Sizeof(n2))
	fmt.Printf("n3的类型: %T, n3占用的字节数为: %d\n",n3,unsafe.Sizeof(n3))
	fmt.Printf("n4的类型: %T, n4占用的字节数为: %d\n",n4,unsafe.Sizeof(n4))
}

 

uint 类型的分类

类型	符号	占用空间	表示范围
uint8	无	1B	0 - 255
uint16	无	2B	0 - 2^16 -1
uint32	无	4B	0 - 2^32 -1
uint64	无	8B	0 - 2^64 -1

package main
import (
	"fmt"
	"unsafe"
)

func main()  {
	var n1 uint8 = 255
	var n2 uint16= 256
	var n3 uint32= 4294967295
	var n4 uint64= 4294967296
	fmt.Printf("n1的类型: %T, n1占用的字节数为: %d\n",n1,unsafe.Sizeof(n1))
	fmt.Printf("n2的类型: %T, n2占用的字节数为: %d\n",n2,unsafe.Sizeof(n2))
	fmt.Printf("n3的类型: %T, n3占用的字节数为: %d\n",n3,unsafe.Sizeof(n3))
	fmt.Printf("n4的类型: %T, n4占用的字节数为: %d\n",n4,unsafe.Sizeof(n4))
}

 

浮点类型

浮点类型就是用来表示小数的

类型	占用空间	范围	特点
单精度 float32	4B	-3.403E38 - 3.403E38	精度低
双精度 float64	8B	-1.798E308 - 1.798E308	精度高, 推荐使用

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var n1 float32 = 1.2345678910123
	var n2 float64= 1.2345678910123
	fmt.Println("n1: ", n1, "n2: ", n2)
	fmt.Printf("n1的类型: %T, n1的占用空间: %d\n", n1, unsafe.Sizeof(n1))
	fmt.Printf("n2的类型: %T, n2的占用空间: %d\n", n2, unsafe.Sizeof(n2))
}

 

可以看到当数字超过浮点类型可以表示的范围时精度就不准确了, 因此在不确定数值大小时推荐使用 大一点的 float64

字符类型

golang中存储单个字符, 一般使用byte来报存, golang的字符是由字节组成的

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var s1 byte = 'a'
	var s2 int = '中'
	fmt.Println("s1对应的码值: ", s1, "s2对应的码值: ", s2)
	fmt.Printf("s1对应的unicode: %c, s2对应的unicode: %c\n", s1, s2)
	fmt.Printf("s1的类型: %T, s1的占用空间: %d\n", s1, unsafe.Sizeof(s1))
	fmt.Printf("s2的类型: %T, s2的占用空间: %d\n", s2, unsafe.Sizeof(s2))
}

 解释: 

当我们需要保存的字符对应的码值小于255时, 用byte保存 , 因为btye 和 unit8一致, 所以输出的类型是uint8 , 保存的字符码值大于255时, 用int来保存, 因为golang字符的本质就是数字, 而不同的数字也可以通过 %c 来看unicode字符

布尔类型

布尔类型只有两个值: true, false . 占用一个字节

package main

import (
	"fmt"
	"unsafe"
)
func main()  {
	var a bool = true
	var b bool = false
	fmt.Printf("a的类型: %T, b的类型: %T", a, b)
	fmt.Printf("a的大小: %d, b的类型: %d", unsafe.Sizeof(a), unsafe.Sizeof(b))
}

 字符串类型

字符串类型用于保存字符串, 字符串占用空间为16字节

package main

import (
	"fmt"
	"unsafe"
)
func main()  {
	var a string = "哈哈哈"
	var b  = `hello,
	 golang`
	b += "nb"
	fmt.Println(a, b)
	fmt.Printf("a的类型: %T, b的类型: %T\n", a, b)
	fmt.Printf("a的大小: %d, b的类型: %d", unsafe.Sizeof(a), unsafe.Sizeof(b))
}

总结: 

1. golang基本数据类型有四种 数值(int) 字符(byte) 布尔(bool) 字符串(string)

2. 数值类型具体又分为 int8,16,32,64, 分别占据1,2,4,8个字节, 是有符号的可以去正负值

3. unit是无符号的数字类型 uint8,16,32,64,同样分别占据1,2,4,8字节, 只能取正值

4. 变量声明且指定类型的默认值 

    (1) int => 0  bool => false string =>'' float(32/64) => 0

5. 变量不指定类型go会对变量进行类型推导

6. 整数不指定类型 默认为 int

7. 浮点数不指定类型 默认为 float64

8. 字符串占用16字节的空间, 布尔值占用1字节的空间

9. 字符类型只能存一个字符, 字符码值<255 类型用byte, 反之用int

10. 浮点值精度不准, 推荐使用 float64

11. %T 输出变量类型, %d 配合 unsafe,Sizeof(var) 输出变量占用空间大小, %c输出变量的unicode码, fmt.Printf配合以上代码进行格式化输出