每一种数据都定义了明确的数据类型,在内存中分配了不同大小的内存空间
数据类型
基本数据类型
-
数值型
-
整数类型
- int
- int8
- int16
- int32
- int64
- uint
- uint8
- uint16
- uint32
- uint64
- byte
-
浮点类型
- float32
- float64
-
-
字符型( 没有专门的字符型, 使用byte来保存单个字母字符 )
-
字符串 ( string )
-
布尔型( bool )
派生/复杂数据类型
- 指针( Pointer )
- 数组
- 结构体 ( struct )
- 管道 ( channel )
- 函数
- 切片 ( slice )
- 接口 ( interface )
- map
整数类型
| 类型 | 有无符号 | 占用存储空间 | 表数范围 | 备注 |
|---|---|---|---|---|
| int8 | 有 | 1B | -128~127 | |
| int16 | 有 | 2B | -215~215-1 | |
| int32 | 有 | 4B | -231~231-1 | |
| int64 | 有 | 8B | -263~263-1 | |
| uint8 | 无 | 1B | 0~255 | |
| uint16 | 无 | 2B | 0~2^16-1 | |
| uint32 | 无 | 4B | 0~2^32-1 | |
| uint64 | 无 | 8B | 0~2^64-1 | |
| int | 有 | 32位系统4B 64位系统8B | -231~231-1 -263~263-1 | |
| uint | 无 | 32位系统4B 64位系统8B | 0~2^32-1 0~2^64-1 | |
| rune | 有 | 与int32等价 | -231~231-1 | 等价int32,表示一个unicode码 |
| byte | 无 | 与uint8等价 | 0~255 | 当要存储字符时选用byte |
整型的使用细节
- golang各整数类型: 有符号和无符号, int uint 的大小和系统有关
- golang的整型默认声明为int型
package main
import "fmt"
func main() {
var n1 = 100
fmt.Printf("n1 的类型 %T", n1)
}
- 查看变量的字节大小和数据类型
package main
import (
"fmt"
"unsafe"
)
func main() {
var n1 int64 = 10
fmt.Printf("n1 的类型 %T n1占用的字节数是 %d", n1, unsafe.Sizeof(n1))
}
- golang程序中整型变量在使用时,遵守保小不保大的原则,即: 在保证程序正确运行下,尽量使用占用空间小的数据类型
package main
import (
"fmt"
"unsafe"
)
func main() {
var age byte = 90
fmt.Printf("age 的类型 %T age占用的字节数是 %d", age, unsafe.Sizeof(age))
}
- bit: 计算机中的最小存储单位 byte: 计算机中基本存储单元 1byte = 8bit
小数类型/浮点型
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| 单精度float32 | 4B | -3.403E38~3.403E38 |
| 双精度float64 | 8B | -1.798E308~1.798E308 |
- 浮点数=符号位+指数位+尾数位
package main
import "fmt"
func main() {
var price float32 = 89.12
fmt.Println("price=", price)
var num1 float32 = -0.00089
var num2 float32 = -7809656.09
fmt.Println("num1=", num1, "num2=", num2)
}
执行结果
price= 89.12
num1= -0.00089 num2= -7.809656e+06
- 尾数部分可能丢失,造成精度损失
var num3 float32 = -123.0000901
var num4 float64 = -123.0000901
fmt.Println("num3=", num3, "num4=", num4)
执行结果
num3= -123.00009 num4= -123.0000901
说明: float64的精度比float32的要准确
说明: 要保存一个精度高的数,应该选float64
浮点型使用细节
- golang浮点类型有固定的范围和字段长度,不受具体OS(操作系统)的影响
- golang的浮点型默认声明为float64类型
var num5 = 1.1
fmt.Printf("num5的数据类型是 %T \n", num5)
运行结果
num5的数据类型是 float64
- 浮点型常量两种表示形式
- 十进制: 5.12
- 科学计数法: 5.1234e2 = 5.12 * 10^2
num6 := 5.12
num7 := 0.123
fmt.Println("num6=", num6, "num7=", num7)
num8 := 5.1234e2
num9 := 5.1234E2
num10 := 5.1234E-2
fmt.Println("num8=", num8, "num9=", num9, "num10=", num10)
字符类型
golang中没有专门的字符类型,如果要存储单个字符(字母),一般使用byte来保存
字符串就是一串固定长度的字符连接起来的字符序列. go的字符串是由单个字节连接起来的.也就是说对于传统的字符串是由字符组成的,而go的字符串不同,它是由字节组成的
package main
import "fmt"
func main() {
var c1 byte = 'a'
var c2 byte = '0'
//输出对应的ASCII码值
fmt.Println("c1=", c1)
fmt.Println("c2=", c2)
//输出字符,需要使用格式化输出
fmt.Printf("c1=%c c2=%c\n", c1, c2)
var c3 int = '北'
fmt.Printf("c3=%c c3对应的码值=%d", c3, c3)
}
运行结果
c1= 97
c2= 48
c1=a c2=0
c3=北 c3对应的码值=21271
说明:
- 如果字符在ASCII表,可以保存到byte
- 如果字符对应码值大于255,使用int类型保存
- 如果需要输出字符,需要格式化输出 fmt.Printf("%c", c1)
字符类型使用细节
-
字符常量是永单引号括起来的单个字符 ‘a’ ‘中’
-
go中允许使用转义字符 \ 来将其后的字符变为特殊字符型常量, ‘\n’
-
go语言的字符使用UTF-8编码
http://www.mytju.com/classcode/tools/encode_utf8.asp
字母-1B
汉字- 3B -
在go中,字符的本质是一个整数,直接输出时,时该字符对应的UTF-8编码值
-
可以给变量赋值一个数字,然后按格式化输出时 %c,会输出该数字对应的Unicode字符
var c4 int = 22269
fmt.Printf("c4=%c\n", c4)
运行结果
c4=国
- 字符类型时可以进行运算的,相当于一个整数,因为它都有对应的Unicode码
var n1 = 10 + 'a'
fmt.Println("n1=", n1)
运行结果
n1= 107
字符类型本质
- 字符型 存储到计算机中,需要将字符对应的码值(整数)找出来
- 存储: 字符—>对应码值---->二进制—>存储
- 读取: 二进制—>码值—>字符—>读取
- 字符和码值的对应关系时通过字符编码表决定的(是规定好的)
- go语言的编码都统一成了utf-8.
布尔类型
- 布尔类型(bool类型),bool类型的值只有true和false
- bool类型占1B
- bool类型用于逻辑运算,流程控制中使用
package main
import (
"fmt"
"unsafe"
)
func main() {
var b = false
fmt.Println("b=",b)
fmt.Println("b的占用空间=", unsafe.Sizeof(b))
}
运行结果
b= false
b的占用空间= 1
string类型
字符串就是一串固定长度的字符连接起来的字符序列. go的字符串是由单个字节连接起来的.go语言的字符串的字节使用UTF-8编码标识Unicode文本
var address string = "北京昌平 110 hello world!"
fmt.Println(address)
执行结果
北京昌平 110 hello world!
string使用注意事项
- go语言的字符串的字节统一使用UTF-8编码标识Unicode文本
- 字符串一旦赋值了,就不能修改了:在go中字符串是不可变的
- 字符串的两种形式
- 双引号 : 会识别转义字符
- 反引号: 以字符串的原生形式输出,包括换行和特殊字符
func main() {
fmt.Println("a\nb")
fmt.Println(`a\nb`)
}
运行结果
a
b
a\nb
- 字符串拼接
var str = "hello " + "world"
str += " haha!"
fmt.Println(str)
运行结果
hello world haha!
- 当一行字符串太长时,需要使用到多行字符串
//注意,需要将+保留在上一行
str4 := "hello " + "world" + "hello " + "world" + "hello " +
"world" + "hello " + "world" + "hello " + "world" +
"hello " + "world"
fmt.Println(str4)
基本数据类型的默认值
在go中,数据类型都有一个默认值,当程序员没有赋值时,就会保留默认值,在go中,默认值又叫零值
| 数据类型 | 默认值 |
|---|---|
| 整形 | 0 |
| 浮点型 | 0 |
| 字符串 | “” |
| 布尔类型 | false |
func main() {
var a int
var b float32
var c float64
var isMarried bool
var name string
fmt.Printf("a=%d,b=%v,c=%v,isMarried=%v name=%v", a, b, c, isMarried, name)
}
运行结果
a=0,b=0,c=0,isMarried=false name=
常量
- 常量使用const定义
- 常量在定义时候必须初始化
- 常量不能修改
- 常量只能修饰bool, 数值类型（int, float系列）, string类型
语法
const identifier [type] = value
常量注意事项
- 写法1
const (
a = 1
b = 2
)
- 写法2
const (
a = iota
b
c
)
说明： 表示给 a赋值为0
b在a的基础上 +1
c在b的基础上 +1
这种写法比较专业
注意：
const iota = 0 // 无类型整数值
iota是一个预定义的标识符，代表顺序按行增加的无符号整数，每个const声明单元（被括号括起来）相互独立，分别从0开始
package main
import "fmt"
func main() {
const (
a = iota
b
c
d
)
fmt.Println(a, b, c, d)
}
package main
import "fmt"
func main() {
const (
a = iota
b = iota
c = iota
d = iota
)
fmt.Println(a, b, c, d)
}
运行结果：
0 1 2 3
package main
import "fmt"
func main() {
const (
a = iota
b = iota
c, d = iota, iota
)
fmt.Println(a, b, c, d)
}
运行结果：
0 1 2 2
- golang中 没有常量名必须字母大写的规范
- 仍然通过首字母的大小写来控制常量的访问范围
727
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
