Go基础
变量
Go变量使用方式和C语言接近,但具备更大的灵活性
变量声明
对于纯粹的变量声明,Go引入了var关键字,类型信息放在变量名之后,示例如下:
var v1 int
var v2 string
var v3 [10]int // 数组
var v4 []int // 数组切片
var v5 struct {
f int
}
var v6 *int // 指针
var v7 map[string]int // map, key为string类型,value为int类型
var v8 func(a int) int
为了避免重复写var,可以将若干个需要声明的变量放在一起,如下:
var (
v1 int
v2 string
)
变量初始化
初始化例子如下:
var v1 int = 10 // 用法1
var v2 = 10 // 用法2 编译器可以自动推导出v2的类型
v3 := 10 // 用法3 编译器可以自动推导出v2的类型
注意:
第三种方法不能用于声明全局变量
即使第三种初始化方法很像动态语言,比如Python,但是Go是强类型语言(静态语言)
变量赋值
Go支持多重复值,所以可以实现直接交换两个数的值操作
i, j = j, i
匿名变量
在一般强类型语言中,如果函数返回多个值,那么需要定义多个多余的变量,在Go中,可以使用匿名变量代替你不需要的变量
例如,GetName()返回三个值,但是你只需要最后一个值
-, -, nickName = GetName()
常量
常量指不可以更改的值
字面常量
程序中硬编码的常量,如:
-12
3.2132131231232 // 浮点型常量
3.2+12i // 复数型常量
true // 布尔型常量
"foo" // 字符串常量
常量定义
与C语言一样,使用const关键字定义常量
const Pi float64 = 3.14159263123213213
const zero = 0.0 // 无类型浮点常量
const (
size int64 = 1024
eof = -1 // 无类型整形常量
)
const u, v float32 = 0, 3 // 常量的多重赋值
Go可以定义常量的类型,也可以定义无类型常量.
常量的右值可以是一个常量表达式,因为常量的赋值是编译期行为,所以右值不可以是一个运行期表达式
预定义常量
Go预定义了这些常量: true、false和iota
true和false比较常见 用法也是类似的
这里详细说一下iota:
iota比较特殊,可以被认为是一个可被编辑器修改的常量,在每个const出现后iota重置为0,在下一个const出现之前,没出现一次iota,其代表的数字加1,下面举个例子:
const (
c0 = iota // c0 = 0
c1 = iota // c1 = 1
c2 = iota // c2 = 2
)
const (
c0 = iota*2 // c0 = 0
c1 = iota*2 // c1 = 2
c2 = iota*2 // c2 = 4
)
如果下面的赋值表达式相同,那么可以省略,比如上面第一个表达式可以写成:
const (
c0 = iota // c0 = 0
c1 // c1 = 1
c2 b// c2 = 2
)
枚举
枚举指一系列相关的常量,比如下面关于一个星期中每天的定义:
const (
Sunday = iota
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
numberOfDays // 这个常量没有导出
)
以大写字母开头的常量在包外可见,以上例子中numberOfDays为包内私有,其他符号可以被其它包访问
类型
Go包含以下基础类型:
- 布尔类型: bool
- 整形: int8, byte, int16, int, uint, uintptr等
- 浮点类型: float32, float64.
- 复数类型: complex64, complex128
- 字符串: string
- 字符类型: rune
- 错误类型: error
此外,还包含以下这些复杂类型: - 指针 ( pointer )
- 数组 ( array )
- 切片 ( slice )
- 字典 ( map )
- 通道 ( chan )
- 结构体 ( struct )
- 接口 ( interface )
布尔类型
关键字bool,可赋值为预定义的true和false
布尔类型不接受其他类型的赋值,不支持自动或强制的类型转换
整形
整形是所有语言中最基础的类型
包括有符号的整形 int8 int16 int32 int64以及对应的无符号整形数 uint8 uint16 uint32 uint64 这里面的数字 8，16，32，64对应的是计算机位数 。
这里对应有特定平台的有符号int型与无符号uint型 这两种类型是根据CPU的处理位数来确定对应大小的
uintptr 没有指定大小，但是可以容纳指针。
类型表示
int和int32在Go语言中是两种不同的类型,如果要进行赋值,必须进行强制转换
强制转换时需要注意
- 数据长度被截短导致的数据进度损失问题
- 值溢出(超过转换的目标类型的值范围)
数值运算
Go语言支持常规的整数运算:加减乘除和取余
比较运算
Go支持 >, <, ==, >=, <= 和 !=.
注意
两个不同类型的整数不能直接比较,但是各种类型的整形变量都可以直接和字面常量比较
位运算
| 运算 | 含义 |
|---|---|
| x << y | 左移 |
| x >> y | 右移 |
| x ^ y | 异或 |
| x & y | 与 |
| x | y |
| ^x | 取反 |
浮点型
浮点型用于表示包含小数点的数据
浮点数表示
float32等价于C中float类型,float64等价于C中double类型
浮点数比较
浮点数不是一种精确的表达方式,所以没有办法直接使用==来判断.
这里推荐一种比较的方法:
import 'math'
// 这样可以自己确认浮点数的比较精度
func IsEqual1(f1, f2, p float64) bool {
return math.Abs(f1-f2) < p
}
复数类型
复数实际上由两个实数构成,一个表示实部,一个表示虚部.
复数表示
复数表示示例如下:
var value1 complex64
value1 = 3.2 + 12i
value2 := 3.2 + 12i
vlaue3 := complex(3.2, 12)
实部和虚部
Go中可以通过real(z)获取复数的实部,imag(z)获取复数的虚部.
字符串
字符串也是基本类型之一.
字符串操作
| 运算 | 含义 |
|---|---|
| x + y | 字符串连接 |
| len(s) | 字符串长度 |
| s[i] | 取字符串 |
更多的字符串操作,可以参考标准库strings包
字符串遍历
字符串遍历有两种方法
第一种通过下标来访问字符串
str := "Hello, everyone"
n := len(str)
for i:= 0; i < n; i++ {
ch := str[i]
fmt.Println(i, ch)
}
第二种类似于python中的遍历
for i, ch := range str {
fmt.Println(i, ch)
}
字符类型
Go中包含两种字符类型,一个是byte,代表UTF-8字符串的单个字节的值;另一个是rune,代表单个Unicode字符
出于简化语言的考虑,Go语言的多数API都假设字符串为UTF-8编码.
数组
数组同样也是Go语言中最常用的数据结构之一.数组就是指一系列同一类型数据的集合.
数组的长度在定义后是无法更改的.
下面是一些常规的数组声明方法:
[32]byte // 长度为32的数组,每个元素为一个字节
[2*N] struct { x, y int32 } // 复杂类型数组
[1000]*float // 指针数组
[3][5]int // 二维数组
元素访问
可以使用数组下标来访问数组,同样也可以通过range函数来遍历数组.
range函数返回两个值,第一个是数组的下标,第二个是元素的值.
值类型
数组是值类型,如果在函数中传入数组,那么在函数中其实是数组的副本,是无法对原数组实行具体操作的.
数组切片
数据切片的数据结构可以抽象为以下3个变量:
- 一个指向原生数组的指针
- 数组切片中的元素个数
- 数组切片已分配的存储空间
创建数组切片
创建数组切片的方法主要有两种 --------- 基于数组和直接创建
基于数组
var Array [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
var array []int = Array[:5]
直接创建
Go中make方法可以直接创建数组切片
mySlice := make([]int, 5)
mySlice := make([]int, 5, 10)
动态增减元素
Go中有cap和len函数
cap函数用于计算数组分配的空间大小
len函数用于计算数组实际元素个数
对于动态增加元素,下面示例:
mySlice := make([]int, 5, 10)
mySlice2 := []int{8, 9, 10}
mySlice = append(mySlice, mySlice2...) // 这里...用于把mySlice包含的元素打散
基于数组切片创建数组切片
可以直接通过对已有数组切片后创建数组切片,并且这个切片范围可以大于数组元素个数,但是不能大于数组分配的空间大小,当超出原有数组的元素,自动赋值为0
内容复制
Go语言中的copy函数可以用于数组内容的复制,如果加入的两个数组切片不一样大,那么就会按照其中较小的数组切片元素进行复制.
map
map(字典)是一对键值对的微排序集合.在python中dict数据结构类似.
变量声明
var myMap map[string] PersonInfo
myMap是声明的map变量名,string是键类型,PersonInfo是值类型
创建
通过make函数创建一个新的map.
myMap = make(map[string] PersonInfo, 100)
创建一个新的map,存储能力是100
初始化
myMap = map[string] PersonInfo{
"1234": PersonInfo{"1", "Jack", "Room 101...."},
}
元素赋值
赋值就直接将键值对应即可
元素删除
Go语言提供一个内置函数delete(),用于删除容器内的元素.
delete(myMap, "1234")
元素查找
在python中dict查找直接使用关键字in即可.
在Go中元素查找可以这样写:
value, ok := myMap["1234"]
if ok {
}
流程控制
Go语言支持下面几种流程控制语句:
- 条件语句, 对应关键字if, else 和 else if
- 选择语句, 对应关键字switch, case 和 select
- 循环语句, 对应关键字for和range
- 跳转语句, 对应关键字goto
Go还添加了如下关键字:break, continue, fallthrough
条件语句
条件语句,需要注意以下几点:
- 条件语句不需要使用括号将条件包含起来
- 无论语句体内有几条语句,花括号都是必须存在的
- 在if之后,条件语句之间,可以添加变量初始化语句,使用;间隔
- 在有返回值的函数中,不允许将"最终的"return语句包含在if…else…结构中,否则会编译失败
选择语句
选择语句与C语言大致,但是Go中switch语句后面的表达式甚至不是必须的.
注意:
- 做花括号必须与switch同一行
- 条件表达式不限制为常量或者整数
- 单个case中,可以出现多个结果选项
- 与C语言等规则相反,Go语言不需要用break退出一个case
- 只有在case中明确添加fallthrough关键字,才会继续执行紧跟的下一个case
- 可以不设定switch之后的条件表达式,在此种情况下,整个switch结构与多个if…else…的逻辑作用等同
循环语句
Go中只支持for关键字,不支持while和do-while结构.
Go中for循环同样支持continue和break来控制循环,但是Go提供了一个更高级的break,可以选择中断哪一个循环.
跳转语句
goto语句被多数人反对,但是Go语言仍然支持goto关键字.
函数
函数的基本组成为:关键字func,函数名,参数列表,返回值,函数体和返回语句
函数定义
func 函数名(参数列表) (返回值) {
函数体
返回值
}
其中参数列表和返回值都需要写清楚返回值和类型,如果类型统一,那么只需要写一次即可.
不定参数
形如…type格式的类型只能作为函数的参数类型存在,并且必须是最后一个参数.这其实是一种语法糖,为了方便程序员写代码.
不定参数的传递
func myfunc(args ...int) {
// 按原样传递
myfunc3(args...)
// 传递片段
myfunc3(args[1:]...)
}
任意类型的不定参数
例子:
func MyPrintf(args ...interface{}) {
for _, arg := range args {
switch arg.(type) {
}
}
}
匿名函数与闭包
匿名函数
匿名函数由一个不带函数名的函数声明喝函数体组成,如下所示:
func(a, b int, z float64) bool {
return a*b <int(z)
}
匿名函数可以直接赋值给一个变量或直接执行
f = func(a, b int, z float64) bool {
return a*b <int(z)
}
func(ch chan int){
ch <- ACK
} (reply_chan) // 花括号后面跟参数列表表示函数调用
闭包
基本概念
闭包是可以包含自由(未绑定到特定对象)变量的代码块,这些变量不再这个代码块内或者任何全局上下文中定义,而是在定义代码块的环境中定义.要执行的代码块(由于自由变量包含在代码块中,所以这些自由变量以及他们引用的对象没有被释放)为自由变量提供绑定的计算环境(作用域)
闭包的价值
闭包的价值在于可以作为函数对象或者匿名函数
Go中的闭包
a := func() (func()) {
var i int = 10
return func() {
fmt.Printf("i, j: %d, %d\n", i, j)
}
}()
错误处理
error接口
Go语言引入了一个关于错误处理的标准模式,即error接口,该接口定义如下:
type error interface {
Error() string
}
defer
defer关键字不管在是否出现异常,最后都会执行defer后的表达式
defer后面还可以跟匿名函数 一个代码块中可以有多个defer 但是defer执行的时候遵循先进后出的规则
panic() 和 recover()
当一个函数执行过程中调用panic()函数时,正常的函数执行流程立即终止,并且返回调用函数执行panic()函数,直到所属的goroutine中所有正在执行的函数被终止.
recover()函数用于终止错误处理流程.一般情况下,recover()函数在defer关键字的函数中确保有效地截取错误信息
参考
- 《Go语言编程》——许式伟