Go in Action - Manning 2016(读书笔记)

cteng · · 1274 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

Go in Action

Go in Action - Manning 2016

目录

介绍Go

  1. fmt.Println("Hello, world")
  2. ?这本书里似乎没提到Go异常处理?

Go快速入门

  1. log.SetOutput(os.Stdout) //import ("log" ...)
  2. package main //main必须在main包里才会生成可执行文件? 通常以所在目录命名?
    1. func init() { ... }
    2. func main() { ... }
  3. search.go
    1. var matchers = make(map[string]Matcher)
    2. go func(matcher Matcher, feed *Feed) { ... }(matcher, feed)
  4. defer file.Close() //跟初始化file, err := os.Open(dataFile)在同一个作用域,确实比try-finally或者using要简单一点
  5. func Match(matcher Matcher, feed *Feed, searchTerm string, results chan<- *Result) {
    1. 注意这里‘写chan’的参数声明
  6. 如果2个value struct里的*成员引用同一个对象?——会自动引用计数吗?
  7. XMLName xml.Name `xml:"item"` //还有这种类型?

打包、工具

  1. 远程导入:
    1. import "github.com/spf13/viper" //go build命令会搜索本地GOPATH(嗯?这会导致总是下载到最新的版本?有可能不兼容)
  2. 命名导入:
    1. import (myfmt "mylib/fmt")
  3. 匿名导入(sql驱动,略)
  4. filename := os.Args[1]
    1. contents, err := ioutil.ReadFile(filename) //读全部内容?没有迭代器吗
  5. go build .
  6. go vet //lint工具?
  7. go fmt //代码洁癖...
  8. godoc -http=:6060
  9. 依赖管理
    1. vendoring
      1. import "bitbucket.org/ww/goautoneg" 转换为
        • "github.ardanstudios.com/myproject/Godeps/_workspace/src/bitbucket.org/ww/goautoneg"
    2. gb
      1. import的问题是没有指定版本
      2. vendored code:$PROJECT/vendor/src/
      3. 与go get不兼容
      4. gb build all

数组、切片和maps

  1. 数组
    1. array := [5]int{10, 20, 30, 40, 50}
    2. array := [...]int{10, 20, 30, 40, 50} //自动推断数组长度,维度一旦初始化不可修改
    3. array := [5]int{1: 10, 2: 20} //选择下标初始化?
    4. array[2] = 35
    5. array := [5]*int{0: new(int), 1: new(int)} //指针数组
      1. *array[0] = 10 //其实Go语言里并不严格区分指针和引用?
    6. array1 = array2 //数组是value对象,赋值操作将导致内存copy
    7. array2d := [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}
    8. 传递数组的地址给函数:func foo(array *[1e6]int) { ... } //注意,这里的数组指针类型比C语言要直接多了
  2. slice:是对array的封装,内部提供了addr,length,capacity元数据
    1. slice := make([]string, 5)
    2. slice := make([]int, 3, 5)
    3. slice := []string{"Red", "Blue", "Green", "Yellow", "Pink"} //注意这里[]里既没有长度常量,也没有...自动推断
    4. newSlice := slice[1:3] //长度2,容量4?newSlice初始情况下引用slice?
      1. slice容量=5,newSlice的容量=5-1=4,注意,newSlice不可以访问slice[0]元素(这种设计很有意思!)
    5. 多个slice可能共享一块内存(那么修改需要同步吗)
    6. slice[index]只能访问length范围内的元素,要访问容量范围内的,需要append:newSlice = append(newSlice, 60)
      1. 当底下的实际存储不足新capacity时,append会分配新内存?有点realloc的味道
      2. append:length=1000一下时每次double,否则增加25%
    7. slice := source[2:3:4] //如果是start:length:capacity三元组(不是Python里面的那种语法)
    8. 迭代:for index, value := range slice { ... } //Go惯用法;想起了Python里的enumerate函数
  3. map
    1. dict := make(map[string]int)
    2. dict := map[string]string{"Red": "#da1337", "Orange": "#e95a22"} //注意,:=代表类型定义(自动推断)及初始化
    3. dict := map[[]string]int{} //编译错误:slice不能用作map key(必须可执行==操作),但可用作map value
    4. nil map问题:
      1. var colors map[string]string
      2. colors["Red"] = "#da1337" //运行时错误
        1. 可以这样:value, exists := colors["Blue"] //又是Go惯用法
      3. value := colors["Blue"] //这样是可以的,如果key不存在,value返回类型的零值
    5. delete(colors, "Coral") //删除元素,又是内置函数,这一点不同于C++语言的成员函数风格
    6. map在函数之间传递时不会copy

Go的类型系统

  1. var总是初始化变量为零值
    1.  := 同时声明及初始化
  2. type typeName struct { fields... }
    1. 然后就可以func (a typeName) methodName(args) retType { ... }扩展方法了
      1. 也可以写成func (a *typeName) ...,但是调用方法时全部是.号,但是指针类型的变量必须是&struct{...}初始化来的
      2. a typeName的形参代表方法操作的是type的value类型,也就是C++里面的const方法?
      3. value类型的变量可以调用用指针类型定义的方法(这些地方太容易让人犯迷糊了),将会被转换为(&obj).method()
  3. 引用类型:slice、map、channel、interface、func
    1. `header` value, contains a pointer
  4. Interfaces
    1. `method sets`(C++里的vtable?)
    2. 接口里的方法指针是不是运行时动态填充的???
    3. 接口实现的接收者通常是*T,而不是value类型的T?
      1. 如果你以value T类型作为接受者来实现接口,那么接口作为参数时可以接受T和*T(?)
  5. 类型嵌入
    1. 有点Ruby/Scala mixin的风格~
    2. inner type promotion //只要名字不冲突?
  6. Exporting and unexporting identifiers
    1. 取决于名字的第1个字母是大写还是小写。。。
  • 感觉本章里作者说的废话太多了,其实简单一句话就可以说清楚了!

并发

  1. logical processors?
    1. 当执行blocking IO操作时,detach;当IO ready时,重新attach?
  2. 第1个例子:
    1. runtime.GOMAXPROCS(1) //或runtime.NumCPU()
    2. var wg sync.WaitGroup //wg的用法是不是可以直接看文档和sample代码即时掌握?
    3. wg.Add(2)
    4. go func() {
      defer wg.Done()
      }()
    5. wg.Wait()
  3. scheduler可在goroutines执行时自动打断?(swap out?抢占式调度?)这个内部操作发生在fmt.Printf调用的时候吗
  4. 竞争条件
    1. 读写共享变量必须是atomic的;
    2. 检测工具:go build -race
    3. 方法1:atomic.AddInt64(&counter, 1) #奇怪,atomic包是怎么做到对一个int64变量的修改是原子的?利用平台特定的汇编指令?
    4. 方法2:mutex sync.Mutex => mutex.Lock() { ... } mutex.Unlock()
  5. 更灵活地,Channels
    1. 初始化:
      1. unbuffered := make(chan int) #如果有一个没准备好,第一个操作(发送/接受)wait
      2. buffered := make(chan string, 10)
        1. close操作:仍然可以接受,但不可以再发送(任务派发端)
    2. 发送数据:buffered <- "Gopher"
    3. 接受数据:value := <-buffered
  6. rand.Seed(time.Now().UnixNano())

并发模式

  1. Runner:监控运行时间及超时终止
    1. type Runner struct {
      1. interrupt chan os.Signal
      2. complete chan error
      3. timeout <-chan time.Time
      4. tasks []func(int)
    2. var ErrTimeout = errors.New("received timeout") //预创建的错误对象
    3. func (r *Runner) Add(tasks ...func(int)) { r.tasks = append(r.tasks, tasks...) } //注意这里的变参;
    4. func (r *Runner) Start() error { //运行所有tasks,并监控超时错误
      1. signal.Notify(r.interrupt, os.Interrupt)
      2. go func() { r.complete <- r.run() }()
      3. select {
        1. case err := <-r.complete: return err
        2. case <-r.timeout: return ErrTimeout
    5. func (r *Runner) run() error { ... } //依次执行每个task,略
    6. func (r *Runner) gotInterrupt() bool {
      1. select {
        1. case <-r.interrupt: signal.Stop(r.interrupt) return true //注意这里检查有没有接受到操作系统中断
        2. default: return false //default分支使得前面的<-r.interrupt操作不会阻塞(?有可能丢失中断吗)
          • 注意,初始化:interrupt: make(chan os.Signal, 1), timeout: time.After(duration), //把OS中断和超时建模为特殊的chan
  2. Pooling
    1. type Pool struct {
      1. m sync.Mutex //这个用来保护什么?chan本身不是自动同步的嘛(保护对closed变量的赋值???靠)
      2. resources chan io.Closer
      3. factory func() (io.Closer, error) //这个命名真恶心,应该改成allocNewResource
      4. closed bool
    2. func (p *Pool) Acquire() (io.Closer, error) {
      1. select {
        1. case r, ok := <-p.resources: ...
        2. default: return p.factory()
    3. func (p *Pool) Release(r io.Closer) {
      1. p.m.Lock()
      2. defer p.m.Unlock()
      3. ...
      4. select { case p.resources <- r: ... //default:pool已满,直接释放资源
    4. 循环内启动goroutine防止共享同一个index/counter变量:
      1. go func(a int){ ... }(i)
  3. Work
    1. 命名有点问题,Work()似乎应该是ExecuteWork()?

标准库

  1. http://sourcegraph.com/code.google.com/p/go/.GoPackage/io/.def/Writer 靠,无法访问
  2. Logging
    1. log.SetPrefix("TRACE: ")
    2. log.SetFlags(log.Ldate | log.Lmicroseconds | log.Llongfile)
    3. log.Println/Fatalln/Panicln("message")
    4. const {
      1. Ldate = 1 << iota
    5. 定制logger:
      1. var ( Trace *log.Logger ...... )
      2. Trace = log.New(ioutil.Discard, "TRACE: ", log.Ldate|log.Ltime|log.Lshortfile) # var Discard io.Writer = devNull(0)
    6. Stdin = NewFile(uintptr(syscall.Stdin), "/dev/stdin") //?
    7. io.MultiWriter(file, os.Stderr) //?
  3. Encoding/Decoding
    1. gResult struct {
      1. GsearchResultClass string `json:"GsearchResultClass"` //struct内的成员需要特殊的json映射声明(tags元数据);
      2. ...
    2. gResponse struct {
      ResponseData struct {
      Results []gResult `json:"results"`
      } `json:"responseData"`
    3. 解码:
      1. var gr gResponse
      2. err = json.NewDecoder(resp.Body).Decode(&gr)
    4. unmarshal:
      1. err := json.Unmarshal([]byte(JSON), &c) //?
      • 更灵活的解析:?
        var c map[string]interface{}
        err := json.Unmarshal([]byte(JSON), &c) //这种情况下感觉代码中interface{}会被滥用?
    5. 编码
      1. c := make(map[string]interface{})
      2. ...
      3. data, err := json.MarshalIndent(c, "", " ")
  4. Input and output
    1. 好像没什么特别值得一说的(又一套API命名风格)

测试与性能基准

  1. listing01_test.go
    1. func TestDownload(t *testing.T) {
      t.Log("Given the need to test downloading content.") #t.Errorf代表测试失败?
      ...
      resp, err := http.Get(url)
      defer resp.Body.Close()
  2. func SendJSON(rw http.ResponseWriter, r *http.Request) {
    1. u = ...
    2. rw.Header().Set("Content-Type", "application/json")
    3. rw.WriteHeader(200)
    4. json.NewEncoder(rw).Encode(&u)
  3.  ?
    1. r, _ := http.NewRequest("GET", "/sendjson", nil)
    2. rw := httptest.NewRecorder()
    3. http.DefaultServeMux.ServeHTTP(rw, r)
  4. 性能基准测试
    1. func BenchmarkSprintf(b *testing.B) {
      b.ResetTimer()
    2. go test -v -run="none" -bench="BenchmarkSprintf" //运行次数?

有疑问加站长微信联系(非本文作者)

本文来自:CSDN博客

感谢作者:cteng

查看原文:Go in Action - Manning 2016(读书笔记)

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:692541889

1274 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传