数据类型:
计算机存储设备最小信息单位是位(bit),最小的存储单元是字节(byte),占用字节的不同,所表示能存储的数据长度不同。数据类型用来说明数据的数据的结构,便于定义变量、参数传递等。
数据类型默认值:
类型 |
默认值 |
整型 |
0 |
浮点型 |
0.0 |
字符串 |
“” |
布尔类型 |
false |
数据类型说明:
1B=8bit(字节),1KB=1024B,1MB=1024KB,1G=1024MB
类型 |
有无符号 |
名称 |
占用字节 |
说明 |
bool |
有 |
布尔类型 |
1 |
只有true或false,默认是false |
byte |
无 |
字节型 |
1 |
等价于uint8,当要存储字符的时候可以byte |
rune |
有 |
字符类型 |
4 |
专用于存储unicode编码,等价于uint32 |
int |
有 |
整型 |
4或8 |
32位系统4个字节 64位系统8个字节int占用多大取决于操作系统
|
uint |
无 |
整型 |
4或8 |
32位系统4个字节 64位系统8个字节 |
int8 |
有 |
整型 |
1 |
-128 ~ 127 |
int16 |
有 |
整型 |
2 |
-32768 ~ 32767 |
int32 |
有 |
整型 |
4 |
-2147483648 ~ 2147483647 |
int64 |
有 |
整型 |
8 |
-9223372036854775808 ~ 9223372036854775807 |
uint8 |
无 |
整型 |
1 |
0 ~ 255 |
uint16 |
无 |
整型 |
2 |
0 ~ 65535 |
uint32 |
无 |
整型 |
4 |
0 ~ 4294967295(42亿) |
uint64 |
无 |
整型 |
8 |
0 ~ 18446744073709551615 |
float32 |
有 |
浮点型 |
4 |
小数位精确到7位 |
float64 |
有 |
浮点型 |
8 |
小数位精确到15位 |
complex64 |
有 |
复数类型 |
8 |
32 位实数和虚数 |
complex128 |
有 |
复数类型 |
16 |
64 位实数和虚数 |
uintptr |
有 |
整型 |
4或8 |
无符号整型,⾜以存储指针的uint32或uint64整数 |
string |
有 |
字符串 |
|
utf-8字符串 |
占用字节数不同有什么区别:
数据类型占用不同的字节所表示的存储空间大小不同
有符号和无符号的区别:
有符号的,长度第一位会存类型,剩余的长度才是数据。无符号的全部都可以存数据。前面有u
就是无符号,没有u
就是有符号
有符号和无符号如何选择:
如果只存整数就使用无符号的,因为范围更大,如果存的有负数就用有符号的。
能用小的就不要选择大的,比如年龄就用byte(0 ~ 255)
查看变量的数据类型:
fmt.Printf("%T", 变量名)
查看变量占用的字节大小:
fmt.Printf("%d", unsafe.Sizeof(变量名))// unsafe.Sizeof(num):返回指定变量占用的字节数
基本数据类型和引用类型区别:
基本数据类型:int、float、bool、string、数组、结构体
引用类型:指针、切片、map、管道、接口
区别:
基本数据类型的变量是直接存数据的,通常在栈中分配
引用数据类型的变量存的是内存地址,这个变量分配的空间才是存数据的,通常在堆中分配的。当没有引用变量的时候,会由GC回收变成垃圾
整型:
func main() {
var age uint = -10 // 报错,不支持负数
fmt.Println(age)
var b byte = 1
var r rune = 2
fmt.Printf("数据类型是:%T,%T", b, r) //uint8,int32
}
浮点类型:
关于数学运算的包里默认都是用的float64,日常使用也尽量使用float64的就行了,浮点数可能会造成精度损失,64位的要比32位的更精准
func main() {
var num float64 = 123.456789
num2 := 123.456789 // 自动推导方式定义变量默认是float64类型
fmt.Printf("%f\n", num) //123.456789
fmt.Printf("%.2f\n", num) // 使用".数字"可以保留小数位数并四舍五入 123.46
fmt.Printf("%T", num2)
}
布尔类型:
- 布尔类型也叫bool类型,布尔类型的取值要么是true,要么是false
- bool适合做逻辑运算,一般用在流程控制语句里
- 使用
bool
关键字进行定义,默认值为false
func main() {
var result bool
fmt.Println(result) // false
result = true //修改默认值
fmt.Printf("%t", result) //true
}
字符类型:
字符就是用’单引号’括起来的数据,在Go中没有char类型,如果要存储单个字符,一般使用byte保存。
- 字符可以使用Go转义字符修饰数据
- 如果需要保存的变量值大于255时使用byte会溢出,可以使用int代替byte保存数据
- Go语言的字符使用的是UTF-8编码标识Unicode文本,所以Go统一使用了UTF-8没有乱码的问题出现
- 字符的本质也是一个整数,直接输出的时候是按照对应的UTF-8编码的码值运算的,所以字符可以参与运算。
- 字符变量赋值后,通过
%c
可以打印出该数字对应的unicode字符
点击查看ASCLL码表
演示:
func main() {
var b byte = 'a'
var b byte = '我' // 报错,一个汉字占用3个字节,数据溢出
fmt.Println("b=", b) // Println打印结果不是a,是97,a=97是ASCLL码表对应值
fmt.Printf("%c\n", b) // 使用%c可以打印出具体存储的字符
var a int = 'b' // 也可以使用int类型定义
fmt.Println("a=", a) // 98
fmt.Printf("%c\n", a)
}
字符串类型:
- "双引号"内的数据称为字符串,本质是一串固定长度字符连接起来的字符序列,但是在Golang里是由单个字节(byte)连接起来的
- 字符串中有一个隐藏的结束标志
\0
, \0是字符串的结束符,任何字符串末尾都会自动加上\0
- 字符串一旦赋值就不能修改了,字符串是不可变的
- 字符可以使用Go转义字符修饰数据
- 反引号以字符串的原生形式输出,在反引号里的内容全部都是普通文本,包括换行和特殊字符,可以实现防止攻击、输入源代码的效果
func main() {
var name string = "itzhuzhu哈哈嘿嘿"
fmt.Printf("%T\n", name) // 打印字符串的数据类型
fmt.Println("name=", name) // 打印字符串的数据值
fmt.Println("长度为:", len(name)) // 输出为20,len:打印字符串的长度,长度不包含隐藏的\0,把所有的数据转换为字节,如果字符是中文,一个中文是3个字节
fmt.Println(utf8.RuneCountInString(name)) // 12 打印的是Unicode码(万国码),中文/英文都算一个字节
// 使用反引号会原样输出,编译器不会解析原始字符串内的数据
str := `
func save() {
var age int = 10
var a int = 1
var b int = a
var name string
fmt.Println(age)
fmt.Println(name)
fmt.Println(a, b)
}
`
str2 := "嘻嘻"
str += "可以再次拼接字符串,也可以和其它字符串变量一起拼接" + str2
fmt.Println("str=", str)
}
在golang中做字符串拼接的时候如果需要换行,需要把加号放在上一行,否则会报错
允许以索引号访问字节数组(并非字符),但不能获取数组元素地址
func main() {
s := "abc"
println(s[1])
println(&s[1]) // 错误: cannot take the address of s[1]
}
使用for遍历字符串时,分byte和rune两种方式
func main() {
s := "itzhuzhu"
for i := 0; i < len(s); i++ { // byte,返回的是ASCLL码
fmt.Printf("%d: [%c]\n", i, s[i])
}
fmt.Println("-------------------")
for i, c := range s { // rune,返回数组索引号,以及Unicode字符
fmt.Printf("%d: [%c]\n", i, c)
}
}
值类型:
- Go的值类型有:int、string、bool、array、struct,内存在栈中分配
- 值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到原内容数据。默认情况下,Go语言使用的是值传递,即在调用过程中不会影响到原数据。每次调用函数,都将实参复制一份再传递到函数中。每次都复制一份,性能会下降,但是Go 语言中使用指针和值传递配合就避免了性能降低问题,也就是通过传指针参数来解决实参复制的问题。
func main() {
i := "itzhuzhu"
j := i
fmt.Printf("i的内存地址:%p i的值:%v\n", &i, i)
fmt.Printf("j的内存地址:%p j的值:%v\n", &j, j)
}
输出:
i的内存地址:0x1400010a020 i的值:itzhuzhu
j的内存地址:0x1400010a030 j的值:itzhuzhu
引用类型:
- Go的引用类型有:指针、slice、map、interface、channel、func,内存通常再堆中分配
- 引用传递是指在调用函数时将实际参数的地址传递到函数中,那么在函数中对参数所进行的修改,将影响到原内容数据。函数参数使用指针参数,传参的时候其实是复制一份指针参数,也就是复制了一份变量地址。函数的参数如果是指针,当函数调用时,虽然参数仍然是按复制传递的,但是此时仅仅只是复制一个指针,也就是一个内存地址,这样就不用担心实参复制造成的内存浪费、时间开销、性能降低。
func main() {
i := "itzhuzhu"
// j是指针,存的是i的内存地址,i的内存地址里又存了itzhuzhu这个数据
j := &i
z:=j
fmt.Printf("i的内存地址:%p i的值:%v\n", &i, i)
fmt.Printf("j的内存地址:%p j的值:%v\n", &j, j)
fmt.Printf("z的内存地址:%p z的值:%v\n", &z, z)
}
输出:
i的内存地址:0x1400008e040 i的值:itzhuzhu
j的内存地址:0x140000ae018 j的值:0x1400008e040
z的内存地址:0x140000ae020 z的值:0x1400008e040
类型别名:
类型别名相当于给数据类型起了个外号,下面两种格式都可以用
Go1.9版本前定义格式
type 类型别名 类型
Go1.9版本后定义格式
type 类型别名 = 类型