Go is expressive, concise, clean, and efficient. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines, while its novel type system enables flexible and modular program construction. Go compiles quickly to machine code yet has the convenience of garbage collection and the power of run-time reflection. It's a fast, statically typed, compiled language that feels like a dynamically typed, interpreted language. 
                                                                                          – 摘自Go语言官方站点

对于一门编程语言最深刻的喜欢莫过于对这门编程语言的设计理念的认同了，Go语言是继C语言之后又一门让我有如此感觉的编程语言。

初听到这门语言的存在时，我皱了皱眉：怎么起了这么一个名字！绝大多数编程语言都以名词或人名命名(如C、Java、Python、Ruby、 Haskell、Ada等)，而这门语言却用了一个日常生活中使用极为频繁的动词Go作为名字，这似乎有些太大众化了。不知为何，这个名字总是让 我联想到以前中国农村给小孩子常起的几个名字：二狗、牛娃等^_^。况且之前已经有很多IT产品也以Go作为名字(例 如，Thoughtworks公司出品的敏捷管理工具也叫Go)。

不过随着对这门语言的了解的深入，名字已不再是问题了。Go语言对我这个C程序员产生了强大的吸引力，原因如下：

* Go保持了与C语言一脉相承的理念：短小精悍、致力于成为系统编程语言、简洁而熟悉的C语言家族语法、静态编译型语言、保留了指针、运行高效；
* Go填平了C语言与生俱来的为数不少的"坑"；
* Go提升了编译速度，统一了源码组织、构建规范以及编码规范，让程序员更集中精力于问题域；
* Go改进了并发模型，在语言级别原生支持多核平台；
* Go语言起点高，以创新的设计以及甚小的代价兼容了现有主流编程范型(例如OO等)。

因此有人称Go为21世纪的C语言，我觉得不为过。从这篇文章开始，我将和大家一起走入Go语言的世界。

一、安装Go

Go语言官方站(从国内访问十分不稳定，时能时不能，原因你懂的)对Go安装有着较为详尽的说明。如果你使用的是Linux、Mac OS或Windows，那你应该可以很顺利地完成Go的安装。Go于今年上旬发布了第一个稳定版本Go 1，目前最新版本是1.0.2，可以从Google Code上的Go项目中下载。我的环境为Ubuntu 10.04 32-bit，下载go1.0.2.linux-386.tar.gz后，解压到/usr/local/go下面：

$ ls /usr/local/go
api/     bin/           doc/        include/  LICENSE  PATENTS    README        src/   VERSION
AUTHORS  CONTRIBUTORS  favicon.ico  lib/      misc/    pkg/    robots.txt  test/

然后将/usr/local/go/bin添加到你的PATH环境变量中，你就可以在任意目录下执行go程序了：

$ go version
go version go1.0.2

如果你得到上面的输出结果，可以断定你的Go安装成功了！

二、第一个Go程序 – Hello, Go!

我们建立一个用于编写Go程序的工作目录go-examples，其绝对路径为/home/tonybai/go-examples。好了，开始 编写我们的第一个Go程序。

我们在go-examples下创建一个文件hellogo.go，其内容如下：

package main

import (
    "fmt"
)

func main() {
    fmt.Printf("Hello, Go! ")
}

下面我们来编译该源文件并执行生成的可执行文件：

$ go build hellogo.go
$ ls
hellogo*  hellogo.go
$ hellogo
Hello, Go!

通过go build加上要编译的Go源文件名，我们即可得到一个可执行文件，默认情况下这个文件的名字为源文件名字去掉.go后缀。当然我们也 可以通过-o选项来指定其他名字：

$ go build -o myfirstgo hellogo.go
$ ls
myfirstgo*  hellogo.go

如果我们在go-examples目录下直接执行go build命令，后面不带文件名，我们将得到一个与目录名同名的可执行文件：

$ go build
$ ls
go-examples*  hellogo.go

三、程序入口点(entry point)和包(package)

Go保持了与C家族语言一致的风格：即目标为可执行程序的Go源码中务必要有一个名为main的函数，该函数即为可执行程序的入口点。除此之外 Go还增加了一个约束：作为入口点的main函数必须在名为main的package中。正如上面hellogo.go源文件中的那样，在源码第 一行就声明了该文件所归属的package为main。

Go去除了头文件的概念，而借鉴了很多主流语言都采用的package的源码组织方式。package是个逻辑概念，与文件没有一一对应的关系。 如果多个源文件都在开头声明自己属于某个名为foo的包，那这些源文件中的代码在逻辑上都归属于包foo(这些文件最好在同一个目录下，至少目前 的Go版本还无法支持不同目录下的源文件归属于同一个包)。

我们看到hellogo.go中import一个名为fmt的包，并利用该包内的Printf函数输出"Hello, Go!"。直觉告诉我们fmt包似乎是一个标准库中的包。没错，fmt包提供了格式化文本输出以及读取格式化输入的相关函数，与C中的printf或 scanf等类似。我们通过import语句将fmt包导入我们的源文件后就可以使用该fmt包导出(export)的功能函数了(比如 Printf)。

在C中，我们通过static来标识局部函数还是全局函数。而在Go中，包中的函数是否可以被外部调用，要看该函数名的首母是否为大写。这是一种 Go语言固化的约定：首母大写的函数被认为是导出的函数，可以被包之外的代码调用；而小写字母开头的函数则仅能在包内使用。在例子中你也看到了 fmt包的Printf函数其首母就是大写的。

四、GOPATH

我们把上面的hellogo.go稍作改造，拆分成两个文件：main.go和hello.go。

/* hello.go */
package hello

import "fmt"

func Hello(who string) {
    fmt.Printf("Hello, %s! ", who)
}

/* main.go */
package main

import (
    "hello"
)

func main() {
    hello.Hello("Go!")
}

用go build编译main.go，结果如下：

$ go build main.go
main.go:4:2: import "hello": cannot find package

编译器居然提示无法找到hello这个package，而hello.go中明明定义了package hello了。这是怎么回事呢？原来go compiler搜索package的方式与我们常规理解的有不同，Go在这方面也有一套约定，这里面涉及到一个重要的环境变量：GOPATH。我们可以使用go help gopath来查看一下有关gopath的manual。

Go compiler的package搜索顺序是这样的，以搜索hello这个package为例：

* 首先，Go compiler会在GO安装目录(GOROOT，这里是/usr/local/go)下查找是否有src/pkg/hello相关包源码；如果没有则继续；
* 如果export GOPATH=PATH1:PAHT2，则Go compiler会依次查找是否存在PATH1/src/hello、PATH2/src/hello；配置在GOPATH中的PATH1和PATH2被称作workplace；
* 如果在上述几个位置均无法找到hello这个package，则提示出错。

在本例子中，我们尚未设置过GOPATH环境变量，也没有建立类似PATH1/src/hello这样的路径，因此Go compiler显然无法找到hello这个package了。我们来设置一下GOPATH变量并建立相关目录：

$ export GOPATH=/home/tonybai/go-examples
$ mkdir src/hello
$ mv hello.go src/hello
$ go build main.go
$ ls
main*  main.go    src/
$ main
Hello, Go!

五、Go install

我们将main.go移到src/main中，这样这个demo project显得更加合理，所有源码均在src下：

$cd src
$ ls
hello/    main/

Go提供了install命令，与build命令相比，install命令在编译源码后还会将可执行文件或库文件安装到约定的目录下。我们以main目录为例：

$ cd main
$ go install

install命令执行后，我们发现main目录下没有任何变化，原先build时产生的main可执行文件也不见了踪影。别急，前面说过Go install也有一套自己的约定：
* go install(在src/DIR下)编译出的可执行文件以其所在目录名(DIR)命名
* go install将可执行文件安装到与src同级别的bin目录下，bin目录由go install自动创建
* go install将可执行文件依赖的各种package编译后，放在与src同级别的pkg目录下

现在我们来看看bin目录：
$ ls /home/tonybai/go-examples
bin/  src/ pkg/
$ ls bin
main*

的确出现一个bin目录，并且刚刚编译的程序main在bin下面。

hello.go编译后并非可执行程序，在编译main的同时，由于main依赖hello package，因此hello也被关联编译了。这与单独在hello目录下执行install的结果是一样的，我们试试：

$ cd hello
$ go install
$ ls /home/tonybai/go-examples
bin/  pkg/  src/

在我们的workspace(go-examples目录)下出现了一个pkg目录，pkg目录下是一个名为linux_386的子目录，其下面有一个文 件：hello.a。这就是我们install的结果。hello.go被编译为hello.a并安装到pkg/linux_386目录下了。

.a这个后缀名让我们想起了静态共享库，但这里的.a却是Go独有的文件格式，与传统的静态共享库并不兼容。但Go语言的设计者使用这个后缀名似乎是希望 这个.a文件也承担起Go语言中"静态共享库"的角色。我们不妨来试试，看看这个hello.a是否可以被Go compiler当作"静态共享库"来对待。我们移除src中的hello目录，然后在main目录下执行go build：

$ go build
main.go:4:2: import "hello": cannot find package

Go编译器提示无法找到hello这个包，可见目前版本的Go编译器似乎不理pkg下的.a文件。http://code.google.com/p/go/issues/detail?id=2775 这个issue也印证了这一点，不过后续Go版本很可能会支持链接.a文件。毕竟我们在使用第三方package的时候，很可能无法得到其源码，并且在每个项目中都保存一份第三方包的源码也十分不利于项目源码的后期维护。

六、像脚本一样运行Go源码

Go具有很高的编译效率，这得益于其设计者对该目标的重视以及设计过程中细节方面的把控，当然这不是本文要关注的话题。正是由于go具有极速的编译，我们才可以像使用运行脚本语言那样使用它。

目前Go提供了run命令来直接运行源文件。比如：

$ go run main.go
Hello, Go!

go run实际上是一个将编译源码和运行编译后的二进制程序结合在一起的命令。但目前go源文件尚不支持作成Shebang Script，因为Go compiler尚不识别#!符号，下面的源码文件运行起来会出错：

#! /usr/local/go/bin/go run

package main

import (
    "hello"
)

func main() {
    hello.Hello("Go!")
}

$ go run main.go
package :
main.go:1:1: illegal character U+0023 '#'

不过我们可以可借助一些第三方工具来运行Shebang Go scripts，比如gorun。

七、测试Go程序

前面说过Go起点较高，因此其自身就提供了一个轻量级单元测试框架包以及运行测试集的命令。

我们用一个例子来说明如何编写包的测试代码以及如何运行这个测试。我们在go-examples/src下建立另外一个目录mymath，mymath目录下mymath包的代码如下：

/* mymath.go */
package mymath

func MyAdd(i int, j int) int {
    return i + j
}

要对mymath包进行测试，我们需在同一目录下创建mymath_test.go文件，其中对MyAdd函数的测试代码如下：

/* mymath_test.go */
package mymath

import "testing"

func TestMyAdd(t *testing.T) {
    a, b := 4, 2
    if x := MyAdd(a, b); x != 6 {
        t.Errorf("MyAdd(%d, %d) = %d, want %d", a, b, x, 6)
    }
}

在这个文件中我们import了Go提供的标准单元测试包-testing，并且每个测试方法都已Test作为前缀开头。现在我们来运行一下这个测试，在mymath目录下运行go test命令：

$ go test
PASS
ok      mymath    0.007s

如果用例出错，我们就可看到下面提示：

$go test
— FAIL: TestMyAdd (0.00 seconds)
    mymath_test.go:8: MyAdd(4, 2) = 6, want 6
FAIL
exit status 1
FAIL    mymath    0.007s

由上可以看出，Go test也有自己的一些约定：测试源文件的名字必须以_test.go作为结尾；测试代码与被测代码在同一个包中；测试代码要导入testing包；测试 函数要以Test作为前缀，并且测试函数的函数签名必须是这样的：func TestXXX(t *testing.T)。

语言自带对测试的支持的好处是一致性，避免了大家使用不同的测试框架而给阅读、交流和维护带来的不便。

八、项目源码组织

有了源码、有了对编译原理的理解、有了测试框架的支持，我们就可以策划项目源码组织形式了。不过Go的诸多约定基本上已经将我们限制在如下结构上：

proj1/
    bin/
        myapp1*
    pkg/
        linux_386/
            lib1.a
            lib2.a
    src/
        lib1/
            lib1.go     
            lib1_test.go
        lib2/
            lib2.go     
            lib2_test.go
        … …
        myapp1/
            main.go       # main package source
            main_test.go  # test source

proj2/
    bin/
        myapp2*
    pkg/
        linux_386/
            lib3.a
            lib4.a
    src/
        lib3/
            lib3.go     
            lib3_test.go
        lib4/
            lib4.go     
            lib4_test.go
        … …
        myapp2/
            main.go       # main package source
            main_test.go  # test source

基于上述结构，我们可将GOPATH设置为proj1_path:proj2_path。

九、代码风格(coding style)

Go程序员可以不再纠结于到底使用哪种代码风格，因为Go已经将代码风格做了严格的约定，一旦违反，Compiler直接给出Error。go还提供了fmt命令来协助Go程序员按标准格式化源文件。

从上面例子中我们可以看到Go的几大风格特点是：

* 左大括号'{'一定在函数名或if等语句在同一行
   func foo {

   }

* 无需显式用分号;将语句分隔(除非是在一行写上多条语句)，因为compiler会替大家在适当位置加入分号的。
   i, j := 2, 3
   MyAdd(i, j)

   if x := MyAdd(a, b); x != 6 {
            … …
   }

* if、for等后面的表达式无需用小括号括上
  
   if x != 5 {
            … …
   }

十、查看文档

Go的全量文档几乎与Go安装包一起发布。安装Go后，执行godoc –http=:端口号即可启动doc server。打开浏览器，输入http://localhost:端口号即可以看到几乎与Go官方站完全相同的文档页面。

十一、参考书籍

Go毕竟是新生代语言，其自身尚不成熟和完善，资料也较少。这里推荐两本市面上比较好的且内容已更新到Go 1的书籍：

* Mark Summerfield的《Programming in Go: creating applications for the 21st century》
* Ivo Balbaert的《The Way to Go – A Thorough Introduction to the Go Programming Language》

vim Go 高亮

http://tonybai.com/2014/11/07/golang-development-environment-for-vim/

http://blog.csdn.net/delphiwcdj/article/details/40947885

Vim-go是当前使用最为广泛的用于搭建Golang开发环境的vim插件，这里我同样使用vim-go作为核心和基础进行环境搭建的。vim-go利 用开源Vim插件管理器安装，gmarik/Vundle.vim是目前被推荐次数更多的Vim插件管理器，超过了pathogen。这里我们 就用vundle来作为Vim的插件管理工具。

1、安装Vundle.vim

Vundle.vim的安装步骤如下：

mkdir ~/.vim/bundle
git clone https://github.com/gmarik/Vundle.vim.git ~/.vim/bundle/Vundle.vim                                                                      

创建~/.vimrc文件(如果你没有这个文件的话)，在文件顶部添加有关Vundle.vim的配置：

set nocompatible              " be iMproved, required
filetype off                  " required

" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()

" let Vundle manage Vundle, required
Plugin 'gmarik/Vundle.vim'

" All of your Plugins must be added before the following line
call vundle#end()            " required
filetype plugin indent on    " required

此时Vim仅安装了Vundle.vim这一个插件。编辑hellogolang.go时与编辑普通文本文件无异，一切都还是Vim的默认属性。

2、安装Vim-go

编辑~/.vimrc，在vundle#begin和vundle#end间增加一行：

Plugin 'fatih/vim-go'

在Vim内执行 :P luginInstall，

Vundle.vim会在左侧打开一个Vundle Installer Preview子窗口，窗口下方会提示：“Processing 'fatih/vim-go'”，待安装完毕后，提示信息变 成“Done!”。

这时，我们可以看到.vim/bundle下多了一个vim-go文件夹：

$ ls .vim/bundle/
vim-go/  Vundle.vim/

此时，再次编辑hellogolang.go，语法高亮有了， 保存时自动format（利用$GOBIN/gofmt）也有了，但其他高级功能，比如自动import缺失的 package、自动补齐仍然没有，我们还要继续安装一些东东。

根据Vundle的安装说明，首先安装Vundle：

$ git clone https://github.com/gmarik/Vundle.vim.git ~/.vim/bundle/Vundle.vim

然后对.vimrc进行配置，将Vundle的相关配置置在最开始处，下面只显示关于Vundle的相关配置：

[cpp] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. " -------------  
  2. " Vundle  
  3. " https://github.com/gmarik/Vundle.vim   
  4. " -------------  
  5.   
  6. set nocompatible              " be iMproved, required  
  7. filetype off                  " required  
  8.   
  9. " set the runtime path to include Vundle and initialize  
  10. set rtp+=~/.vim/bundle/Vundle.vim  
  11. call vundle#begin()  
  12. " alternatively, pass a path where Vundle should install plugins  
  13. "call vundle#begin('~/some/path/here')  
  14.   
  15. " let Vundle manage Vundle, required  
  16. Plugin 'gmarik/Vundle.vim'  
  17.   
  18. " The following are examples of different formats supported.  
  19. " Keep Plugin commands between vundle#begin/end.  
  20. " plugin on GitHub repo  
  21. ""Plugin 'tpope/vim-fugitive'  
  22. " plugin from http://vim-scripts.org/vim/scripts.html   
  23. ""Plugin 'L9'  
  24. " Git plugin not hosted on GitHub  
  25. ""Plugin 'git://git.wincent.com/command-t.git'  
  26. " git repos on your local machine (i.e. when working on your own plugin)  
  27. ""Plugin 'file:///home/gmarik/path/to/plugin'  
  28. " The sparkup vim script is in a subdirectory of this repo called vim.  
  29. " Pass the path to set the runtimepath properly.  
  30. ""Plugin 'rstacruz/sparkup', {'rtp': 'vim/'}  
  31. " Avoid a name conflict with L9  
  32. ""Plugin 'user/L9', {'name': 'newL9'}  
  33.   
  34. " Install Vim-go  
  35. Plugin 'fatih/vim-go'  
  36.   
  37. " All of your Plugins must be added before the following line  
  38. call vundle#end()            " required  
  39. filetype plugin indent on    " required  
  40. " To ignore plugin indent changes, instead use:  
  41. "filetype plugin on  
  42. "  
  43. " Brief help  
  44. " :PluginList       - lists configured plugins  
  45. " :PluginInstall    - installs plugins; append `!` to update or just :PluginUpdate  
  46. " :PluginSearch foo - searches for foo; append `!` to refresh local cache  
  47. " :PluginClean      - confirms removal of unused plugins; append `!` to auto-approve removal  
  48. "  
  49. " see :h vundle for more details or wiki for FAQ  
  50. " Put your non-Plugin stuff after this line  
" -------------
" Vundle
" https://github.com/gmarik/Vundle.vim
" -------------

set nocompatible              " be iMproved, required
filetype off                  " required

" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" alternatively, pass a path where Vundle should install plugins
"call vundle#begin('~/some/path/here')

" let Vundle manage Vundle, required
Plugin 'gmarik/Vundle.vim'

" The following are examples of different formats supported.
" Keep Plugin commands between vundle#begin/end.
" plugin on GitHub repo
""Plugin 'tpope/vim-fugitive'
" plugin from http://vim-scripts.org/vim/scripts.html
""Plugin 'L9'
" Git plugin not hosted on GitHub
""Plugin 'git://git.wincent.com/command-t.git'
" git repos on your local machine (i.e. when working on your own plugin)
""Plugin 'file:///home/gmarik/path/to/plugin'
" The sparkup vim script is in a subdirectory of this repo called vim.
" Pass the path to set the runtimepath properly.
""Plugin 'rstacruz/sparkup', {'rtp': 'vim/'}
" Avoid a name conflict with L9
""Plugin 'user/L9', {'name': 'newL9'}

" Install Vim-go
Plugin 'fatih/vim-go'

" All of your Plugins must be added before the following line
call vundle#end()            " required
filetype plugin indent on    " required
" To ignore plugin indent changes, instead use:
"filetype plugin on
"
" Brief help
" :PluginList       - lists configured plugins
" :PluginInstall    - installs plugins; append `!` to update or just :PluginUpdate
" :PluginSearch foo - searches for foo; append `!` to refresh local cache
" :PluginClean      - confirms removal of unused plugins; append `!` to auto-approve removal
"
" see :h vundle for more details or wiki for FAQ
" Put your non-Plugin stuff after this line

其中，配置中的 Plugin 'fatih/vim-go' 告诉Vundle我们想要安装vim-go这个插件，安装方法如下：

先用vim打开任意一个go源文件（假如之前并未配置过GoLang开发环境，确保~/.vim/syntax下没有使用vim.go，打开go的源文件后不会有对应的语法显示），例如，hello.go。然后使用命令 :PluginInstall 就可以安装vim-go了，安装成功后会在最下面显示Done的字样。

安装好插件后，再次用vim打开hello.go文件就可以看到vim-go插件已经生效了。

Go语言极速入门手册.go

http://blog.coderzh.com/2015/09/28/go-tips/ 

 Go lang 使用 protobuf

go get -u github.com/golang/protobuf/{proto,protoc-gen-go}

https://github.com/golang/protobuf

一、三种不同的导入方式，对应三种不同使用内部方法的方式：

  import "lib/math"      math.Sin 
  import M "lib/math"    M.Sin 
  import . "lib/math"    Sin

二、当引入某个包之后却没有对其的公开方法进行调用，则go编译过程会报错。有人会问，那有什么方式让我import只是为了初始化，但又不报错呢，官网上介绍如下方法：

import _ "lib/math"


我们传递ByteSlice的地址，是因为只有*ByteSlice才满足io.Writer。关于接收者对指针和值的规则是这样的，值方法可以在指针和值上进行调用，而指针方法只能在指针上调用。这是因为指针方法可以修改接收者；使用拷贝的值来调用它们，将会导致那些修改会被丢弃。

 Vim还可以配合gocode支持输入提示功能。接下来我们简单地配置一下。

首先获取gocode：
$ go get -u github.com/nsf/gocode
这个命令会下载gocode相应内容到Go的安装目录去（比如/usr/local/go），因此需要保证有目录的
写权限。然后开始配置gocode：
$ cd /usr/local/go/src/pkg/github.com/nsf/gocode/
$ cd vim
$ ./update.bash
配置就是这么简单。现在使用以下Vim的语法提示效果。用Vim创建一个新的Go文件（比如
命名为auto.go），输入以下内容：
package main
import "fmt"
func main() {
fmt.Print
请将光标停在 fmt.Print 后面，然后按组合键Ctrl+X+O（三个键同时按住后放开），你会看
到 fmt 包里的所有3个以 Print 开头的全局函数都被列了出来： Print 、 Printf 和 Println 。之
后就可以用上下方向键选取，按回车键即可完成输入，非常方便。

go语言中int类型和string类型都是属于基本数据类型

两种类型的转化都非常简单

下面为大家提供两种int类型转化成string类型的方法！

go语言的类型转化都在strconv package里面，详情请参考：

http://golang.org/pkg/strconv

下面附上转化代码:

[java] view plaincopyprint?
 
  1. package main  
  2.   
  3. import (  
  4.     "fmt"  
  5.     "strconv"  
  6. )  
  7.   
  8. var i int = 10  
  9.   
  10. func main() {  
  11.     // 通过Itoa方法转换  
  12.     str1 := strconv.Itoa(i)  
  13.   
  14.     // 通过Sprintf方法转换  
  15.     str2 := fmt.Sprintf("%d", i)  
  16.   
  17.     // 打印str1  
  18.     fmt.Println(str1)  
  19.     // 打印str2  
  20.     fmt.Println(str2)  
  21. }  


%d代表Integer

package main

import (
    "fmt"
)

func slice_demo(s []int) {
    fmt.Println("Slice In Func(1):", s)
    s[0] = 100 
    fmt.Println("Slice In Func(2):", s)
}

func map_demo(m map[string]string) {
    fmt.Println("Map In Func(1):", m)
    m["O"] = "Orange"
    fmt.Println("Map In Func(2):", m)
}

func main() {
    s := []int{1, 2, 3, 4, 5}
    fmt.Println("Slice Out Func(1):", s)
    slice_demo(s)
    fmt.Println("Slice Out Func(2):", s)

    fmt.Println()
    //map
    m := map[string]string{
        "A": "Apple",
        "B": "Banana",
        "C": "Cucumber",
    }   
    fmt.Println("Map Out Func(1):", m)
    map_demo(m)
    fmt.Println("Map Out Func(2):", m)

}

输出

Slice Out Func(1): [1 2 3 4 5]
Slice In Func(1): [1 2 3 4 5]
Slice In Func(2): [100 2 3 4 5]
Slice Out Func(2): [100 2 3 4 5]

Map Out Func(1): map[A:Apple B:Banana C:Cucumber]
Map In Func(1): map[A:Apple B:Banana C:Cucumber]
Map In Func(2): map[C:Cucumber O:Orange A:Apple B:Banana]
Map Out Func(2): map[O:Orange A:Apple B:Banana C:Cucumber]

go里面值类型,表现出引用语义的东西有
slice,map,interface,chan

Go 语言中的 Array，Slice，Map 和 Set   http://se77en.cc/2014/06/30/array-slice-map-and-set-in-golang/

在 GOLANG 中用名字调用函数

2012/07/12  10条评论

上个星期，我写了篇《Function call by name in Golang》。由于是英文的，所以被人诟病（说谁，谁知道！）。好吧，现在用中文重新写一遍。

Golang 中的函数跟 C 的一样，是个代码块，不过它可以像其他类型那样赋值给一个变量。

如果你对函数不熟悉，《Codewalk: First-Class Functions in Go》应该是个不错的起点。已经有所了解？那么继续吧！

首先，来看看这段 PHP 代码：

function foobar() {
    echo "Hello Golang ";
}
$funcs = array(
    "foobar" => "foobar",
    "hello"  => "foobar",
);
$funcs["foobar"]();
$funcs["hello"]();

它会输出：

mikespook@mikespook-laptop:~/Desktop$ php foobar.php
Hello Golang
Hello Golang

用这个方法调用匹配名字的函数，非常有效。

那么，在 Golang 中是否可能用函数的名字来调用某个函数呢？

作为一个静态、编译型语言，答案是否定的……又是肯定的！

在 Golang 中，你不能这样做：

func foobar() {
    // bla...bla...bla...
}
funcname := "foobar"
funcname()

不过可以：

func foobar() {
    // bla...bla...bla...
}
funcs := map[string]func() {"foobar":foobar}
funcs["foobar"]()

但这里有一个限制：这个 map 仅仅可以用原型是“func()”的没有输入参数或返回值的函数。
如果想要用这个方法实现调用不同函数原型的函数，需要用到 interface{}。

是啊！interface{}，跟 C 中的 void 指针类似。还记得这个东西吗？不记得了？没事，看看这个吧：《The Go Programming Language Specification:Interface types》。

这样，就可以添加有着不同函数原型的函数到一个 map 中：

func foo() {
    // bla...bla...bla...
}
func bar(a, b, c int) {
    // bla...bla...bla...
}
funcs := map[string]interface{}{"foo":foo,"bar":bar}

那么如何调用 map 中的函数呢？像这样吗：

funcs["foo"]()

绝对不行！这无法工作！你不能直接调用存储在空接口中的函数。

反射走进我们的生活！在 Golang 中有着叫做“reflect”的包。你是否了解反射了呢？
如果还没有，那么阅读一下这个：《Laws of reflection》吧。哦，这里有个中文版本：《反射的规则》。

func Call(m map[string]interface{}, name string, params ... interface{}) (result []reflect.Value, err error) {
    f = reflect.ValueOf(m[name])
    if len(params) != f.Type().NumIn() {
        err = errors.New("The number of params is not adapted.")
        return
    }
    in := make([]reflect.Value, len(params))
    for k, param := range params {
        in[k] = reflect.ValueOf(param)
    }
    result = f.Call(in)
    return
}
Call(funcs, "foo")
Call(funcs, "bar", 1, 2, 3)

将函数的值从空接口中反射出来，然后使用 reflect.Call 来传递参数并调用它。
没有什么是很难理解的。

我已经完成了一个包来实现这个功能，在这里：https://bitbucket.org/mikespook/golib/src/27c65cdf8a77/funcmap.

gocode 这个就不用说了，必备利器，实现Golang的代码自动补全，好处你懂的。  https://github.com/nsf/gocode

golang 环境配置建议（Atom）http://my.oschina.net/wxfvm/blog/380243

go 环境安装

这一部分是最重要的，如果没有它，每次build的时候出现 too many errors 心里真的是非常难过的。

  1. 环境配置：（golint,gooracle,mercurial）

    1. 安装mercurial: brew install mercurial

      这个东西是用来做版本管理的，也是下载代码的工具类似git，貌似google的项目用的挺多的。

    2. 安装golint：

$ go get github.com/golang/lint$ 
go install github.com/golang/lint

  1. 安装gooracle

go get code.google.com/p/go.tools/cmd/oracle

  1. 安装goimport

go get golang.org/x/tools/cmd/goimports

  1. 安装gocode

  
go get -u github.com/nsf/gocode

  1. 安装 godef

go get -v code.google.com/p/rog-go/exp/cmd/godef
go install -v code.google.com/p/rog-go/exp/cmd/godef

    1. 安装环境的时候经常会出现下载不下来的问题，大概是我网络不好吧。连接google经常出现问题。

      解决方案：
      golang中国的下载频道中有一个第三方包的下载工具，只要输入地址之后人家会给你提供下载tar包的。
      放到gopath中就ok了。
      此步骤只能替代go get的步骤，最后还是需要go install

    2. go install 之后会在  $GOPATH/bin/ 中出现各种工具文件

      最后不要忘记复制上面的命令到 $GOROOT/bin/下面

      1. gocode 提供代码补全

      2. godef 代码跳转

      3. gofmt 自动代码整理

      4. golint 代码语法检查

      5. goimports 自动整理imports

      6. oracle 代码callgraph查询（plugin中还在todolist中，但是不配置一直报错。实在烦。）

3、安装go.tools Binaries

vim-go安装说明中提到所有必要的binary需要先安装好，比如gocode、godef、goimports等。

通过:GoInstallBinaries，这些vim-go依赖的二进制工具将会自动被下载，并被安装到$GOBIN下或$GOPATH/bin下。（这个工具需要依赖git或hg，需要提前安装到你的OS中。）

:GoInstallBinaries的执行是交互式的，你需要回车确认：

vim-go: gocode not found. Installing github.com/nsf/gocode to folder /home/tonybai/go/bin
vim-go: goimports not found. Installing code.google.com/p/go.tools/cmd/goimports to folder /home/tonybai/go/bin/
vim-go: godef not found. Installing code.google.com/p/rog-go/exp/cmd/godef to folder /home/tonybai/go/bin/
vim-go: oracle not found. Installing code.google.com/p/go.tools/cmd/oracle to folder /home/tonybai/go/bin/
vim-go: gorename not found. Installing code.google.com/p/go.tools/cmd/gorename to folder /home/tonybai/go/bin/
vim-go: golint not found. Installing github.com/golang/lint/golint to folder /home/tonybai/go/bin/
vim-go: errcheck not found. Installing github.com/kisielk/errcheck to folder /home/tonybai/go/bin/

不过这些代码多在code.google.com上托管，因此由于众所周知的原因，vim-go的自动安装很可能以失败告终，这样就需要你根据上 面日志中提到的各个工具的源码地址逐一去下载并本地安装。无法搭梯子的，可以通过http://gopm.io 下载相关包。

安装后，$GOBIN下的新增Binaries如下：
-rwxr-xr-x  1 tonybai tonybai  5735552 11??  7 11:03 errcheck*
-rwxr-xr-x  1 tonybai tonybai  9951008 11??  7 10:33 gocode*
-rwxr-xr-x  1 tonybai tonybai  5742800 11??  7 11:07 godef*
-rwxr-xr-x  1 tonybai tonybai  4994120 11??  7 11:00 goimports*
-rwxr-xr-x  1 tonybai tonybai  5750152 11??  7 11:03 golint*
-rwxr-xr-x  1 tonybai tonybai  6381832 11??  7 11:01 gorename*
-rwxr-xr-x  1 tonybai tonybai  2954392 11??  7 10:38 gotags*
-rwxr-xr-x  1 tonybai tonybai  9222856 11??  7 11:01 oracle*

安装好这些Binaries后，我们来看看哪些特性被支持了。

再次编辑hellogolang.go：

         - 新起一行输入fmt.，然后ctrl+x, ctrl+o，Vim 会弹出补齐提示下拉框，不过并非实时跟随的那种补齐，这个补齐是由gocode提供的。
    – 输入一行代码：time.Sleep(time.Second)，执行:GoImports，Vim会自动导入time包。
    – 将光标移到Sleep函数上，执行:GoDef或命令模式下敲入gd，Vim会打开$GOROOT/src/time/sleep.go中 的Sleep函数的定义。执行:b 1返回到hellogolang.go。
    – 执行:GoLint，运行golint在当前Go源文件上。
    – 执行:GoDoc，打开当前光标对应符号的Go文档。
    – 执行:GoVet，在当前目录下运行go vet在当前Go源文件上。
    – 执行:GoRun，编译运行当前main package。
    – 执行:GoBuild，编译当前包，这取决于你的源文件，GoBuild不产生结果文件。
    – 执行:GoInstall，安装当前包。
    – 执行:GoTest，测试你当前路径下地_test.go文件。
    – 执行:GoCoverage，创建一个测试覆盖结果文件，并打开浏览器展示当前包的情况。
    – 执行:GoErrCheck，检查当前包种可能的未捕获的errors。
    – 执行:GoFiles，显示当前包对应的源文件列表。
    – 执行:GoDeps，显示当前包的依赖包列表。
    – 执行:GoImplements，显示当前类型实现的interface列表。
    – 执行:GoRename [to]，将当前光标下的符号替换为[to]。

 redigo 操作hmset 的例子   http://studygolang.com/topics/826  https://github.com/garyburd/redigo/issues/21

c, err := dial()
if err != nil {
    panic(err)
}
defer c.Close()

var p1, p2 struct {
    Title  string `redis:"title"`
    Author string `redis:"author"`
    Body   string `redis:"body"`
}

p1.Title = "Example"
p1.Author = "Gary"
p1.Body = "Hello"

if _, err := c.Do("HMSET", redis.Args{}.Add("id1").AddFlat(&p1)...); err != nil {
    panic(err)
}

m := map[string]string{
    "title":  "Example2",
    "author": "Steve",
    "body":   "Map",
}

if _, err := c.Do("HMSET", redis.Args{}.Add("id2").AddFlat(m)...); err != nil {
    panic(err)
}

for _, id := range []string{"id1", "id2"} {

    v, err := redis.Values(c.Do("HGETALL", id))
    if err != nil {
        panic(err)
    }

    if err := redis.ScanStruct(v, &p2); err != nil {
        panic(err)
    }

    fmt.Printf("%+v
", p2)
}

golang闭包里的坑

 2015-08-30 16:54   sunshine-anycall
 阅读 531 次  
 

介绍

go的闭包是一个很有用的东西。但是如果你不了解闭包是如何工作的，那么他也会给你带来一堆的bug。这里我会拿出Go In Action这本书的一部分代码，来说一说在使用闭包的时候可能遇到的坑。全部的代码在github上。

闭包的坑

首先看一段代码：

search/search.go

29  // Launch a goroutine for each feed to find the results.
30  for _, feed := range feeds {
31     // Retrieve a matcher for the search.
32     matcher, exists := matchers[feed.Type]
33     if !exists {
34        matcher = matchers["default"]
35     }
36
37     // Launch the goroutine to perform the search.
38     go func(matcher Matcher, feed *Feed) {
39        Match(matcher, feed, searchTerm, results)
40        waitGroup.Done()
41     }(matcher, feed)
42  }

这段代码从30行开始遍历一个Feed的slice。在for range语句中声明的feed变量的值在每一个循环中都不同。之后从32行的代码在检查一个某个特定的key值是否有值，如果不存在则赋一个默认值。和feed变量一样，matcher的值也是每个循环都不一样。

现在我们可以跳到38行到41行。这几行代码显然还是在for range循环中的。这里我们定义了一个匿名函数，并把这个函数做为一个goroutine运行。这个匿名函数接受两个参数，第一个是Matcher类型的值，第二个是一个Feed类型的指针。在地41行，我们可以蛋刀matcher和feed两个变量被传入了匿名函数中。

这个匿名函数在第39行的实现很有意思。这里我们可以看到一个对Match方法的调用。这个方法接受4个参数，如果你仔细看的话，前两个参数就是我们定义匿名函数声明的而两个参数。后面的两个我们没有在匿名函数中声明。而是作为变量直接在匿名函数使用了。

search/search.go

37     // Launch the goroutine to perform the search.
38     go func(matcher Matcher, feed *Feed) {
39        Match(matcher, feed, searchTerm, results)
40        waitGroup.Done()
41     }(matcher, feed)
42  }

变量searchTerm和results是定义在闭包外部的。我们可以在匿名函数内部直接使用，而不必作为参数传入后再使用。这里就会有一个问题：我们为什么要把变量matcher和feed作为参数传入而其他的两个不是呢？

我在一开始就指出，matcher和feed两个变量的值是如何在每一个for range循环中改变的。searchTerm和results的值不会随着循环而改变，他们的值在每一个goroutine的生命周期中都是常量。当然，这个goroutine就是使用的匿名函数。那么，为什么要这么做呢？

当我们在匿名函数闭包中使用一个变量的时候，我们不必在匿名函数声明的时候作为参数传递。这个匿名函数闭包可以直接访问到定义在其外部的变量，也就是说对这个变量的修改会在匿名函数闭包内部体现出来，也就是这里的goroutine。如果我们把matcher和feed变量这样使用，而不是把他们作为参数传入匿名函数闭包。那么多数情况下gotoutine只会处理for range循环的最后一个值。

在这个例子中，所有的goroutine都会并发执行。for range循环也许在第一个最多第二个goroutine还在运行的时候就运行完了，matcher和feed变量只会有最后一次循环时候的值。也就是说即使不是全部的goroutine也是大部分的goroutine会处理这些变量的相同的值。这种情况适用于searchTerm和results变量，因为他们不会在循环中改变值。

结论

幸好我们可以声明可以接收参数的匿名函数，这些类型的闭包问题也就引刃而解。在我们上面的例子中，当每一个匿名函数都声明在for range的作用域内的时候，matcher和feed变量的值在作为参数传入匿名函数闭包的时候也就同时被锁定。在使用闭包访问外部变量的时候，问问你自己这个变量时候会发生改变，这样的改变对闭包的运行有什么影响。

Go中error类型的nil值和nil    http://my.oschina.net/chai2010/blog/117923

先看C语言中的类似问题：空字符串。

const char* empty_str0 = "";
const char* empty_str1 = "empty";
const char* empty_str2 = NULL;

以上3个字符串并不相等，但是从某种角度看，它们都是对应空的字符串。

  • empty_str0 指向一个空的字符串，但是empty_str0本身的值是有效的。
  • empty_str1 指向一个非空的字符串，但是字符串的第一个字符是''。
  • empty_str2 本身是一个空的指针。

Go的error是一个interface类型，error的nil问题和C语言的字符串类似。

参考官方的error文档说明：

在底层，interface作为两个成员实现：一个类型和一个值。该值被称为接口的动态值， 它是一个任意的具体值，而该接口的类型则为该值的类型。对于 int 值3， 一个接口值示意性地包含(int, 3)。

只有在内部值和类型都未设置时(nil, nil)，一个接口的值才为 nil。特别是，一个 nil 接口将总是拥有一个 nil 类型。若我们在一个接口值中存储一个 int 类型的指针，则内部类型将为 int，无论该指针的值是什么：(*int, nil)。 因此，这样的接口值会是非 nil 的，即使在该指针的内部为 nil。

下面是一个错误的错误返回方式：

func returnsError() error {
    var p *MyError = nil
    if bad() {
        p = ErrBad
    }
    return p // Will always return a non-nil error.
}

这里 p 返回的是一个有效值（非nil），值为 nil。 
类似上面的 empty_str0。

因此，下面判断错误的代码会有问题：

func main() {
    if err := returnsError(); err != nil {
        panic(nil)
    }
}

针对 returnsError 的问题，可以这样处理（不建议的方式）：

func main() {
    if err := returnsError(); err.(*MyError) != nil {
        panic(nil)
    }
}

在判断前先将err转型为*MyError，然后再判断err的值。 
类似的C语言空字符串可以这样判断：

bool IsEmptyStr(const char* str) {
    return !(str && str[0] != '');
}

但是Go语言中标准的错误返回方式不是returnsError这样。 
下面是改进的returnsError：

func returnsError() error {
    if bad() {
        return (*MyError)(err)
    }
    return nil
}

因此，在处理错误返回值的时候，一定要将正常的错误值转换为 nil。

比如，syscall中就有一个bug是由于没有处理好error导致的：

// syscall: (*Proc).Call always returns non-nil err
// http://code.google.com/p/go/issues/detail?id=4686
package main

import "syscall"

func main() {
    h := syscall.MustLoadDLL("kernel32.dll")
    proc := h.MustFindProc("GetVersion")
    r, _, err := proc.Call()
    major := byte(r)
    minor := uint8(r >> 8)
    build := uint16(r >> 16)
    print("windows version ", major, ".", minor, " (Build ", build, ")
")
   if err != nil {
       e := err.(syscall.Errno)
       println(err.Error(), "errno =", e)
   }
}

目前issues4686这个bug已经在修复中。

作为用户，临时可以用前面的方法回避这个bug：

// Issue 4686: syscall: (*Proc).Call always returns non-nil err
// https://code.google.com/p/go/issues/detail?id=4686
func call(h *syscall.LazyDLL, name string,
    a ...uintptr) (r1, r2 uintptr, err error) {
    r1, r2, err = h.NewProc(name).Call(a...)
    if err.(syscall.Errno) == 0 {
        return r1, r2, nil
    }
    return
}

Go作为一个强类型语言，不同类型之前必须要显示的转换（而且必须是基础类型相同）。 
这样可以回避很多类似C语言中因为隐式类型转换引入的bug。

但是，Go中interface是一个例外：type到interface和interface之间可能是隐式转换的。 
或许，这是Go做得不太好的地方吧。

go build -gcflags "-N -l"

Go 语言中的方法，接口和嵌入类型  

http://se77en.cc/2014/05/05/methods-interfaces-and-embedded-types-in-golang/

http://www.goinggo.net/2014/05/methods-interfaces-and-embedded-types.html

概述

在 Go 语言中，如果一个结构体和一个嵌入字段同时实现了相同的接口会发生什么呢？我们猜一下，可能有两个问题：

  • 编译器会因为我们同时有两个接口实现而报错吗？
  • 如果编译器接受这样的定义，那么当接口调用时编译器要怎么确定该使用哪个实现？

在写了一些测试代码并认真深入的读了一下标准之后，我发现了一些有意思的东西，而且觉得很有必要分享出来，那么让我们先从 Go 语言中的方法开始说起。

方法

Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。

下面定义一个结构体类型和该类型的一个方法：

1
2
3
4
5
6
type User struct {
Name string
Email string
}
 
func (u User) Notify() error

首先我们定义了一个叫做 User 的结构体类型，然后定义了一个该类型的方法叫做 Notify，该方法的接受者是一个 User 类型的值。要调用Notify 方法我们需要一个 User 类型的值或者指针：

1
2
3
4
5
6
7
// User 类型的值可以调用接受者是值的方法
damon := User{"AriesDevil", "ariesdevil@xxoo.com"}
damon.Notify()
 
// User 类型的指针同样可以调用接受者是值的方法
alimon := &User{"A-limon", "alimon@ooxx.com"}
alimon.Notify()

在这个例子中当我们使用指针时，Go 调整和解引用指针使得调用可以被执行。注意，当接受者不是一个指针时，该方法操作对应接受者的值的副本(意思就是即使你使用了指针调用函数，但是函数的接受者是值类型，所以函数内部操作还是对副本的操作，而不是指针操作，参见：http://play.golang.org/p/DBhWU0p1Pv)。

我们可以修改 Notify 方法，让它的接受者使用指针类型：

1
func (u *User) Notify() error

再来一次之前的调用(注意：当接受者是指针时，即使用值类型调用那么函数内部也是对指针的操作，参见：http://play.golang.org/p/SYBb4xPfPh)：

1
2
3
4
5
6
7
// User 类型的值可以调用接受者是指针的方法
damon := User{"AriesDevil", "ariesdevil@xxoo.com"}
damon.Notify()
 
// User 类型的指针同样可以调用接受者是指针的方法
alimon := &User{"A-limon", "alimon@ooxx.com"}
alimon.Notify()

如果你不清楚到底什么时候该使用值，什么时候该使用指针作为接受者，你可以去看一下这篇介绍。这篇文章同时还包含了社区约定的接受者该如何命名。

接口

Go 语言中的接口很特别，而且提供了难以置信的一系列灵活性和抽象性。它们指定一个特定类型的值和指针表现为特定的方式。从语言角度看，接口是一种类型，它指定一个方法集，所有方法为接口类型就被认为是该接口。

下面定义一个接口：

1
2
3
type Notifier interface {
Notify() error
}

我们定义了一个叫做 Notifier 的接口并包含一个 Notify 方法。当一个接口只包含一个方法时，按照 Go 语言的约定命名该接口时添加 -er后缀。这个约定很有用，特别是接口和方法具有相同名字和意义的时候。

我们可以在接口中定义尽可能多的方法，不过在 Go 语言标准库中，你很难找到一个接口包含两个以上的方法。

实现接口

当涉及到我们该怎么让我们的类型实现接口时，Go 语言是特别的一个。Go 语言不需要我们显式的实现类型的接口。如果一个接口里的所有方法都被我们的类型实现了，那么我们就说该类型实现了该接口。

让我们继续之前的例子，定义一个函数来接受任意一个实现了接口 Notifier 的类型的值或者指针：

1
2
3
func SendNotification(notify Notifier) error {
return notify.Notify()
}

SendNotification 函数调用 Notify 方法，这个方法被传入函数的一个值或者指针实现。这样一来一个函数就可以被用来执行任意一个实现了该接口的值或者指针的指定的行为。

用我们的 User 类型来实现该接口并且传入一个 User 类型的值来调用 SendNotification 方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func (u *User) Notify() error {
log.Printf("User: Sending User Email To %s<%s> ",
u.Name,
u.Email)
return nil
}
 
func main() {
user := User{
Name: "AriesDevil",
Email: "ariesdevil@xxoo.com",
}
 
SendNotification(user)
}
 
// Output:
cannot use user (type User) as type Notifier in function argument:
User does not implement Notifier (Notify method has pointer receiver)

详细代码：http://play.golang.org/p/KG8-Qb7gqM

为什么编译器不考虑我们的值是实现该接口的类型？接口的调用规则是建立在这些方法的接受者和接口如何被调用的基础上。下面的是语言规范里定义的规则，这些规则用来说明是否我们一个类型的值或者指针实现了该接口：

  • 类型 *T 的可调用方法集包含接受者为 *T 或 T 的所有方法集

这条规则说的是如果我们用来调用特定接口方法的接口变量是一个指针类型，那么方法的接受者可以是值类型也可以是指针类型。显然我们的例子不符合该规则，因为我们传入 SendNotification 函数的接口变量是一个值类型。

  • 类型 T 的可调用方法集包含接受者为 T 的所有方法

这条规则说的是如果我们用来调用特定接口方法的接口变量是一个值类型，那么方法的接受者必须也是值类型该方法才可以被调用。显然我们的例子也不符合这条规则，因为我们 Notify 方法的接受者是一个指针类型。

语言规范里只有这两条规则，我通过这两条规则得出了符合我们例子的规则：

  • 类型 T 的可调用方法集不包含接受者为 *T 的方法

我们碰巧赶上了我推断出的这条规则，所以编译器会报错。Notify 方法使用指针类型作为接受者而我们却通过值类型来调用该方法。解决办法也很简单，我们只需要传入 User 值的地址到 SendNotification 函数就好了：

1
2
3
4
5
6
7
8
9
10
11
func main() {
user := &User{
Name: "AriesDevil",
Email: "ariesdevil@xxoo.com",
}
 
SendNotification(user)
}
 
// Output:
User: Sending User Email To AriesDevil<ariesdevil@xxoo.com>

详细代码：http://play.golang.org/p/kEKzyTfLjA

嵌入类型

结构体类型可以包含匿名或者嵌入字段。也叫做嵌入一个类型。当我们嵌入一个类型到结构体中时，该类型的名字充当了嵌入字段的字段名。

下面定义一个新的类型然后把我们的 User 类型嵌入进去：

1
2
3
4
type Admin struct {
User
Level string
}

我们定义了一个新类型 Admin 然后把 User 类型嵌入进去，注意这个不叫继承而叫组合。 User 类型跟 Admin 类型没有关系。

我们来改变一下 main 函数，创建一个 Admin 类型的变量并把变量的地址传入 SendNotification 函数中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func main() {
admin := &Admin{
User: User{
Name: "AriesDevil",
Email: "ariesdevil@xxoo.com",
},
Level: "master",
}
 
SendNotification(admin)
}
 
// Output
User: Sending User Email To AriesDevil<ariesdevil@xxoo.com>

详细代码：http://play.golang.org/p/ivzzzk78TC

事实证明，我们可以 Admin 类型的一个指针来调用 SendNotification 函数。现在 Admin 类型也通过来自嵌入的 User 类型的方法提升实现了该接口。

如果 Admin 类型包含了 User 类型的字段和方法，那么它们在结构体中的关系是怎么样的呢？

当我们嵌入一个类型，这个类型的方法就变成了外部类型的方法，但是当它被调用时，方法的接受者是内部类型(嵌入类型)，而非外部类型。— Effective Go

因此嵌入类型的名字充当着字段名，同时嵌入类型作为内部类型存在，我们可以使用下面的调用方法：

1
2
3
4
admin.User.Notify()
 
// Output
User: Sending User Email To AriesDevil<ariesdevil@xxoo.com>

详细代码：http://play.golang.org/p/0WL_5Q6mao

这儿我们通过类型名称来访问内部类型的字段和方法。然而，这些字段和方法也同样被提升到了外部类型：

1
2
3
4
admin.Notify()
 
// Output
User: Sending User Email To AriesDevil<ariesdevil@xxoo.com>

详细代码：http://play.golang.org/p/2snaaJojRo

所以通过外部类型来调用 Notify 方法，本质上是内部类型的方法。

下面是 Go 语言中内部类型方法集提升的规则：

给定一个结构体类型 S 和一个命名为 T 的类型，方法提升像下面规定的这样被包含在结构体方法集中：

  • 如果 S 包含一个匿名字段 T，S 和 *S 的方法集都包含接受者为 T 的方法提升。

这条规则说的是当我们嵌入一个类型，嵌入类型的接受者为值类型的方法将被提升，可以被外部类型的值和指针调用。

  • 对于 *S 类型的方法集包含接受者为 *T 的方法提升

这条规则说的是当我们嵌入一个类型，可以被外部类型的指针调用的方法集只有嵌入类型的接受者为指针类型的方法集，也就是说，当外部类型使用指针调用内部类型的方法时，只有接受者为指针类型的内部类型方法集将被提升。

  • 如果 S 包含一个匿名字段 *T，S 和 *S 的方法集都包含接受者为 T 或者 *T 的方法提升

这条规则说的是当我们嵌入一个类型的指针，嵌入类型的接受者为值类型或指针类型的方法将被提升，可以被外部类型的值或者指针调用。

这就是语言规范里方法提升中仅有的三条规则。

回答开头的问题

现在我们可以写程序来回答开头提出的两个问题了，首先我们让 Admin 类型实现 Notifier 接口：

1
2
3
4
5
6
7
func (a *Admin) Notify() error {
log.Printf("Admin: Sending Admin Email To %s<%s> ",
a.Name,
a.Email)
 
return nil
}

Admin 类型实现的接口显示一条 admin 方面的信息。当我们使用 Admin 类型的指针去调用函数 SendNotification 时，这将帮助我们确定到底是哪个接口实现被调用了。

现在创建一个 Admin 类型的值并把它的地址传入 SendNotification 函数，来看看发生了什么：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func main() {
admin := &Admin{
User: User{
Name: "AriesDevil",
Email: "ariesdevil@xxoo.com",
},
Level: "master",
}
 
SendNotification(admin)
}
 
// Output
Admin: Sending Admin Email To AriesDevil<ariesdevil@xxoo.com>

详细代码：http://play.golang.org/p/JGhFaJnGpS

预料之中，Admin 类型的接口实现被 SendNotification 函数调用。现在我们用外部类型来调用 Notify 方法会发生什么呢：

1
2
3
4
admin.Notify()
 
// Output
Admin: Sending Admin Email To AriesDevil<ariesdevil@xxoo.com>

详细代码：http://play.golang.org/p/EGqK6DwBOi

我们得到了 Admin 类型的接口实现的输出。User 类型的接口实现不被提升到外部类型了。

现在我们有了足够的依据来回答问题了：

  • 编译器会因为我们同时有两个接口实现而报错吗？

不会，因为当我们使用嵌入类型时，类型名充当了字段名。嵌入类型作为结构体的内部类型包含了自己的字段和方法，且具有唯一的名字。所以我们可以有同一接口的内部实现和外部实现。

  • 如果编译器接受这样的定义，那么当接口调用时编译器要怎么确定该使用哪个实现？

如果外部类型包含了符合要求的接口实现，它将会被使用。否则，通过方法提升，任何内部类型的接口实现可以直接被外部类型使用。

总结

在 Go 语言中，方法，接口和嵌入类型一起工作方式是独一无二的。这些特性可以帮助我们像面向对象那样组织结构然后达到同样的目的，并且没有其它复杂的东西。用本文中谈到的语言特色，我们可以以极少的代码来构建抽象和可伸缩性的框架

Golang实现带优先级的channel  http://blog.123hurray.tk/2015/10/29/golang_priority_channel/

http://stackoverflow.com/questions/11117382/priority-in-go-select-statement-workaround

一般Go语言同时使用多个channel的方法是使用select/case语句配合<-操作符，比如

select {
case <- chan1:
    // do something
case <- chan2:
    // do something
}

但是这种实现方式下chan1和chan2是同等优先级的。如果要实现带优先级的channel则需要用到defalut语句。

在go语言中，如果select/case中没有default子句，则程序会阻塞在select中，直到其中一个case语句接收到了数据。 如果有default语句，则不会阻塞，如果case接收到数据，就执行case中的语句，如果case未收到信号，则会执行defalut中的语句，随后跳出select块。

使用这个特性可以实现带优先级的channel队列。以2个优先级的channel举例，实现方法是使用多层select，将高优先级channel放在最外层select语句的case后，并跟上一个default语句以免当高优先级的channel没有数据时阻塞。 defalut内依然是一个select语句，在这个select语句中，将高优先级和低优先级的case都放入，并且没有default语句。这样内层select就会阻塞直到其中一个case收到数据。

这种实现方式相当于高优先级的channel比低优先级的多了一次被处理的机会，即外层select，只有高优先级没有数据时，才会执行内层select，此时先产生数据的channel先被执行。

也就是说，当高优先级和低优先级都有数据时，高优先级先被处理，也就是实现了优先级。示例如下：

package main

import "fmt"

func sender(out chan int, exit chan bool) {
    for i := 1; i <= 10; i++ {
        out <- i
    }
    exit <- true
}

func main() {
    out := make(chan int, 10)
    exit := make(chan bool)

    go sender(out, exit)

    for {
        select {
        case i := <-out:
            fmt.Printf("Value: %d
", i)
            continue
        default:
        }
        select {
        case i := <-out:
            fmt.Printf("Value: %d
", i)
            continue
        case <-exit:
            fmt.Println("Exiting")
        }
        break
    }
    fmt.Println("Did we get all 10? I think so!")
}
for {
    select {
    case data := <- highChan:
        handleHigh(data)
    default:
        select {
        case data := <- highChan:
            handleHigh(data)
        case data := <- lowChan:
            handleLow(data)
        }
    }
}

 A "break" statement terminates execution of the innermost "for", "switch" or "select" statement.  http://stackoverflow.com/questions/11104085/in-go-does-a-break-statement-break-from-a-switch-select

channel默认上是阻塞的，也就是说，如果Channel满了，就阻塞写，如果Channel空了，就阻塞读。阻塞的含义就是一直等到轮到它为止。单有时候我们会收到 fatal error: all goroutines are asleep - deadlock!  异常，这是如何呢？

代码例子：

package main

import "fmt"

func main() { 
    channel := make(chan string, 2)

    fmt.Println("1") 
    channel <- "h1" 
    fmt.Println("2") 
    channel <- "w2" 
    fmt.Println("3") 
    channel <- "c3"    // 执行到这一步，直接报 error 
    fmt.Println("...") 
    msg1 := <-channel 
    fmt.Println(msg1) 
}

执行效果：

image

参考：

http://stackoverflow.com/questions/26927479/go-language-fatal-error-all-goroutines-are-asleep-deadlock

fatal error: all goroutines are asleep - deadlock!

出错信息的意思是： 
在main goroutine线，期望从管道中获得一个数据，而这个数据必须是其他goroutine线放入管道的 
但是其他goroutine线都已经执行完了(all goroutines are asleep)，那么就永远不会有数据放入管道。 
所以，main goroutine线在等一个永远不会来的数据，那整个程序就永远等下去了。 
这显然是没有结果的，所以这个程序就说“算了吧，不坚持了，我自己自杀掉，报一个错给代码作者，我被deadlock了”

这里是系统自动在除了主协程之外的协程都关闭后，做的检查，继而报出的错误， 证明思路如下， 在100秒内， 我们看不到异常， 100秒后，系统报错。

package main

import ( 
    "fmt" 
    "time" 
)

func main() { 
    channel := make(chan string, 2)

    go func() { 
        fmt.Println("sleep 1") 
        time.Sleep(100 * time.Second) 
        fmt.Println("sleep 2") 
    }()

    fmt.Println("1") 
    channel <- "h1" 
    fmt.Println("2") 
    channel <- "w2"

    fmt.Println("3") 
    channel <- "c3"

    fmt.Println("...") 
    msg1 := <-channel 
    fmt.Println(msg1) 
}

100秒内执行效果截图：

image

100秒后执行效果截图：

image

如果避免上面异常抛出呢？这时候我们可以用 select来帮我们处理。

package main

import "fmt"

func main() { 
    channel := make(chan string, 2)

    fmt.Println("1") 
    channel <- "h1" 
    fmt.Println("2") 
    channel <- "w2"

    fmt.Println("3") 
    select {

    case channel <- "c3": 
        fmt.Println("ok") 
    default: 
        fmt.Println("channel is full !") 
    }

    fmt.Println("...") 
    msg1 := <-channel 
    fmt.Println(msg1) 
}

执行效果：

image

这时候，我们把第三个要写入的 chan 抛弃了。

上面的例子中是写的例子， 读的例子也一样，下面的异常是  ws := <-channel 这一行抛出的。

channel := make(chan string, 2)

fmt.Println("begin") 
ws := <-channel 
fmt.Println(ws)

image

http://eleme.io/blog/2014/goroutine-1/    channel 详解

无缓冲的信道永远不会存储数据，只负责数据的流通，为什么这么讲呢？

  • 从无缓冲信道取数据，必须要有数据流进来才可以，否则当前线阻塞

  • 数据流入无缓冲信道, 如果没有其他goroutine来拿走这个数据，那么当前线阻塞

所以，你可以测试下，无论如何，我们测试到的无缓冲信道的大小都是0 (len(channel))

如果信道正有数据在流动，我们还要加入数据，或者信道干涩，我们一直向无数据流入的空信道取数据呢？ 就会引起死锁

死锁

一个死锁的例子:

func main() {
    ch := make(chan int)
    <- ch // 阻塞main goroutine, 信道c被锁
}

执行这个程序你会看到Go报这样的错误:

fatal error: all goroutines are asleep - deadlock!

何谓死锁? 操作系统有讲过的，所有的线程或进程都在等待资源的释放。如上的程序中, 只有一个goroutine, 所以当你向里面加数据或者存数据的话，都会锁死信道， 并且阻塞当前 goroutine, 也就是所有的goroutine(其实就main线一个)都在等待信道的开放(没人拿走数据信道是不会开放的)，也就是死锁咯。

Go的pprof使用  http://www.cnblogs.com/yjf512/archive/2012/12/27/2835331.html

多路复合

上面的例子都使用一个信道作为返回值，可以把信道的数据合并到一个信道的。 不过这样的话，我们需要按顺序输出我们的返回值（先进先出）。

如下，我们假设要计算很复杂的一个运算 100-x , 分为三路计算， 最后统一在一个信道中取出结果:

func do_stuff(x int) int { // 一个比较耗时的事情，比如计算
    time.Sleep(time.Duration(rand.Intn(10)) * time.Millisecond) //模拟计算
    return 100 - x // 假如100-x是一个很费时的计算
}

func branch(x int) chan int{ // 每个分支开出一个goroutine做计算并把计算结果流入各自信道
    ch := make(chan int)
    go func() {
        ch <- do_stuff(x)
    }()
    return ch
}

func fanIn(chs... chan int) chan int {
    ch := make(chan int)

    for _, c := range chs {
        // 注意此处明确传值
        go func(c chan int) {ch <- <- c}(c) // 复合
    }

    return ch
}


func main() {
    result := fanIn(branch(1), branch(2), branch(3))

    for i := 0; i < 3; i++ {
        fmt.Println(<-result)
    }
}
go 并发   https://talks.golang.org/2012/concurrency.slide#1





反射中tag的使用：

    u := User{"Bob", "bob@mycompany.com"}
    t := reflect.TypeOf(u)

    for _, fieldName := range []string{"Name", "Email"} {
        field, found := t.FieldByName(fieldName)
        if !found {
            continue
        }   
        fmt.Printf("
Field: User.%s
", fieldName)
        fmt.Printf("	Whole tag value : %q
", field.Tag)
        fmt.Printf("	Value of 'mytag': %q
", field.Tag.Get("mytag"))
    }   
}

type User struct {
    Name  string `mytag:"MyName"`
    Email string `mytag:"MyEmail"`
}

golang 支持可变长参数

支持可变长参数列表的函数可以支持任意个传入参数，比如fmt.Println函数就是一个支持可变长参数列表的函数。

package main

import "fmt"

// 这个函数可以传入任意数量的整型参数
func sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

func main() {

    // 支持可变长参数的函数调用方法和普通函数一样
    // 也支持只有一个参数的情况
    sum(1, 2)
    sum(1, 2, 3)

    // 如果你需要传入的参数在一个切片中，像下面一样
    // "func(slice...)"把切片打散传入
    nums := []int{1, 2, 3, 4}
    sum(nums...)
}

输出结果为

[1 2] 3
[1 2 3] 6
[1 2 3 4] 10

需要注意的是，可变长参数应该是函数定义的最右边的参数，即最后一个参数。