Go语言编程（旧读书笔记）

Go语言编程

文件夹

 [隐藏] 

• 1 前言
• 2 初识Go语言
• 3 顺序编程
• 4 OOP
• 5 并发编程
• 6 网络编程
• 7 安全编程
• 8 project管理
• 9 开发工具
• 10 进阶话题
• 11 附录A

[编辑]前言

1. 协程？ go run('test')
2. Go强制了{ }的编写风格： if expression {
3. 错误处理：
   1. defer？相当于finally？注意这里的作用域，defer之前似乎没实用{ }把整个（try）块括起来？
      1. defer相当于说推迟语句的运行，其内部实现会自己主动管理嵌套作用域的问题？
   2. Go同意返回多个值（像Python里的tuple返回）
4. Go用组合，不用继承、虚函数、虚函数重载
5. Go里的变量声明是先变量名字，后类型名字（Pascal风格，但没有:）？
6. Go的接口是duck typing吗？
   1. Go里。2个接口仅仅要拥有同样的方法列表（名字、签名、顺序？？），那么就是等同的
7. ？Go里避免太多的{ }嵌套可能是一种策略——这使它显得更像一门脚本语言。给程序猿写代码带来某种“轻快”的感觉。

   。。

[编辑]初识Go语言

1. Plan 9上的Limbo语言被觉得是Go的前身？
2. 支持自己主动GC？——那不就和Java/C#的性能几乎相同了么
3. 更丰富的内置类型：
   1. Slice
   2. map
4. 多返回值
   1. func getName() (firstName, lastName, nickName string){

      //因为这里返回值也给了名字。因此可以赋值然后空return！

      （Python里似乎还不可以这么灵活。靠）

   2. fn, ln, nn := getName()

      模式匹配（destructuring）：_,ln,_ := getName()

5. 错误处理：defer、panic、recover
6. 匿名函数和闭包
   1. f := func(x,y int) int { return x+y }
7. 类型：类似于C里的struct（预计这里借用了Objective-C的一些做法。

   。

   。）

   1. type Bird struct { ... }
   2. func (b *Bird) Fly() { ... } //这一句的写法我怎么有点看不明确呢？见鬼
8. 并发编程
   1. resultChan := make(chan, int, 2)
   2. go sum(.../*參数略*/, resultChan)
   3. func sum(..., resultChan chan int) {

      ... resultChan <- sum

   4. sum1, sum2 := <-resultChan, <-resultChan //Channel对象仅仅有一个符号操作：<- 。放左边代表取出，右边表示放进？
9. 反射：靠，这边的语法太丑陋了，妈的
10. Cgo
11. 第1个Go程序：
    1. package main
    2. import "fmt"
    3. func main() {

       fmt.Println("Hello, world!")

12. go run hello.go //直接执行。
    1. go build hello.go && ./hello //编译执行。即能够解释执行，也能够编译执行（这个跟Rust倒是一样的）

[编辑]顺序编程

1. var v3 [10]int //变态的数组声明语法~
2. var v7 map[string] int //string->int的映射
3. i := 10 //自己主动类型推导？
4. i,j = j,i
5. 数值类型：int uint int32 int64 float32 float64 complex64 complex128
6. const
7. true false iota（每一个const的开头从0開始。每次出现自己主动增1？用于定义枚举。但Go并不支持enumkeyword）
8. string byte/rune error
9. uintptr
10. 不同类型的数不能直接比較，也就是说，Go不做自己主动类型提升？
11. 字符串遍历：for i := 0; i < len(str); i++ { ... str[i] }
12. Unicode字符遍历：
    1. for i, ch := range str { ... }
13. 数组是一个值类型。
    1. 切片：var mySlice []int = myArray[:5]

       mySlice2 := make([]int, 5)

       可动态增减元素：len(mySlice) cap(mySlice) append copy ...

14. map
    1. delete(myMap, "key") //靠，这里的操作都是C语言风格的，不支持C++/Java/C#里的.成员函数訪问操作？
15. 流程控制：
    1. if else
    2. switch case
    3. for
    4. goto
16. 函数
    1. 成员函数的写法太怪异了：func (file *File) Read(b []byte) (n int, err Error) //注意。没有其它语言里的this、self等keyword！
17. 闭包
18. 错误处理
    1. p48 return nil, &PathError("stat", name, err) //这里&的写法是怎么回事？以引用方式传递对象吗
    2. defer func() { ... } ()
    3. func panic(interface())
    4. func recover() interface()

[编辑]OOP

1. 值语义（默认？）和引用语义（&）
   1. ？Go使用*符号。那么它究竟是不是C/C++里的指针？（预计不是。但看着有点诡异）
2. 初始化
   1. r1 := new(Rect)
   2. r2 := &Rect()
3. 组合就是继承：type Derived struct{

   Base //还能够写成*Base，这种话，。。。——相当于C++里的虚基类？

   ... //*log.Logger：可直接注入其它类的方法？但logger类显然无法訪问当前类的数据成员（！！）

4. 可见性：大写为public。小写是private
5. （非侵入式的）接口
   1. 这里的语法似乎有点类似于Objective-C。

      。

      。注意声明type IFile interface { ... }时，里面的Read、Write不须要带(f *File)（this引用）

   2. 接口查询：略
   3. 类型查询：vt := v.(type)
   4. 接口组合
   5. Any类型：interface()

[编辑]并发编程

1. 主main不等待goroutine直接退出会导致线程强制结束？
2. channel
   1. select（这是学习了Erlang吧？）
   2. 超时机制：创建一个额外的channel
      1. timeout := make(chan bool, 1)
      2. go func() { time.Sleep(1e9) timeout <- true }()
      3. select {

         ... case <-timeout: //已经超时

   3. 利用channel传递实行管道？
   4. 单向chan：声明的时候加上<-
   5. 关闭：close(ch)
3. 同步
   1. sync.Mutex sync.RWMutex
   2. sync.Once

[编辑]网络编程

1. net.Dial？这种方法名太。。

   。

   了

2. net/http
3. net/rpc
   1. Gob
4. JSON

[编辑]安全编程

1. 略

[编辑]project管理

1. 远程import：神经病！

2. GOPATH
3. Android支持？？？——必须在adb shell下执行吧

[编辑]开发工具

[编辑]进阶话题

1. 反射
   1. Type, Value
2. 语言交互
   1. Cgo：import "C"
3. 链接符号：由下列信息构成（注意Go里无重载）
   1. Pakcage
   2. ClassType
   3. Method（恩？链接符号同意/、*、. ？）
4. goroutine机制
   1. libtask？
5. 接口机制

[编辑]附录A

1. 经常使用包：fmt io bufio strconv os sync flag encoding/json http