五步让你成为GO 语言高手
francesc () 是 go 核心团队的一员, 是提倡 google cloud 平台的开发者. 他是一个编程语言的爱好者, google的技术指导大师, go tour的创造者之一. 这个讨论的灵感来自于另一个 raquel vélez 在 jsconf. slides 的讨论，这个讨论已经发到了.
sourcegraph 是下一代编程协作工具, 用于搜索, 探索, 和审查代码. 我们参加gophercon india 来分享我们是怎样使用 go 并学习别人是怎样使用它的, 对配合liveblog的这次讨论我们深感荣幸.
作为go团队的开发者之一，francesc可能比世界上其他人接触到的go语言程序员都要多。正因为有了这样的有利条件，他把go语言的学习过程划分为5个阶段。
这些阶段对于其他语言的学习也是成立的。理解自己处于哪个阶段，可以帮助你找到提高自己的最有效的方法，也可以避免每个阶段学习过程中的常见陷阱。
编者按：这篇文章对于每一个学习阶段都给出了交互式的代码片段。点击函数名你就可以跳到具体的函数定义，方便进行深入的研究。请看下文。
这里是go程序员的五个进化阶段:
: 刚刚学习了这门语言。 已经通过一些教程或者培训班了解基本的语法，可以写短的代码片段。
: 可以写一个完整的程序，但不懂一些更高级的语言特征，比如“channels”。还没有使用go写一个大项目。
: 你能熟练的使用go, 能够用go去解决，生产环境中一个具体和完整的问题。已经形成了一套自己的惯用法和常用代码库。在你的编码方案中go是一个非常好用的工具。
: 绝逼清楚go语言的设计选择和背后的动机。能理解的简洁和可组合性哲学。
: 积极地与他人分享关于go语言知识和你对go语言的理解。在各种合适的场所发出自己的声音, 参与邮件列表、建立qq群、做专题报告。成为一个布道者不见得是一个完全独立的阶段，这个角色可以在上述的任何一个阶段中。
第一阶段: 菜逼
菜鸟在这个阶段使用go去创建一些小项目或者玩具项目。他们应该会利用到go tour, go playground, go文档, 和邮件列表().
func main() {
fmt.println(stringutil.reverse("!selpmaxe og ,olleh"))}
这是go语言写的简单例子，这个代码段来自代码库里面的 hello.go 。 点击就可以查看完整代码撸。
一项重要的技能，新人应该试着学习如何正确提问。很多新人在邮件列表里面这样说“嘿，这报错了”，这并没有提供足够的信息，让别人能理解并帮助他们解决问题。别人看到的是一个粘贴了几百行的代码的帖子，并没有花费精力来重点说明所遇到的问题。
所以, 应该尽量避免直接粘贴代码到论坛。而应该使用可以编辑并且可以在浏览器中直接运行的go playground的“分享”按钮链接到代码片段。
phase 2: the explorer
探索者已经可以使用go写一些小的软件，但有时仍然会有些迷茫。他们可能不完全明白怎么使用go的高级特性，比如通道。虽然他们还有很多东西要学习，但已掌握的足够做一些有用的事情了！他们开始对go的潜能有感觉了，并对它们能使用go创建的东西感到兴奋。
在探索阶段通常会经历两个步骤。第一，膨胀的预期达到顶点，你觉得可以用go做所有的事情，但还并不能明白或领悟到go的真谛。你大概会用所熟悉的语言的模式和惯用语来写go代码，但对于什么是地道的go，还没有比较强烈的感觉。你开始尝试着手干这样的事情--“迁移架构x，从y语言到go语言”。
到达预期膨胀的顶点之后，你会遇到理想幻灭的低谷。你开始想念语言y的特性x，此时你还没有完全的掌握地道的go。你还在用其他编程语言的风格来写go语言的程序，你甚至开始觉得沮丧。你可能在大量使用reflect和unsafe这两个包，但这不是地道的go。地道的go不会使用那些魔法一样的东西。
这个探索阶段产生的项目的一个很好的例子就是martini web框架。martini是一个go语言的早期web框架，它从ruby的web框架当中吸收了很多思想（比如依赖注入）。最初，这个框架在社区中引起了强烈的反响，但是它逐渐在性能和可调试性上受到了一些批评。martini框架的作者jeremy saenz积极响应这些来自go社区的反馈，写了一个更加符合go语言规范的库negroni
func (m *martini) runonaddr(addr string) {
// todo: should probably be implemented using a new instance of http.server in place of
// calling http.listenandserver directly, so that it could be stored in the martini struct for later use.
// this would also allow to improve testing when a custom host and port are passed.
logger := m.injector.get(reflect.typeof(m.logger)).interface().(*log.logger)
logger.printf("listening on %s (%s)\n", addr, env)
logger.fatalln(http.listenandserve(addr, m))}
来自martini框架的交互式代码片段，它是不地道的go的例子。注意用反射包实现的依赖注入
func testnegroniservehttp(t *testing.t) {
result := ""
response := httptest.newrecorder()
n := new()
n.use(handlerfunc(func(rw http.responsewriter, r *http.request, next http.handlerfunc) {
result += "foo"
next(rw, r)
result += "ban"
}))
n.use(handlerfunc(func(rw http.responsewriter, r *http.request, next http.handlerfunc) {
result += "bar"
next(rw, r)
result += "baz"
}))
n.use(handlerfunc(func(rw http.responsewriter, r *http.request, next http.handlerfunc) {
result += "bat"
rw.writeheader(http.statusbadrequest)
}))
n.servehttp(response, (*http.request)(nil))
expect(t, result, "foobarbatbazban")
expect(t, response.code, http.statusbadrequest)}
来自negroni库的交互式代码片段，它是地道的go的例子
其他语言在提供一些核心功能，比如http处理的时候，往往需要依赖第三方库。但是go语言在这一点上很不同，它的标准库非常强大。如果你认为go标准库没有强大到可以做你想做的事情，那么我说你错了。go语言标准库难以置信的强大，值得你花时间阅读它的代码，学习它实现的模式。
func (srv *server) listenandserve() error {
addr := srv.addr
if addr == "" {
addr = ":http"
}
ln, err := net.listen("tcp", addr)
if err != nil {
return err
}
return srv.serve(tcpkeepalivelistener{ln.(*net.tcplistener)})}
go标准库中的listenandserve函数片段。如果你写过go程序，你可能已经调用过这个函数很多次了，但是你曾经花时间看过它的实现么？去点击上面的代码片段吧。
幻灭的低谷中的幻灭感来自于这样的事实：你还在用其他语言的模式来想问题，而且你还没有完全探索过go能提供给你什么。下面是一些好玩的事情，你可以做一下来打破困境，进一步探索这门语言中好玩的事。
go generate
现在来看看go generate。go generate是一个你可以用来自动自成go代码的命令。你可以结合例如jsonenums(一个用于为枚举类型自动生成json编组样板代码的类库)这样的元编程来使用go generate快速自动实现重复乏味代码的编写。在go标准类库里面已经有大量可以用于解析ast的接口，而ast使得编写元编程工具更简单，更容易。在会议上，有另外两次讨论（go语言中的元编程实践和）谈及到了这一点。
func main() {
flag.parse()
if len(*typenames) == 0 {
log.fatalf("the flag -type must be set")
}
types := strings.split(*typenames, ",")
// only one directory at a time can be processed, and the default is ".".
dir := "."
if args := flag.args(); len(args) == 1 {
dir = args[0]
} else if len(args) > 1 {
log.fatalf("only one directory at a time")
}
pkg, err := parser.parsepackage(dir, *outputsuffix+".go")
if err != nil {
log.fatalf("parsing package: %v", err)
}
var analysis = struct {
command string
packagename string
typesandvalues map[string][]string
}{
command: strings.join(os.args[1:], " "),
packagename: pkg.name,
typesandvalues: make(map[string][]string),
}
// run generate for each type.
for _, typename := range types {
values, err := pkg.valuesoftype(typename)
if err != nil {
log.fatalf("finding values for type %v: %v", typename, err)
}
analysis.typesandvalues[typename] = values
var buf bytes.buffer
if err := generatedtmpl.execute(&buf, analysis); err != nil {
log.fatalf("generating code: %v", err)
}
src, err := format.source(buf.bytes())
if err != nil {
// should never happen, but can arise when developing this code.
// the user can compile the output to see the error.
log.printf("warning: internal error: invalid go generated: %s", err)
log.printf("warning: compile the package to analyze the error")
src = buf.bytes()
}
output := strings.tolower(typename + *outputsuffix + ".go")
outputpath := filepath.join(dir, output)
if err := ioutil.writefile(outputpath, src, 0644); err != nil {
log.fatalf("writing output: %s", err)
}
}}
一段互动的片段演示了如何编写jsonenums命令。
opengl
许多人使用go作web服务，但是你知道你也可以用go写出很cool的图形应用吗？查看go在opengl中的捆绑。
func main() {
glfw.seterrorcallback(errorcallback)
if !glfw.init() {
panic("can't init glfw!")
}
defer glfw.terminate()
window, err := glfw.createwindow(width, height, title, nil, nil)
if err != nil {
panic(err)
}
window.makecontextcurrent()
glfw.swapinterval(1)
gl.init()
if err := initscene(); err != nil {
fmt.fprintf(os.stderr, "init: %s\n", err)
return
}
defer destroyscene()
for !window.shouldclose() {
drawscene()
window.swapbuffers()
glfw.pollevents()
}}
交互式的片段正说明go的opengl捆绑能制作gopher cube。点击函数或方法名去探索。
黑客马拉松和挑战
你也可以观看挑战和黑客马拉松，类似gopher gala和go challenge。在过去，来自世界各地的程序员一起挑战一些真实的酷项目，你可以从中获取灵感。
第三阶段: 老手
作为一个老手，这意味着你可以解决很多go语言中你关心的问题。新的需要解决的问题会带来新的疑问，经过试错，你学会了在这门语言中什么是可以做的，什么是不能做的。此时，你已经对这门语言的习惯和模式有了一个坚实的理解。你可以非常高效地工作，写出可读，文档完善，可维护的代码。
成为老手的一个很好的方法就是在大项目上工作。如果你自己有一个项目的想法，开始动手去做吧（当然你要确定它并不是已经存在了）。大多数人也许并没有一个很大的项目的想法，所以他们可以对已经存在的项目做出贡献。go语言已经有很多大型项目，而且它们正在被广泛使用，比如docker, kubernetes和go本身。可以看看这个项目列表
func (cli *dockercli) cmdrestart(args ...string) error {
cmd := cli.subcmd("restart", "container [container...]", "restart a running container", true)
nseconds := cmd.int([]string{"t", "-time"}, 10, "seconds to wait for stop before killing the container.")
cmd.require(flag.min, 1)
utils.parseflags(cmd, args, true)
v := url.values{}
v.set("t", strconv.itoa(*nseconds))
var encounterederror error
for _, name := range cmd.args() {
_, _, err := readbody(cli.call("post", "/containers/"+name+"/restart?"+v.encode(), nil, false))
if err != nil {
fmt.fprintf(cli.err, "%s\n", err)
encounterederror = fmt.errorf("error: failed to restart one or more containers")
} else {
fmt.fprintf(cli.out, "%s\n", name)
}
}
return encounterederror}
docker项目的交互式代码片段。点击函数名，开始探索之旅吧。
老手应该对go生态系统的工具有一个很强的掌握，因为这些工具真的提高生产效率。你应该了解go generate，go vet，go test-race， 和gofmt/goimports/goreturns。你应该使用go fmt，因为它会自动把你的代码按照go社区的风格标准来格式化。goimports可以做同样的事情，而且还会添加丢失的imports。goretures不光做了前面所说的事情，还可以在返回表达式添加丢失的错误，这是大家都讨厌的地方。
在老手阶段，你一定要开始做code review。code review的意义并不是要修改或者找到错误（那是测试人员做的事情）。code review可以帮助维持统一的编程风格，提高软件的总体质量，还可以在别人的反馈中提高你自己的编程技术。几乎所有的大型开源项目都对每一个提交做code review。
下面是一个从人类的反馈当中学习的例子：google的go团队以前都在main函数的外面声明命令行标记。在去年的gophercon会议上，francesc遇到了soundcloud公司的peter bourgon（@peterbourgon）。peter bourgon说在soundcloud，他们都在main函数内部声明标记，这样他们不会错误地在外部使用标记。francesc现在认为这是最佳实践。
第四阶段：专家
作为一个专家，你很好地了解了语言的哲学思想。对于go语言的特性，你知道何时应该使用，何时不应该使用。例如，jeremy saenz在dotgo风暴讨论中谈论到了何时不该使用接口。
func (client *client) go(servicemethod string, args interface{}, reply interface{}, done chan *call) *call {
call := new(call)
call.servicemethod = servicemethod
call.args = args
call.reply = reply
if done == nil {
done = make(chan *call, 10) // buffered.
} else {
// if caller passes done != nil, it must arrange that
// done has enough buffer for the number of simultaneous
// rpcs that will be using that channel. if the channel
// is totally unbuffered, it's best not to run at all.
if cap(done) == 0 {
log.panic("rpc: done channel is unbuffered")
}
}
call.done = done
client.send(call)
return call}
来自标准类库的一小块交互代码片段使用了频道。理解标准类库里面的模式背后的决策原因是成为一个专家必经之路。
但是不要成为只局限于单一语言的专家。跟其他任何语言一样，go仅仅只是一个工具。你还应该去探索其他语言，并且学习他们的模式和风格。francesc从他使用go的经验中找到了编写javascript的启发。他还喜欢重点关注于不可变性和致力于避免易变性的haskell语言，并从中获得了如何编写go代码的灵感。
布道者
作为一个布道者，你分享自己的知识，传授你学会的和你提出的最佳实践。你可以分享自己对go喜欢或者不喜欢的地方。全世界各地都有go会议，。
你可以在任何一个阶段成为布道者，不要等到你成为这个领域的专家的时候才发出自己的声音。在你学习go的任何一个阶段，提出问题，结合你的经验给出反馈，不要羞于提出自己不喜欢的地方。你提出的反馈可以帮助社区改善做事情的方法，也可能改变你自己对编程的看法。
func main() {
httpaddr := flag.string("http", "127.0.0.1:3999", "http service address (e.g., '127.0.0.1:3999')")
originhost := flag.string("orighost", "", "host component of web origin url (e.g., 'localhost')")
flag.stringvar(&basepath, "base", "", "base path for slide template and static resources")
flag.boolvar(&present.playenabled, "play", true, "enable playground (permit execution of arbitrary user code)")
nativeclient := flag.bool("nacl", false, "use native client environment playground (prevents non-go code execution)")
flag.parse()
if basepath == "" {
p, err := build.default.import(basepkg, "", build.findonly)
if err != nil {
fmt.fprintf(os.stderr, "couldn't find gopresent files: %v\n", err)
fmt.fprintf(os.stderr, basepathmessage, basepkg)
os.exit(1)
}
basepath = p.dir
}
err := inittemplates(basepath)
if err != nil {
log.fatalf("failed to parse templates: %v", err)
}
ln, err := net.listen("tcp", *httpaddr)
if err != nil {
log.fatal(err)
}
defer ln.close()
_, port, err := net.splithostport(ln.addr().string())
if err != nil {
log.fatal(err)
}
origin := &url.url{scheme: "http"}
if *originhost != "" {
origin.host = net.joinhostport(*originhost, port)
} else if ln.addr().(*net.tcpaddr).ip.isunspecified() {
name, _ := os.hostname()
origin.host = net.joinhostport(name, port)
} else {
reqhost, reqport, err := net.splithostport(*httpaddr)
if err != nil {
log.fatal(err)
}
if reqport == "0" {
origin.host = net.joinhostport(reqhost, port)
} else {
origin.host = *httpaddr
}
}
if present.playenabled {
if *nativeclient {
socket.runscripts = false
socket.environ = func() []string {
if runtime.goarch == "amd64" {
return environ("goos=nacl", "goarch=amd64p32")
}
return environ("goos=nacl")
}
}
playscript(basepath, "sockettransport")
http.handle("/socket", socket.newhandler(origin))
}
http.handle("/static/", http.fileserver(http.dir(basepath)))
if !ln.addr().(*net.tcpaddr).ip.isloopback() &&
present.playenabled && !*nativeclient {
log.print(localhostwarning)
}
log.printf("open your web browser and visit %s", origin.string())
log.fatal(http.serve(ln, nil))
流行的present命令的main函数，很多go的用户使用它来制作幻灯片。许多演讲者修改了这个模块来满足自己的需要。
q&a
问：在go语言中，我所怀念的一项功能是一个好的调试器。
答：我们正在做了，不只是调试器，我们还会提供一个更好的总体监视工具可以让你在程序运行时更好地洞察程序在干什么(显示出所有正在运行的goroutine的状态)。在go 1.5中探索它吧。
以上所述就是本文的全部内容了，希望大家能够喜欢。