Go语言学习
语法基础
变量、常量
const var = 1
const (
var = 1
)字符串
- Go语言字符串为任意字节常量序列
- UTF-8编码，变宽字符序列。而Java的String、C++的std::strin都是定宽的
- 可使用 ==、!=、>=、<=、>、<比较字符串，底层会在内存中逐字节比较字符串
- 可直接转成
[]rune，unicode切片（rune是int32的别名） 可使用 ` 和 ” 创建
双引号创建可解析字符串，支持转义序列，不支持多行
反引号创建原生字符串，不支持转义序列，支持多行，可包含除了反引号之外的任意字符可使用 for range循环
for idx, rune range str {
....
}- Go语言字符串底层就是增强型的
[]byte，所以[]byte(string) string([]byte)只需要O(1)，无需复制 - 对于只包含7位ASCII字符的字符串，可以直接用
string[idx]索引字符；而对于包含非ASCII字符的字符串，需要转换成[]rune(string)再索引 strings.IndexFunc(string, indexFunc)可使用自定义方法查询index，如unicode.IsSpace来查询任意空白符的位置strings.FieldsFunc(string, func(rune) bool)遍历string中rune，如果匿名函数返回true则进行拆分
集合类型
值、指针和引用类型
- 指针
- Go指针类似C、C++，区别是不能参与指针计算
- Go不需要显示free内存，本身具备垃圾回收器
- 对布尔、数值、字符串类型，传递给方法和函数时使用了值传递，且无论字符串长度如何，代价都很小。但是如果函数内部修改了字符串，那么将会生成一份副本，这个代价可能比较大
- new() 函数返回的是指针 同 取址操作符 &
type test struct {
id int64
}
hello := new(test)
hello.id = 2- Go支持大括号直接初始化对象
Go语言的 . 操作符，会直接解引用指针，无需再显示使用 * 解引用
- 引用类型
- 映射、切片、通道、函数、方法都是引用类型
数组
- 长度固定，不可修改
- 声明与初始化（未被显示初始化的元素，值会初始化位0值）
[length]Type
[N]Type{value1, value2, ...}
[...]Type{value1, value2, ...}切片
- 创建，二三四长度等于容量
make([]Type, length, capacity)
make([]Type, length)
[]Type{}
[]Type{value1, value2, ...}- 切片的重新切片 与 原切片都是对同一个底层数组的引用
- for range循环中，直接修改range参数中的当前元素，会包 ineffectual assignment错误。
for _, amount := range amounts {
amount = amount * 2
}正确修改方式如下
for i := range amounts {
amounts[i] xxxxx
}- append函数 返回新切片（…代表 将切片元素全部取出转成数组）
append(slice1, slice2[idx:]...)
映射
- 键唯一，且必须支持 == 与 != 操作
- 基本类型、可比较的数组、结构体以及基于这些类型的自定义类型都可以作为键
- 创建方式
make(map[KeyType] ValueType, initialCapacity)
make(map[KeyType] ValueType)
map[KeyType] ValueType{}
map[KeyType] ValueType{key1: value1, ...}- 支持for range遍历
- 查询，可以通过判断found来知晓是否存在键，但通过值无法判断，因为不存在就返回零值
value, bFound := map[key] - 删除
delete(map, key)
过程式编程
快速声明
- 快速声明操作符
:=，如果声明的变量已经存在了，只有当声明语句位于块作用域的起始处，才会新创建一个变量，否则会直接覆盖原值。 - 使用函数命名返回值时需特别注意函数中快速声明的同名变量
类型转换
resultOfType := Type(expression)- 整形、浮点型、复数互转注意精度丢失
- []byte、[]rune可以转为string，反之亦然
类型断言
- 安全类型断言
resultofType, bOK := expression.(Type) - 非安全类型断言
resultofType := expression.(Type)，如果失败，panic
分支
- if分支
if optionalStatement; booleanExpression {
} else if optionalStatement; booleanExpression {
} else {
}- switch分支，Go语言的case不会自动向下贯穿，需使用
fallthrough关键字
switch optionalStatement; optionalExpression {
case optionalStatement; booleanExpression: blockStatements
case optionalStatement; booleanExpression: fallthrough
default: blockStatements
}- 类型开关，
typeSwitchGuard是一个结果为类型的表达式。如果 对开关表达式使用了 快速申明，那么获取的值为开关表达式中的变量的值，类型决定于case分支
switch optionalStatement; typeSwitchGuard {
case typeLis1: block
...
default: block
}for循环
- 各种循环格式
for {//无限循环
block
}
for booleanExpression {// while循环
block
}
for optionalPreStatement; booleanExpression; optionalPostStatement {// 普通for循环
block
}
for index, value := range string or array or slice {// 普通for range循环，字符串、数组、切片
block
}
for index := range string or array or slice {// 省略value的for range循环，字符串、数组、切片
block
}
for key, value := range map {// 普通for range循环，映射
block
}
for item := range channel{// 通道迭代
block
}通信和并发
goroutine
- 类似轻量级线程
- 可在小机器开销的情况下大量创建
- 所有goroutine共享地址空间
- goroutine间推荐通过通信的方式获取共享数据
创建goroutine
go functionName(arguments) // 调用已有函数
go func(parameters){block}(arguments) // 创建新匿名函数 channel创建
make(chan Type)
make(chan Type, capacity)通道默认是双向的
不声明缓冲区容量的通道默认为同步的，阻塞直至发送准备好发送或者接收准备好接收
给定缓冲区容量则认为是异步的，只要缓冲区存在未使用空间或者包含可接收数据，就会是异步的
channel消息收发
channel <- value //阻塞发送
<- channel // 接收并丢弃
x := <- channel // 接收并保存
x, ok := <- channel // 接收并保存并判断通道是否已关闭或者是否为空channel关闭
延时关闭可使用defer关键字
defer func(){ // defer函数会在外层函数返回时被调用
close(chanVar)
}close关键字不支持关闭 只接收的通道
select语句
select会评估所有case语句中的通道操作是否阻塞，全部阻塞时，若无default则等待，若有default执行default后继续执行后续语句；通道操作有可执行的，则执行并进入对应block，然后执行后续语句
select {
case sendOrRecv1: block
case sendOrRecv2: block
default: block
}defer、panic、recover
defer
- 延迟在外层函数返回时执行
- 若一个函数内有多个defer语句，则秉承LIFO原则执行
- Go语言推荐在可释放资源创建后紧跟defer关闭语句
panic和recover
- Go语言区分错误与异常，错误指可能出错的东西，程序需优雅地处理；异常指原本不可能发生的问题发生了，需要立即中断当前函数或程序执行
- panic发生时，会立即终端当前函数执行，然后调用存在的defer语句，然后返回到当前函数调用者，如法炮制，中断外部函数执行，调用defer语句，直至上升到main函数，中断整个程序执行
- 如果panic在函数栈上升的过程中，某个函数的defer中存在recover()处理，则会终止panic继续向上传播
自定义函数
- 创建，Go语言对函数的创建顺序没有要求
func functionName(optionalParameters) optionalReturnType {
}
func functionName(optionalParameters) (optionalReturnValues){
}有返回值的函数一定需要return（或者结尾处存在panic）。如果返回值未命名，则须在return后紧跟返回值类型定义相同的返回值；如果返回值已命名，则return后可空白
可变参数函数，这里
...Type实际上是[]Type切片
func functionName(values ...Type){// 其实， ...的作用是展开切片的意思。 numbers[1:]... 代表展开 numbers切片的子切片
}- 每个程序必须有main包，main包总必须有main函数。每个包中最多可以有一个init函数。每个包的init函数会在main之前被执行。
- 闭包，匿名函数（函数字面量）都是闭包。
- Go语言的泛型就是使用
interface{}来作为参数类型
面向对象编程
自定义结构体与添加的方法，首字母大写的会被导出，小写的不 导出
- Go语言不支持继承，只支持聚合和嵌入
type ColoredPoint struct{
color.Color // 嵌入
x, y int // 聚合
}自定义类型，typeSpecification可以是内置类型、接口、结构体、函数签名
type typeName typeSpecification添加方法，就是在定义函数时指明了所属，函数名称要求在所属对象中唯一
type Count int
func (count *Count) Increment() {*count++}
func (count *Count) Decrement() {*count--}
func (count Count) IsZero() {return count == 0}- 嵌入 与 方法重写
type Item struct {
id string
price float64
quantity int
}
func (ite *Item) Cost() float64 {
return item.price * float64(item.quantity)
}
type LuxuryItem struct {
Item // 嵌入成员
cataogId int
markup int
}
func (item* LuxuryItem ) cost (item *Luxuryitem) float64 {
return item.Item.Cost * item.markup
}- 方法表达式：直接将自定义类型的方法当作变量使用。
asStringV := Part.String
sv := asStringV(part)
lowerP := (*Part).LowerCase
lowerP(&part)接口
- 只要自定义类型实现了同签名的全部接口方法，Go编译器就会自动将改自定义类型认为实现了这个接口
type Exchanger interface {
Exchange()
}
type StringPair struct {
first, second string
}
func (stringPair *StringPair) Exchange() {
stringPair.first, stringPair.second = stringPair.second, stringPair.first
}
type PointPair [2]int
func (pointPair *PointPair) Exchange() {
pointPair[0], pointPair[1] = pointPair[1], pointPair[0]
}
func BatchExchange(pairs ...Exchanger) {
for _, pair := range pairs {
pair.Exchange()
}
}
func TestExchangeInterface() {
stringpair := StringPair{"1", "2"}
pointpair := PointPair{1, 2}
fmt.Println("Before ", stringpair, pointpair)
BatchExchange(&stringpair, &pointpair)
fmt.Println("After ", stringpair, pointpair)
}- 接口嵌入，嵌入后父接口包含子接口的所有方法
type LowerCase interface {
ToLowerCase()
}
type UpperCase interface {
ToUpperCase()
}
type LowerUpperCase interface {
LowerCase
UpperCase
}结构体
聚合与嵌入
- 嵌入字段的访问，如果存在名称冲突，需要指定嵌入的结构体名称
type Person struct {
Title string
Forenames []string
Surname string
}
type Author1 struct {
Names Person // 聚合
Title []string
YearBorn int
}
type Author2 struct {
Person // 嵌入，匿名结构体字段
Title []string
YearBorn int
}
func Test_embedAndAggregation() {
author1 := Author1{Person{"Person", []string{"X", "U"}, "ZHE"}, []string{"XU", "ZHE"}, 19911115}
author1.Names.Title = "Male" // 聚合结构体的字段访问
fmt.Println(author1)
author2 := Author2{Person{"Person", []string{"M", "A"}, "ZHUOJUN"}, []string{"MA", "ZHUO", "JUN"}, 19920227}
author2.Surname = "ZHUOJUN2"// 聚合结构体的字段访问，不存在冲突
author2.Person.Title = "Female"// 聚合结构体的字段访问，存在冲突
fmt.Println(author2)
}- 结构体的初始化，要么依次写全参数，要么指定结构体成员名称
aStruct{field1:value1}
并发编程
runtime常用API
runtime.NumCPU()返回当前机器的逻辑处理器或者核心数量rumtime.GOMAXPROCS(n)n为0时，同上。n > 0时，设置Go运行时系统可以使用的处理器数
注意
- 所有业务goroutine在主goroutine退出后都会退出
- range chan 会一直从chan中获取数据，直到chan被显示关闭
goroutine组的join结束
sync库支持如下
waiter := &sync.WaitGroup() // 创建
go func() {
// 然后再某个routine中
waiter.Add(1)
// 该routine结束的时候
waiter.Done()
}()
// 如果要等待这一组通过Add方法收集的routine的结束
waiter.Wait()包
- go src下的包可以为本机所有工程共享，go root下的只能是本机当前用户使用
- Go中import包的搜索机制为：先Go Root然后 GOPATH 下
- Go推荐再GoPath下的src目录创建my_package目录，其中防止自己的代码，便于后续工程引用
反射
也叫 类型检视(introspection)
常用API
reflect.DeepEqual()可用于比较== != 不能比较的对象reflect.valueOf()返回一个reflect.Value结构，可以通过它获取真实值、获取成员、调用方法等- 对于无法修改的值，如string常量，可以获取其指针的值，然后使用
relect.Value.Elem()，获取值，替换掉指针所指向的string值。如下
test := "test1"
value := reflect.ValueOf(&test)
value.Elem().SetString("test2")reflect.Value.Call([]reflect.Value) []reflect.Value可以调用当前Value对应的方法。reflect.TypeOf(interface{}).Kind()可以获取类型，如reflect.Array, reflect.Chan等reflect.Value.MethodByName(string) reflect.Value可以获取指定方法