[编辑]前言

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并不支持enum关键字）
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等关键字！
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. 略

[编辑]工程管理

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