Go语言学习 golang

语法基础变量、常量

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语言的 . 操作符，会直接解引用指针，无需再显示使用 * 解引用
1. 引用类型
映射、切片、通道、函数、方法都是引用类型

数组

长度固定，不可修改
声明与初始化（未被显示初始化的元素，值会初始化位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]intfunc (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 { Titlestring Forenames []string Surnamestring }type Author1 struct { NamesPerson // 聚合 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结束
【Go语言学习】sync库支持如下

waiter := &sync.WaitGroup() // 创建go func() { // 然后再某个routine中 waiter.Add(1)// 该routine结束的时候 waiter.Done() }()// 如果要等待这一组通过Add方法收集的routine的结束 waiter.Wait()

包