Golang通脉之数据类型详情
作者:羌 时间:2023-07-14 05:37:03
1、标识符与关键字
在了解数据类型之前,先了解一下go的标识符和关键字
1.1 标识符
在编程语言中标识符就是定义的具有某种意义的词,比如变量名、常量名、函数名等等。 Go语言中标识符允许由字母数字和_(下划线)组成,并且只能以字母和_开头:abc
, _
, _123
, a123
。
1.2 关键字
关键字是指语言预先定义好的具有特殊含义的标识符。 关键字和保留字都不建议用作变量名。
Go语言有25个关键字:
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
Go语言中有37个保留字
Constants: true false iota nil
Types: int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
Functions: make len cap new append copy close delete
complex real imag
panic recover
2、变量
2.1 什么是变量
程序运行过程中的数据都是保存在内存中,想要在代码中操作某个数据时就需要去内存上找到这个变量,但是如果直接在代码中通过内存地址去操作变量的话,代码的可读性会非常差而且还容易出错,所以就利用变量将这个数据的内存地址保存起来,以后直接通过这个变量就能找到内存上对应的数据了。
所以变量的本质就是一小块内存,用于存储数据,在程序运行过程中数值可以改变
变量是为存储特定类型的值而提供给内存位置的名称。在go中声明变量有多种语法。
2.2 变量类型
变量(Variable
)的功能是存储数据。不同的变量保存的数据类型可能会不一样。常见变量的数据类型有:整型、浮点型、布尔型等。
Go语言中的每一个变量都有自己的类型,并且变量必须经过声明才能开始使用。
2.3 变量声明
Go语言中的变量需要声明后才能使用,同一作用域内不支持重复声明。 并且Go语言的变量声明后必须使用,否则无法通过编译。
标准声明:
Go语言的变量声明格式为:
var 变量名 变量类型
变量声明以关键字var开头,变量类型放在变量的后面,行尾无需分号:
var name string
var age int
var isTrue bool
批量声明:
每声明一个变量就需要写var
关键字会比较繁琐,go
语言中还支持批量变量声明:
var (
a string
b int
c bool
d float32
)
变量的初始化:
Go语言在声明变量的时候,会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值,即零值,例如: 整型和浮点型变量的默认值为0。 字符串变量的默认值为空字符串。 布尔型变量默认为false
。 切片、函数、指针变量的默认为nil
。
当然也可在声明变量的时候为其指定初始值。变量初始化的标准格式如下:
var 变量名 类型 = 表达式
var name string = "golang"
var age int = 18
或者一次初始化多个变量
var name, age = "golang", 20
类型推导:
有时候会将变量的类型省略,这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。
var name = "golang"
var age = 18
短变量声明:
在函数内部,可以使用更简略的 :=
方式声明并初始化变量。
// 全局变量m
var m = 100
func main() {
n := 10
m := 200 // 此处声明局部变量m
fmt.Println(m, n)
}
匿名变量:
在使用多重赋值时,如果想要忽略某个值,可以使用匿名变量(anonymous variable
)。 匿名变量用一个下划线_表示,例如:
func foo() (int, string) {
return 10, "golang"
}
func main() {
x, _ := foo()
_, y := foo()
fmt.Println("x=", x)
fmt.Println("y=", y)
}
匿名变量不占用命名空间,不会分配内存,所以匿名变量之间不存在重复声明。
注意事项:
函数外的每个语句都必须以关键字开始(
var
、const
、func
等):=
不能使用在函数外,不能定义全局变量,并且左边的变量名至少有一个是新的。_多用于占位,表示忽略值。
变量必须先定义才能使用,定义了就一定要使用。
变量的类型和赋值的类型必须一致。
变量名在同一个作用于域内不能冲突。
3、常量
相对于变量,常量是恒定不变的值,多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似,只是把var换成了const
,常量在定义的时候必须赋值。
const pi = 3.1415
const e = 2.7182
声明了pi
和e
这两个常量之后,在整个程序运行期间它们的值都不能再发生变化了。
多个常量也可以一起声明:
const (
pi = 3.1415
e = 2.7182
)
const
同时声明多个常量时,如果省略了值则表示和上面一行的值相同。 例如:
const (
n1 = 100
n2
n3
)
上面示例中,常量n1
、n2
、n3
的值都是100。
常量可以作为枚举,常量组
const (
Unknown = 0
Female = 1
Male = 2
)
常量组中如不指定类型和初始化值,则与上一行非空常量右值相同
func main() {
const (
x uint16 = 16
y
s = "abc"
z
)
fmt.Printf("%T,%v\n", y, y) //uint16,16
fmt.Printf("%T,%v\n", z, z) //string,abc
}
常量的注意事项:
常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型
不曾使用的常量,在编译的时候,是不会报错的
显示指定类型的时候,必须确保常量左右值类型一致,需要时可做显示类型转换。这与变量就不一样了,变量是可以是不同的类型值
3.1 iota
iota
是go语言的常量计数器,是特殊的常量,只能在常量的表达式中使用。
iota在const
关键字出现时将被重置为0
。const
中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义,在定义枚举时很有用。
const (
n1 = iota //0
n2 //1
n3 //2
n4 //3
)
几个常见的iota示例:
使用_
跳过某些值
const (
n1 = iota //0
n2 //1
_
n4 //3
)
iota
声明中间插队
const (
n1 = iota //0
n2 = 100 //100
n3 = iota //2
n4 //3
)
const n5 = iota //0
定义数量级 (这里的<<
表示左移操作,1<<10
表示将1的二进制表示向左移10位,也就是由1变成了10000000000,也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位,也就是由10变成了1000,也就是十进制的8。)
const (
_ = iota
KB = 1 << (10 * iota)
MB = 1 << (10 * iota)
GB = 1 << (10 * iota)
TB = 1 << (10 * iota)
PB = 1 << (10 * iota)
)
多个iota
定义在一行
const (
a, b = iota + 1, iota + 2 //iota = 0、a = 1, b = 2
c, d //iota = 1、c = 2, d = 3
e, f //iota = 2、e = 3, f = 4
)
Go
语言中有丰富的数据类型,除了基本的整型、浮点型、布尔型、字符串外,还有数组、切片、结构体、函数、map
、通道(channel
)等。
4、基本数据类型
4.1 整型
整型分为以下两个大类: 按长度分为:int8
、int16
、int32
、int64
对应的无符号整型:uint8
、uint16
、uint32
、uint64
其中,uint8
就是byte
型,int16
对应C语言中的short型,int64对应C语言中的long型。
类型 | 描述 |
---|---|
uint8 | 无符号 8位整型 (0 到 255) |
uint16 | 无符号 16位整型 (0 到 65535) |
uint32 | 无符号 32位整型 (0 到 4294967295) |
uint64 | 无符号 64位整型 (0 到 18446744073709551615) |
int8 | 有符号 8位整型 (-128 到 127) |
int16 | 有符号 16位整型 (-32768 到 32767) |
int32 | 有符号 32位整型 (-2147483648 到 2147483647) |
int64 | 有符号 64位整型 (-9223372036854775808 到 9223372036854775807) |
特殊整型:
类型 | 描述 |
---|---|
uint | 32位操作系统上就是uint32,64位操作系统上就是uint64 |
int | 32位操作系统上就是int32,64位操作系统上就是int64 |
uintptr | 无符号整型,用于存放一个指针 |
注意: 在使用int和 uint类型时,不能假定它是32位或64位的整型,而是考虑int和uint可能在不同平台上的差异。除非需要使用特定大小的整数,否则通常应该使用int来表示整数。 大小:32位系统32位,64位系统64位。 范围:-2147483648到2147483647的32位系统和-9223372036854775808到9223372036854775807的64位系统。
注意事项 获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中,切片或 map 的元素数量等都可以用int来表示。在涉及到二进制传输、读写文件的结构描述时,为了保持文件的结构不会受到不同编译目标平台字节长度的影响,不要使用int和 uint。
数字字面量语法(Number literals syntax)
Go1.13版本之后引入了数字字面量语法,这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字,例如:
v := 0b00101101
, 代表二进制的 101101,相当于十进制的 45。 v := 0o377
,代表八进制的 377,相当于十进制的 255。 v := 0x1p-2,代表十六进制的 1 除以 2²,也就是 0.25。
而且还允许用 _ 来分隔数字,比如说: v := 123_456
表示 v 的值等于 123456
。
将一个整数以不同进制形式展示:
func main(){
// 十进制
var a int = 10
fmt.Printf("%d \n", a) // 10
fmt.Printf("%b \n", a) // 1010 占位符%b表示二进制
// 八进制 以0开头
var b int = 077
fmt.Printf("%o \n", b) // 77
// 十六进制 以0x开头
var c int = 0xff
fmt.Printf("%x \n", c) // ff
fmt.Printf("%X \n", c) // FF
}
4.2 浮点型
Go语言支持两种浮点型数:float32
和float64
。这两种浮点型数据格式遵循IEEE 754标准: float32
的浮点数的最大范围约为 3.4e38,可以使用常量定义:math.MaxFloat32
。 float64
的浮点数的最大范围约为 1.8e308
,可以使用一个常量定义:math.MaxFloat64
。
打印浮点数时,可以使用fmt包配合动词%f:
func main() {
fmt.Printf("%f\n", math.Pi)
fmt.Printf("%.2f\n", math.Pi)
}
4.3 复数
complex64
和complex128
var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)
复数有实部和虚部,complex64
的实部和虚部为32位,complex128
的实部和虚部为64位。
4.4 布尔值
Go语言中以bool
类型进行声明布尔型数据,布尔型数据只有true(真)
和false(假)
两个值。
注意:
布尔类型变量的默认值为
false
。不允许将整型强制转换为布尔型.
布尔型无法参与数值运算,也无法与其他类型进行转换。
4.5 字符串
Go语言中的字符串以原生数据类型出现,使用字符串就像使用其他原生数据类型(int、bool、float32、float64
等)一样。字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容,可以在源码中直接添加非ASCII码字符:
s1 := "hello"
s2 := "你好"
字符串转义符:
Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等,如下表所示。
转义符 | 含义 |
---|---|
\r | 回车符(返回行首) |
\n | 换行符(直接跳到下一行的同列位置) |
\t | 制表符 |
\' | 单引号 |
\" | 双引号 |
\\ | 反斜杠 |
打印一个Windows平台下的一个文件路径:
func main() {
fmt.Println("str := \"d:\\go\\go.exe\"")
}
多行字符串:
定义一个多行字符串时,就必须使用反引号
字符:
s1 := `第一行
第二行
第三行
`
fmt.Println(s1)
反引号间换行将被作为字符串中的换行,但是所有的转义字符均无效,文本将会原样输出。
字符串的常用操作:
介绍 | 方法 |
---|---|
求长度 | len(str) |
拼接字符串 | +或fmt.Sprintf |
分割 | strings.Split |
判断是否包含 | strings.contains |
前缀/后缀判断 | strings.HasPrefix,strings.HasSuffix |
子串出现的位置 | strings.Index(),strings.LastIndex() |
join操作 | strings.Join(a[]string, sep string) |
4.6 byte和rune类型
组成每个字符串的元素叫做“字符”,可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号(')包裹起来,如:
var a := '中'
var b := 'x'
Go 语言的字符有以下两种:
uint8类型,或者叫 byte 型,代表了ASCII码的一个字符。
rune类型,代表一个 UTF-8字符。
当需要处理中文、日文或者其他复合字符时,则需要用到rune
类型。rune
类型实际是一个int32。
Go 使用了特殊的 rune
类型来处理 Unicode
,让基于 Unicode
的文本处理更为方便,也可以使用 byte
型进行默认字符串处理,性能和扩展性都有照顾。
因为UTF8编码下一个中文汉字由3~4个字节组成,所以不能简单的按照字节去遍历一个包含中文的字符串
字符串底层是一个byte数组,所以可以和[]byte
类型相互转换。字符串是不能修改的 字符串是由byte字节组成,所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符,一个rune
字符由一个或多个byte组成。
修改字符串:
要修改字符串,需要先将其转换成[]rune
或[]byte
,完成后再转换为string
。无论哪种转换,都会重新分配内存,并复制字节数组。
func changeString() {
s1 := "big"
// 强制类型转换
byteS1 := []byte(s1)
byteS1[0] = 'p'
fmt.Println(string(byteS1))
s2 := "白萝卜"
runeS2 := []rune(s2)
runeS2[0] = '红'
fmt.Println(string(runeS2))
}
4.7 类型转换
Go语言中只有强制类型转换,没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。
强制类型转换的基本语法如下:
T(表达式)
其中,T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等.
func sqrtDemo() {
var a, b = 3, 4
var c int
// math.Sqrt()接收的参数是float64类型,需要强制转换
c = int(math.Sqrt(float64(a*a + b*b)))
fmt.Println(c)
}
运算符用于在程序运行时执行数学或逻辑运算。
5、运算符
Go 语言内置的运算符有:
算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
5.1 算数运算符
运算符 | 描述 |
---|---|
+ | 相加 |
- | 相减 |
* | 相乘 |
/ | 相除 |
% | 求余 |
注意: ++
(自增)和--(
自减)在Go语言中是单独的语句,并不是运算符。
5.2 关系运算符
运算符 | 描述 |
---|---|
== | 检查两个值是否相等,如果相等返回 True 否则返回 False。 |
!= | 检查两个值是否不相等,如果不相等返回 True 否则返回 False。 |
> | 检查左边值是否大于右边值,如果是返回 True 否则返回 False。 |
>= | 检查左边值是否大于等于右边值,如果是返回 True 否则返回 False。 |
< | 检查左边值是否小于右边值,如果是返回 True 否则返回 False。 |
<= | 检查左边值是否小于等于右边值,如果是返回 True 否则返回 False。 |
5.3 逻辑运算符
运算符 | 描述 |
---|---|
&& | 逻辑 AND 运算符。 如果两边的操作数都是 True,则为 True,否则为 False。 |
|| | 逻辑 OR 运算符。 如果两边的操作数有一个 True,则为 True,否则为 False。 |
! | 逻辑 NOT 运算符。 如果条件为 True,则为 False,否则为 True。 |
5.4 位运算符
位运算符对整数在内存中的二进制位进行操作。
运算符 | 描述 |
---|---|
& | 参与运算的两数各对应的二进位相与。 (两位均为1才为1) |
| | 参与运算的两数各对应的二进位相或。 (两位有一个为1就为1) |
^ | 参与运算的两数各对应的二进位相异或,当两对应的二进位相异时,结果为1。 (两位不一样则为1) |
&^ | 二进制位清空&^ |
<< | 左移n位就是乘以2的n次方。 “a<<b”是把a的各二进位全部左移b位,高位丢弃,低位补0。 |
>> | 右移n位就是除以2的n次方。 “a>>b”是把a的各二进位全部右移b位。 |
A | B | A&B | A|B | A^B |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
5.5 赋值运算符
运算符 | 描述 | 示例 |
---|---|---|
= | 简单的赋值操作符,分配值从右边的操作数左侧的操作数 | C = A + B 将分配A + B的值到C |
+= | 相加并赋值运算符,它增加了右操作数左操作数和分配结果左操作数 | C += A 相当于 C = C + A |
-= | 减和赋值运算符,它减去右操作数从左侧的操作数和分配结果左操作数 | C -= A 相当于 C = C - A |
*= | 乘法和赋值运算符,它乘以右边的操作数与左操作数和分配结果左操作数 | C *= A 相当于 C = C * A |
/= | 除法赋值运算符,它把左操作数与右操作数和分配结果左操作数 | C /= A 相当于 C = C / A |
%= | 模量和赋值运算符,它需要使用两个操作数的模量和分配结果左操作数 | C %= A 相当于 C = C % A |
<<= | 左移位并赋值运算符 | C <<= 2 相同于 C = C << 2 |
>>= | 向右移位并赋值运算符 | C >>= 2 相同于 C = C >> 2 |
&= | 按位与赋值运算符 | C &= 2 相同于 C = C & 2 |
^= | 按位异或并赋值运算符 | C ^= 2 相同于 C = C ^ 2 |
|= | 按位或并赋值运算符 | C |= 2 相同于 C = C | 2 |
5.6 运算符优先级
有些运算符拥有较高的优先级,二元运算符的运算方向均是从左至右。由上至下代表优先级由高到低:
优先级 | 运算符 |
---|---|
7 | ~ ! ++ -- |
6 | * / % << >> & &^ |
5 | + - ^ |
4 | == != < <= >= > |
3 | <- |
2 | && |
1 | || |
当然,可以通过使用括号来临时提升某个表达式的整体运算优先级。
来源:https://www.cnblogs.com/drunkery/p/15402180.html