本文可以随意转载，转载请标明作者和来源。
引子
本文题目凸显一个‘怪’字，怪即为奇异，Go语言很多特点和特性可称之为奇异，掌握了这些奇异之处，我们自然也就了解了Go语言的精髓。
概述
Go语言作为一门新时代的编译语言，以排山倒海之势迅速占领后台服务开发阵地，在C++标准委员会急不可耐的把原本就极其复杂的C++语言用C++11变的更加复杂以后，作为面向过程、面向对象、泛型编程语言的C++逐渐被追求最新技术的程序员所抛弃，而Go语言以其无比简单的语法，极其高效的运行效率获得了越来越多人的亲睐，Go语言原生支持并发的特性使其在现今的并行计算时代更具有非凡意义。
本文主旨
本文主要通过简单的几个例子的介绍，为读者构建一个Go语言的基本印象，本文不是Go语言教程，作者在这里仅用调侃的态度来给没有接触过Go语言的读者提供一些Go语言特性的信息，希望在看到这些特性后，我能欣喜的看到有人可以捧起书真正进入Go语言的世界。
第一怪：老朽伪装小鲜肉
这么是说谁呢，其实呢，我去搜索Go语言介绍的时候，惊人的发现一个萌萌的年轻人坐在那里，然后我就以为这样一个小鲜肉竟然发明了Go语言，真是“江山代有才人出，后浪死在沙滩上”。但是别急，再继续搜索后我发现，Go语言的创造者罗布·派克（Rob Pike）其实早就名声斐然，出生于1965年的他并不年轻，他可是UTF-8设计者，同时罗布·派克跟Unix渊源极深，他和Ken Thompson以及 Dennis M.Ritche一起开发了Unix操作系统，作为资深Geek，罗布·派克不忘在体育界刷存在感，他在1980年奥运会上转了一圈，拿了个射箭银牌。闲着没事他还在天文学那边儿插一脚，真是程序员大师中的一朵奇葩。
顺便说一句，由于Go语言在Google大行其势，原来的香饽饽Python之父吉多·范罗苏姆（Guido Van Rossum） 于2012年底黯然离开谷歌加入到了Dropbox，这也暗示着python时代将要终结，Go语言的时代正在到来。
第二怪：强迫症晚期谁来救
我们正式进入到Go语言的世界，看看Go语言的一些特性，首先以一个例子开头：
package main
import(
"os"//@1：先import进来，一会儿就发力
"fmt"
)
func main()
{//@2：还是换个行吧，这样看起来帅帅的
x := 1//@3：我先占个座，一会来自习
fmt.Println("我是第一个go程序")
}
这是我们的第一个例子，对于熟悉其他语言的人来说，这看起来是一个最正常不过的例子，但是其实这个例子中有三处语法错误，你们先找茬，我先简单介绍一下Go语言的基本语法，文件开头一般要命名一个包名（package），相同包名即是一家子，如果有package main即为主执行程序，通过go install命令即可进行安装，生成可执行二进制，第二行的import说明需要import的包，如果只有一行可以使用类似import "fmt"这种语法，这个程序的例子多个import括号方式会比较简洁，Go语言的函数是以func开始，局部变量使用:=运算符时，编译器可以自动推导出变量的类型。说了这么多，我们该把语法错误指出来了，@1这一处错误是因为，在程序文件中，根本没有使用os包的位置，由于其多余，Go语言强行定义其为语法错误；@2这一处更加体现了罗布·派克强迫症晚期患者的症状，他要求如第7行的大括号必须紧跟在main（）的后面，否则就是语法错误；@3和@1类似，这是变量级别的使用要求，不允许任何变量定义未使用。
罗布·派克定义了大量的规则用来保证程序员少犯错，这大概是其见过太多C和C++过于自由的导致其难用的最痛的领悟吧。
第三怪：匿名字段真不赖
直接上例子：
package main
import "fmt"
type Human struct{
name string
age int
weight int
}
type Student struct{
Human //@1
speciality string
}
func main(){
mark := Student{Human{"Mark", 25, 120}, "e-commerce"}
fmt.Println(mark.name, mark.age, mark.weight, mark.speciality)//@2
}
这个例子讲的是Go语言中的struct，Go语言的struct和C++的class比较相似，但是你们可能会奇怪第@1行的Human是要闹哪样，你的对象呢，你的对象呢？其实这里就到Go语言中的匿名字段的神奇之处了。在讲匿名字段之前，需要解释个事情，Go语言变量命名方式是绝无仅有的奇葩，聪明的你应该已经发现了，这里面变量都是在类型前面，导致如果你给变量附初值时会出现var i int=8这种看起来很欠揍的语法，不过用习惯也就没什么了，语言本身就是一堆规则，大师制定规则，码农按照规则拉磨。
我们言归正传，继续讲struct，匿名字段其实相当于在Student使用Human类型时，默认编译器将Human自动展开，我们看第@2行即可以发现Human.name直接过继给了Student，匿名字段就是可以把儿子变孙子，这种奇葩的事情罗布.派克不是首创，咱们中国老祖宗唐德宗就有认自己的孙子为儿子的事儿，这里面有啥八卦隐情这里不表，估计罗布.派克也不知道这事儿。有的人可能一定要问了，如果俩孙子重名可咋办，万一孙子跟儿子重名不也乱套了么，这个你不用着急，如果发生这种情况，编译器还是会及时发现，星星还是那颗星星，儿子还是那个儿子，具体可以做实验去体验吧。
第四怪：interface你陷害
Go语言的interface可以说是面向对象设计中极其巧妙的实现，其隐含接口实现不但使得代码简洁，同时内容组织无与伦比的方便。继续读代码说话：
package main
import(
"fmt"
"math"
)
type geometry interface {
area() float64
perim() float64
}
type square struct{
width, height float64
}
func (s square) area() float64{
return s.width * s.height
}
func (s square) perim() float64{
return 2*s.width + 2*s.height
}
type circle struct{
radius float64
}
func (c circle) area() float64{
return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64{
return 2*math.Pi*c.radius
}
func measure(g geometry){
fmt.Println(g)
fmt.Println(g.area())
fmt.Println(g.perim())
}
func main(){
c := circle{radius:3}
s := square{width:4.0, height:5.0}
measure(c)
measure(s)
}
这个例子略长，前面介绍的struct我们现在已经熟悉了，重点看一下interface的定义和实现。我们可以看到一个geometry interface的定义，这个接口里定义了area和perim两个方法。重点看一下成员函数的实现方法，Go语言成员函数与struct也是松耦合的，这里我们要重点关注的是括号，以square的area方法为例，我先看第一个括号，我们把类型square s称为这个方法接收者，其实就是C++的成员函数的不同表征方法，在python中，一般是用传入self来实现的。第二括号才是方法自己的括号，这里我们没有带参数，最后一个float64是返回值类型，如果有多个返回值需要用括号括起来。那么问题来了，一个成员方法你最多可以看到多少括号，其实可能不止三个，但是会有三部分。
到此有人可能会问了，interface你陷害，你瞎掰吧，说了这么多，还不说陷害的事儿。我们言归正传，为什么说interface陷害呢，因为一个struct的方法只要实现了interface的方法组合，那么Go语言就认为我们实现了这个接口，这中关联是隐式的，也就是说，你写了一个struct，实现了一堆方法，可能你就顺便实现了另外一堆接口，这些接口可能连你都不知道。我们看measure方法定义，其接受的参数是一个geometry接口，可以直接传入circle和square对象，因为这两个struct都实现了area和perim方法，那么他们就实现了geometry接口，这两个struct啥都没说，就被陷害说他们实现了geometry接口。
实际上在fmt.Println接收的参数就是不定长interface参数Stringer，其定义为：type Stringer interface { String() string }，由此我们可以看出，只要你的struct实现了String方法，那么你就实现了Stringer接口，也就是说，这样你就可以打印这个struct对象了，这有点儿类似Java中的toString，但是实现的优雅程度就是云泥之别了。顺便说一句，所有的类型都实现了空接口interface{}，也就是说，如果一个函数参数为空接口interface{}类型，那么这个函数可以接受任何参数，这有点儿像C语言的void，但是Go语言要更加强大。
interface的设计是Go语言的神来之笔，使用过程中你会越来越体会到interface之精妙。
第五怪：加锁啥的都狗带
通过通信来共享内存，而非通过共享内存来通信，Go语言原生支持并发，并通过goroutine和channel将并发编程的简洁性和高效性体现的淋漓尽致，我们再也不用担心加锁问题了，在程序员上空死锁的阴云散去（其实还是会写出死锁的程序，具体可以查找相关聊），抬头再看，并发编程一片晴空。我们以生产者消费者问题举例，我们会发现gorutine实现并发是怎样一种优雅：
package main
import "fmt"
import "time"
func producer(id int, item chan int) {
for i := 0; i < 10; i++ {
item <- i
fmt.Printf("producer %d produces data: %d\n", id, i)
time.Sleep(1*time.Second)
}
}
func consumer(id int, item chan int) {
for i := 0; i < 20; i++ {
c_item := <-item
fmt.Printf("consumer %d get data: %d\n", id, c_item)
time.Sleep(1*time.Second)
}
}
func main() {
item := make(chan int, 6)//@1
go producer(1, item)
go producer(2, item)
go consumer(1, item)
time.Sleep(30 * time.Second)//等待其他goroutine都执行完退出
}
我们看@1行，我们通过make语法建立了一个缓冲为6的int管道，生产者只需要关心生产，把生产好的数据直接扔进管道，消费者呢，不用关心生产者的任何细节，只需要从管道里取数据，生产端和消费端都是阻塞的，当管道为空时，消费端阻塞，当管道满时，生产端阻塞。关键字go定义我们新开了一个goroutine，每个goroutine你可以理解成线程，但是goroutine更加轻量和高效，一个程序起成千上万个goroutine毫无压力。
我们刚刚看到有缓冲channel类似于消息队列的神勇表现，接下来我们看看无缓冲channel在多个goroutine同步的精彩演绎：
package main
import "fmt"
func fibonacci(c, quit chan int){
x,y := 1,1
for{
select{
case c<-x:
x,y = y,x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main(){
c := make(chan int)
quit := make(chan int)
go func(){
for i:=0; i<10; i++{
fmt.Println(<-c)
}
quit <-0
}()
fibonacci(c, quit)
}
我们这个程序用了一个select关键字，没错，这个select的作用跟网络通信模型的select非常相似，select监听channel中的数据流，默认select是阻塞的，当管道中有发送或者接收行为时，select才会执行，当有多个管道都准备好时，select会从中随机取一个执行，这个程序我们不需要用time.Sleep等待其他goroutine退出，在quit管道被写入0之后，select侦测到，执行case <-quit后程序退出。
Go语言并发编程有效利用多核CPU，把比thread更加轻量、高效的goroutine与管道相结合，极度优雅的实现数据共享和同步，加锁什么的确实可以狗带了。
第六怪：静态编译没依赖
动态链接库在计算机的蛮荒年代起了非常大的作用，那时的内存还是论K的，硬盘是论M的，动态链接库可以在不同进程间通过共享代码来节省内存，使用动态链接库编译出的二进制也非常小，这就使得磁盘空间使用和拷贝代价很低。但是动态链接库的缺点也是显而易见的，甚至因为动态链接库过于混乱产生了专门的名词，相关性依赖地狱（dependence hell），不同程序之间的依赖让无数程序员彻夜调试，而动态链接库给我们带来的好处在今天看来实在是不值得的，它为我们节省的内存和磁盘空间实在微不足道，动态链接冲突导致的问题跟带来的好处比起来就太大了，可以说，现在如果还抱着动态链接库不放就是丢西瓜捡芝麻完全是得不偿失。
Go语言作者罗布·派克显然也看到了这一点，他的解决方案非常简单，二进制不依赖任何动态链接库，所有的编译都是静态链接，我们再也不用担心换了一台机器运行程序无法执行的问题了，这种做法只是损失了很少的内存和磁盘空间，但是带来整体性（integrity）的极大好处。
第七怪：编码运行真是快
有人把Go语言称为21世纪的C语言，跟C语言相比，Go语言的运行效率当之无愧，但是如果把C语言的编码效率与Go语言相比，C语言会被甩出好几条街，可以这么说，Go语言是python和C的合体，它兼顾了C语言的运行效率和python的编码效率。Go语言的关键字只有25个，Go语言的所有循环的写法只有一个for把其他语言的while、foreach等一堆乱七八糟的命名整合成一个，使用极其简洁。其运行效率到底有多高呢，下图是benchmarksgame网站上对比Go语言和C执行不同算法执行效率，除了个别算法运行效率差别较大，大部分算法Go语言执行效率跟C相差可以忽略不计。
我们这种对比虽然可能不一定公平，我们可以直观上感受Go语言运行的高效。
第八怪：异常处理没有try
“作为现代编程语言一枚，try-catch都没有，你还想让我在编程界混么”，Go语言的内心OS一定是这样。现实是罗布·派克根本不想让try-catch出现，原因我们来看一段python代码：
def main():
try:
check_filename()
check_filesize()
check_filelines()
read_file()
except:
exit(1)
#endf main
if __name__ == "__init__":
main()
可能有人会说，这代码挺正常啊，出问题就退出呗，这么写代码的人真是被python给惯的太懒了，多少行代码都能用一个try-catch给包起来，根本不仔细考量到底可能会发生哪些异常，这些所谓的异常可能根本不是异常，曾经见过在python有人用try-catch代替if-else来对类似于字段个数判断处理，这种程序执行结果是没有错，但是无论是执行效率还是代码可读性以及代码可维护性上都会有问题。罗布·派克强制让编码人员仔细考虑逻辑，对于可以预期的异常就不应该用try-catch来处理，直接就是代码处理逻辑分支，而不可预期的异常就应该抛出来，所以在Go语言中遇到数组越界程序就会直接painc程序退出，另外Go语言还有个recover机制，通过调用recover捕获到panic的输入值，恢复正常的执行。
没有try-catch机制实际上是对程序员的严格要求，这也是对程序的一种保护。panic和recover在使用时都应该慎之又慎，作为程序员的我们最重要的是严谨的考虑代码逻辑，尽量避免panic。
回顾
本文从8个不同角度介绍了Go语言的由来和设计，它们分别是：
第一怪：老朽伪装小鲜肉
第二怪：强迫症晚期谁来救
第三怪：匿名字段真不赖
第四怪：interface你陷害
第五怪：加锁啥的都狗带
第六怪：静态编译没依赖
第七怪：编码运行真是快
第八怪：异常处理没有try
总结
Go语言作者罗布·派克作为贝尔实验室Unix先驱，看惯了各种编程语言刀光剑影、鼓角争鸣，各种语言你方唱罢我登场，它们虽然在一定程度上解决了之前使用语言的一些弊端，如C++语言把面向对象引进，Java把设计模式发扬光大，python使写代码接近自然语言，但是他们的时代毕竟要过去，Go语言简洁的语法，原生的并发支持，interface是精妙设计无一不显示了作者对编程语言的全新的设计和理解，罗布·派克把我们带入了一个新的编程语言世界，在这里，我们用简单严谨的语法书写程序艺术，而Go语言以其高效运行来回报我们，生活在Go语言的世界里是程序员的幸福，用时下流行的话来说，用Go语言编程的人运气都不会太坏。
注：本文大部分代码来自谢孟军的《Go web编程》一书。
