目录
- 1. Golang数据类型分类
- 2. 数据类型的默认值
- 3. 数据类型及大小
- 4. 数据类型介绍
- 5. 基本数据类型的转换
- 6 基本数据类型和string转换
- 7 指针
- 8 标识符
- 9 系统保留关键字
- 10 预定义标识符
1. Golang数据类型分类
![](/i/l/?n=22&i=blog/2707935/202210/2707935-20221023225027215-618075375.png)
2. 数据类型的默认值
如果定义变量时候不初始化数据,各种类型都会有默认值,比如整形为0,字符串为空字符串,布尔类型为false等等
var v1 int // 整型
var v2 string // 字符串
var v3 bool // 布尔型
var v4 [10]int // 数组,类型为整型
var v5 struct { // 结构体
v float32
}
var v6 *int // 指针,指向整型
var v7 map[string]int // map key为字符串,value为整型
var v8 func(a int) int // 函数
打印结果:
v1: 0
v2:
v3: false
v4: [0 0 0 0 0 0 0 0 0 0]
v5: {0}
v6: <nil>
v7: map[]
v8: <nil>
3. 数据类型及大小
3.1 查看变量的数据类型
使用%T
打印出变量的数据类型
var i int = 10
// fmt.Printf() 可用于格式化输出
fmt.Printf("i数据类型:%T \n" , i)
打印结果:
i数据类型:int
3.2 查看变量占用字节大小
var i int = 10
// unsafe用于返回变量占用的字节数
fmt.Printf("i占用字节大小:%d \n", unsafe.Sizeof(i))}
打印结果:
i占用字节大小:8
4. 数据类型介绍
4.1 整数类型
整数类型,简单来说,就是用于存放整数值的类型,也可以简称为整型。每门编程语言都有对应的数据类型。
4.1.1 整型各个类型对比
有符号整型对比:
类型 | 有无符号 | 占用存储空间 | 范围 | 备注 |
---|---|---|---|---|
int8 | 有 | 1字节 | -128 ~ 127 | |
int16 | 有 | 2字节 | \(-2^1\)\(^5\) ~ \(2^1\)\(^5\)-1 | |
int32 | 有 | 4字节 | \(-2^3\)\(^1\) ~ \(2^3\)\(^1\)-1 | |
int64 | 有 | 8字节 | \(-2^6\)\(^3\) ~ \(2^6\)\(^3\)-1 |
无符号整型对比:
类型 | 有无符号 | 占用存储空间 | 范围 | 备注 |
---|---|---|---|---|
uint8 | 无 | 1字节 | 0 ~ 255 | |
uint16 | 无 | 2字节 | 0 ~ \(2^1\)\(^6\)-1 | |
uint32 | 无 | 4字节 | 0 ~ \(2^3\)\(^2\)-1 | |
uint64 | 无 | 8字节 | 0 ~ \(2^6\)\(^4\)-1 |
整型的类型:
类型 | 有无符号 | 占用存储空间 | 表数范围 | 备注 |
---|---|---|---|---|
int | 有 | 32位操作系统4个字节,64位操作系统8个字节 | \(-2^3\)\(^1\) ~ \(2^3\)\(^1\)-1 或 \(-2^6\)\(^3\) ~ \(2^6\)\(^3\)-1 | |
uint | 无 | 32位操作系统4个字节,64位操作系统8个字节 | 0 ~ \(2^3\)\(^2\)-1 或 0 ~ \(2^6\)\(^4\)-1 | |
rune | 有 | 与int32一样,4个字节 | \(-2^3\)\(^1\) ~ \(2^3\)\(^1\)-1 | 等价于int32,表示一个Unicode码 |
byte | 无 | 与uint8一样,1个字节 | 0 ~ 255 | 当要存储字符时选用byte |
4.1.2 整型的使用细节
-
Golang各整数类型分为:有符号和无符号,int和uint的大小和系统有关;
-
Golang的整型默认声明为int型;
-
如何在程序查看某个变量的字节大小和数据类型;
-
Golang程序中整型变量在使用时,遵守保小不保大的原则,即:在保证程序正确运行下,尽量使用占用空间小的数据类型;
-
bit:计算机中的最小存储单位,byte:计算机中基本存储单元;
4.2 浮点类型
Golang的浮点型可以表示一个小数,比如:123.5...
4.2.1 浮点类型分类
类型 | 占用存储空间 | 表数范围 |
---|---|---|
单精度float32 | 4字节 | -3.403E38 ~ 3.403E38 |
双精度float64 | 8字节 | -1.798E308 ~ 1.798E308 |
4.2.1 浮点类型分类说明
-
关于浮点数在机器中存放形式的简单说明:浮点数=符号位+指数位+尾数位;
-
尾数部分可能丢失,造成精度损失;
-
浮点型存储分为三部分:符号位+指数位+尾数位 在存储过程中,精度会有损失;
4.2.2 浮点类型使用细节
-
Golang浮点型有固定的范围和字段长度,不受具体系统的影响;
-
Golang的浮点型默认声明为float64类型;
-
浮点型常量有两种表示形式
- 十进制数形式:5.12 或 0.512(0可以省略但是小数点必须有)
- 科学计数法形式:5.1234e2 = 5.12 * \(10^2\) 或 5.12E-2 = 5.12 / \(10^2\)
-
通常情况下,应该使用float64,比float32更精确;
4.3 字符类型
Golang中没有专门的字符类型,如果要单独存储单个字符(字母),一般使用byte来存储。
字符串就是一串固定长度的字符连接起来的字符序列,Golang的字符串是由单个字节连接起来的,也就是说对于传统的字符串是由字符组成的,而Golang的字符串不同,它是由字节组成的。
4.3.1 字符类型案例
package main
import (
"fmt"
)
func main() {
var chr1 byte = 'a'
var chr2 byte = '0' // 字符类型的0
fmt.Println("chr1=", chr1)
fmt.Println("chr2=", chr2)
}
打印结果:
chr1= 97
chr2= 48
看到以上的结果,我们可以观察到,当我们直接输出byte值,就是输出了对应字符的码值,详细可以参照ASCII码对照表。
如果想要输出对应字符怎么办?那就需要使用格式化输出方式
fmt.Printf("chr1=%c\n", chr1)
fmt.Printf("chr2=%c\n", chr2)
打印结果:
chr1=a
chr2=0
这时我们对字符类型的使用和格式化输出有一定的了解了,但是我们存储的都是英文、数字或符号。如果我们存储一些中文会发生什么呢?
var chr3 byte = '北'
fmt.Printf("chr3=%c\n", chr3)
打印结果:
# command-line-arguments
GoProject/project03/demon09/main.go:8:18: cannot use '北' (untyped rune constant 21271) as byte value in variable declaration (overflows)
可以明显的看到,显示溢出了,所以在存储中文时,就需要使用较大的类型。
var chr3 int = '北'
fmt.Printf("chr3=%c\n", chr3)
打印结果:
chr3=北
4.3.2 字符类型使用细节
-
字符常量是用单引号
('')
括起来的单个字符。例如:var c1 byte = 'a'
; -
Golang中允许使用转义字符
\
来将其后的字符转变为特殊字符型常量。例如:var c2 char = '\n'
; -
Golang语言的字符使用UTF-8编码;
-
在Golang中,字符的本质是一个整数,直接输出时,是该字符对应的UTF-8编码的码值;
-
可以直接给某个变量赋一个数字,按格式化输出时
%c
,会输出该数字对应的Unicode字符; -
字符类型是可以进行运算的,相当于一个整数,因为它都对应有Unicode码;
![](/i/l/?n=22&i=blog/2707935/202210/2707935-20221025232645615-1526379794.png)
4.3.3 字符类型本质探讨
-
字符型存储到计算机中,需要将字符对应的码值(整数)找出来;
-
存储:字符--->对应码值---->二进制-->存储
-
读取:二进制----> 码值 ----> 字符 --> 读取
-
-
字符和码值的对应关系是通过字符编码表决定的(是规定好);
-
Golang语言的编码都统一成了 utf-8;
4.4 布尔类型
-
布尔类型也叫Bool类型,Bool类型只允许取值
True
和Fasle
; -
Bool类型占1字节;
-
Boolean类型适用于逻辑运算,一般用于程序流程控制;
-
if条件控制语句
-
for循环控制语句
-
4.5 字符串类型
字符串就是一串固定长度的字符连接起来的字符序列。Golang的字符串是由单个字节连接起来的。Golang语言的字符串的字节使用UTF-8编码标识Unicode文本。
4.5.1 字符串类型案例
定义一个字符串并进行打印
var address string = "Beijing Langfeng"
fmt.Println(address)
打印结果:
Beijing Langfeng
4.5.2 字符串类型使用细节
-
Golang语言的字符串的字节使用UTF-8编码标识Unicode文本,这样Golang统一使用UTF-8编码;
-
字符串一旦赋值,字符串就不能修改,在Golang中字符串是不可变的;
var str1 string = "hello"
fmt.Println(str1)
str1[0] = 'n'
fmt.Println(str1)
打印结果:
GoProject/project03/demon10/main.go:11:2: cannot assign to str1[0] (value of type byte)
- 字符串的两种表示形式:双引号,会识别转义字符。反引号,以字符串的原生形式输出,包括换行和特殊字符,可以防止攻击、输出源代码等。
var str1 string = `package main
import "fmt"
func main() {
fmt.Println("hello,world!")
}`
fmt.Println(str1)
打印结果:
package main
import "fmt"
func main() {
fmt.Println("hello,world!")
}
- 字符串拼接;
var str1 string = "Hello" + " World"
str1 += "!"
fmt.Println(str1)
打印结果:
Hello World!
- 当一行字符串太长时,可以进行换行操作;
var str1 string = "Hello" + " World" +
" Hello" + " World" +
" Hello" + " World"
fmt.Println(str1)
5. 基本数据类型的转换
Golang和Java/C不同,Golang在不同类型的变量之间赋值时需要显式转换,也就说Golang中数据类型不能自动转换。
5.1 基本语法
表达式T(v)将值v转换为类型T
T:数据类型,比如:int32、int64、float32等;
v:需要转换的变量
5.2 基本数据路类型转换案例
package main
import (
"fmt"
)
func main() {
var i int32 = 100
// 将 int32 ==> float32
var n1 float32 = float32(i)
// 将 int32 ==> in8
var n2 int8 = int8(i)
// 将 int32 ==> int64
var n3 int64 = int64(i)
fmt.Printf("i= %v, n1=%v, n2=%v, n3=%v", i, n1, n2, n3)
}
5.3 基本数据类型转换细节
-
Golang中,数据类型的转换可以是从表示范围小-->表示范围大,也是从表示范围大-->表示范围小;
-
被转换的是变量存储的数据(即值),变量本身的数据类型没有变化;
-
在转换中,比如int64转换int8,编译时不会报错,只是转换的结果按溢出处理,和我们希望的结果不一致;
6 基本数据类型和string转换
在程序开发中,我们经常需要将基本数据类型转成string类型,或者将string类型转成基本数据类型。
6.1 基本数据类型转换string类型语法
方式一:
// fmt.Sprintf("%参数", 表达式)
package main
import (
"fmt"
)
func main() {
var n1 int = 99
var n2 float64 = 99.99
var n3 bool = true
var n4 byte = 'c'
var str string
str = fmt.Sprintf("%d", n1) // 整数转换
fmt.Printf("str type %T, str=%q\n", str, str)
str = fmt.Sprintf("%f", n2) // 浮点数转换
fmt.Printf("str type %T, str=%q\n", str, str)
str = fmt.Sprintf("%t", n3) // 布尔类型转换
fmt.Printf("str type %T, str=%q\n", str, str)
str = fmt.Sprintf("%c", n4) // 字节转换
fmt.Printf("str type %T, str=%q\n", str, str)
}
-
参数需要和表达式的数据相匹配;
-
fmt.Sprintf()
会返回转换后的字符串; -
百分号都有哪些参数,可参考Go语言标准库;
方式二:
使用strconv
包的函数
package main
import (
"fmt"
"strconv"
)
func main() {
var n1 int = 99
var n2 float64 = 99.99
var n3 bool = false
var str string
str = strconv.Itoa(n1) // 整数转换
fmt.Printf("str type %T, str=%q\n", str, str)
str = strconv.FormatInt(int64(n1), 10) // 整数转换
fmt.Printf("str type %T, str=%q\n", str, str)
// 说明:'f':表示格式,;10:表示小数位保留10位;64:表示这个小数是float64
str = strconv.FormatFloat(n2, 'f', 10, 64) // 浮点数转换
fmt.Printf("str type %T, str=%q\n ", str, str)
str = strconv.FormatBool(n3) // 布尔类型转换
fmt.Printf("str type %T, str=%q\n ", str, str)
}
6.2 string类型转基本数据类型语法
使用strconv
包的函数
package main
import (
"fmt"
"strconv"
)
func main() {
var s1 string = "true"
var s2 string = "99"
var s3 string = "99.99"
// 转换至布尔类型
var b bool
b, _ = strconv.ParseBool(s1)
fmt.Printf("str type %T, str=%v\n", b, b)
// 转换至整数类型
var n1 int64
n1, _ = strconv.ParseInt(s2, 10, 64)
fmt.Printf("str type %T, str=%v\n", n1, n1)
// 转换至小数类型
var n2 float64
n2, _ = strconv.ParseFloat(s3, 64)
fmt.Printf("str type %T, str=%v\n", n2, n2)
}
6.2.1 string类型转基本数据类型的注意事项
在将string类型转成基本数据类型时,要确保string类型能够转成有效的数据。比如,我们可以把‘123’,转成整数,但不能把‘hello’转成一个整数,如果这样做,Golang直接将其转换为默认值。
7 指针
7.1 指针基本介绍
- 基本数据类型,变量存的就是值,也叫值类型;
- 获取变量的地址,用
&
;
var num int = 10
fmt.Println("num的地址=", &num)
- 指针类型,变量存的是一个地址,这个地址指向的空间存的才是值。
var num int = 10
fmt.Println("num的地址=", &num)
var ptr *int = &num
fmt.Printf("ptr=%v\n", ptr)
fmt.Println("ptr的地址=", &ptr)
- 获取指针类型所指向的值,使用
*
;
var num int = 10
fmt.Printf("num 的地址=%v\n", &num)
var ptr *int = &num
fmt.Printf("ptr 的值=%v\n", ptr)
fmt.Printf("ptr 的地址=%v\n", &ptr)
fmt.Printf("ptr 指向的值=%v\n", *ptr)
7.2 指针细节说明
-
值类型,都有对应的指针类型,形式为
*数据类型
,比如int的对应指针类型就是int,float32对应的指针类型就是float32,以此类推; -
值类型包括:基本数据类型int系列、float系列、bool、string、数组和结构体struct;
7.3 值类型和引用类型
7.3.1 值类型和引用类型说明
-
值类型:基本数据类型int系列,float系列、bool、string、数组和结构体struct;
-
引用类型:指针、slice切片、map、管道chan、interface等都是引用类型;
7.3.2 值类型和引用类型使用特点
-
值类型:变量直接存储值,内存通常在栈中分配;
-
引用类型:变量存储的是一个地址,这个地址对应的空间才是真正存储数据(值),内存通常在堆上分配,当没有任何变量引用这个地址时,该地址对应的数据空间就成为一个垃圾,由GC来回收;
8 标识符
8.1 标识符概念
-
Golang对各种变量、方法等命名时使用的字符序列称为标识符;
-
凡是自己可以起名字的地方都叫标识符;
8.2 标识符的命名规则
-
由26个英文字母大小写,0-9,_组成;
-
数字不可以开头;
-
Golang中严格区分大小写;
-
标识符不能包含空格;
-
下划线"_"本身在Golang中是一个特殊标识符,成为“空标识符”。可以代表任何其他的标识符,但是它对应的值会被忽略。所以仅能被作为占位符使用,不能作为标识符使用;
-
不能以系统保留关键字作为标识符;
8.3 标识符命名注意事项
-
包名:保持package的名字和目录保持一致,尽量采取有意义的包名,简短、有意义、不要和标准库冲突;
-
变量名、函数名、常量名,采用驼峰法;
-
如果变量名、函数名、常量名首字母大写,则可以被其他的包访问。如果首字母小写,则只能在本包中使用;(注:大写共有,小写私有)
9 系统保留关键字
在Golang中,为了简化代码编译过程中对代码的解析,其定义的保留关键字只有25个。详见如下。
10 预定义标识符
除了保留关键字外,Golang还提供了36个预定的标识符,其包括基础数据类型和系统内嵌函数。