这一周，利用每天晚上下班回来后的一小时，学习了Google开发的Go语言，算是对其有了个基本的了解。确实是门漂亮的语言。

首先，从它的设计目标是设计一种高效的、静态编译的、易于编写的语言。它涉足的是系统级的编程，试图与C/C++抗衡。

详细来说，它的设计目标有如下几点（来自wikipedia和golang FAQ）：

• 安全：类型安全与内存安全。没有继承，无需处理类型的依赖关系，弱化类型的使用；变量默认初始化，简化设计负担。
• 并发和通信的支持。内建的并发机制使得多线程编程变得非常简单；内建的chan（channel）类型简化了线程间通讯。
• 完全的内存垃圾回收机制。
  
• 高速编译。没有头文件、Makefile等复杂的工程依赖关系，使得编译速度更快，工程更容易组织。

而在我看来，通过一周的学习，给我留下最深印象的，是如下几个方面：

下面我将以我在教程中写的一些代码为例，说说我对上面几点的理解。

自然的语法

go语言的语法，非常符合英语语法的习惯（英语语法较汉语更具有逻辑性，更能清楚的解释问题）。

比如

定义一个变量：x int，用英语来读就是x of type int；

定义一个函数：func add(x, y int) int，读出来就是：a function named add, with parameter x & y of type int, that returns int。非常自然。

当然，要显示出这种定义的自然性，我们可以看一个复杂的例子，函数指针：

首先看看C语言的定义方式：

int (*fp)(int (*ff)(int x, int y), int b)

如果用Go呢？

fp func(ff func(x, y int) int, b int) int

是不是刚好与上面的描述符合？

这种符合自然语言语法的定义方式，简化了代码理解的步骤，也不容易出错。

关于此部分更详细的内容，可以参考Go's Declaration Syntax。

下面给出一个hello world程序，一睹为快：

// 类似Java，用包名来组织代码
package main

import "fmt"

// 程序的“入口”，main函数。
func main() {
	fmt.Println("Hello, 世界")
	// 没有return语句
}

方便的内建类型

这里我以tour.golang.org中的一个练习为例子，介绍go语言中的map和string。

这个练习要求：

实现WordCount函数。此函数输入一句英文语句，并返回一个map类型，存储每个单词对应的重复次数。主函数以及写好，包含一个wc.Test函数，用于测试WordCount函数的正确性。

提示：strings.Fields可能会很有帮助。

下面是我的实现：

package main

import (
	"tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	// 创建一个键为string，值为int的map
	// make可以用来创建任何类型的变量。
	// 比如make([]int, 3)是创建3个元素的int数组
	m := make(map[string]int)
	// 变量的使用可以不用显示的指明类型
	// 这里，words的类型即Fields的返回值类型，是个字符串数组
	words := strings.Fields(s)

	// Go语言没有while、do-while
	// for 条件 { 执行体 } 即相当于while
	// for { 执行体 } 即无限循环
	// 这里，使用for的range特性，取words的索引和值
	// 分别给_和word，下划线_相当于一个占位符，不赋值给具体的变量
	// 同样，还可以使用：i, _ := range words，表示只需要其索引
	// 甚至可以使用：_, _ := range words，表示只需要循环相应次数即可
	for _, word := range words {
		// 根据键取map中的值，并修改
		// Go是内存安全的语言，如果m中不存在word键
		// 将会自动创建一个word，并初始化其值为0
		m[word]++;
	}
	return m
}

func main() {
	wc.Test(WordCount)
}

由这个例子，我们可以了解到Go语言的很多特性，比如_, word := range words这样的多个赋值同时进行（也可用于函数返回值），比如内建的string、map类型，比如简化的循环体（没有括号，去掉while,do-while，支持多种循环条件的定义），还有代码的组织方式等。

结构体和接口

Go语言没有类的概念，没有构造、析构函数，更没有继承。只有结构体和接口。

下面以Exercise: Images为例，介绍Go语言的结构体和接口的使用：

package main

import (
	"image"
	"image/color"
	"tour/pic"
)

// 定义Image类型
// 类似的定义还可以这样：type MyInt int
// 相当于typedef
type Image struct{
	content [][]uint32	// 二维数组，存储图片内容
				// 包含每个像素点的RGBA值。
	width, height int	// 图片宽度和高度
}

// 自定义的像素点函数，返回给定点的RGBA值
func valueOfPointer(x, y int) uint32 {
	return uint32(0xfffff*x^(0xfffff*y + 0xff))
}

// 自定义的图片生成函数，用于使用给定的像素点函数生成一幅图片
func makePic(w, h int, f func(int,int) uint32) *Image {
	img := new(Image)
	img.width = w
	img.height = h
	
	// 此处先申请一个长度为w，类型为[]uint32的数组
	img.content = make([][]uint32, w)
	for x := 0; x < w; x++ {
		// 再为每个数组的元素申请h长度的uint32型数组
		// 由此而创建出一块 w x h 的二维数组
		img.content[x] = make([]uint32, h)
		
		// 使用f函数为每个像素赋值
		for y := 0; y < h; y++ {
			img.content[x][y] = f(x, y)
		}
	}
	
	return img
}

////////////////////////////////////////////
// 接下来的几个函数是接口image.Image的函数实现
// Go语言中，无需显示的申明实现接口
// 只需要实现接口的所有函数，即实现了接口

// Bounds 函数返回图片的可用区域
// 在 func 和函数名之间加上类型，表示此函数是该类型的成员函数
// 注意，此处的类型不仅限于结构体，比如浮点数、整数都可以。
func (img *Image) Bounds() image.Rectangle {
	return image.Rect(0, 0, img.width, img.height)
}

// ColorModel 函数指明图片使用的颜色模式
// 这里，我们选用RGBA模式
func (img *Image) ColorModel() color.Model {
	return color.RGBAModel
}

// At 函数，返回指定像素点的颜色属性
func (img *Image) At(x, y int) color.Color {
	// 根据练习的说明设置超出范围的点的颜色
	if x >= img.width || y >= img.height {
		return color.RGBA{uint8(x), uint8(y), 0xff, 0xff}
	}
	
	// 根据存储的二维数组，生成RGBA模式的颜色并返回
	var c = img.content[x][y]
	return color.RGBA{
		uint8((c >> 24) & 0xff),
		uint8((c >> 16) & 0xff),
		uint8((c >> 8) & 0xff),
		uint8(c & 0xff) }
}

func main() {
	m := makePic(200, 100, valueOfPointer)
	// 调用pic类的ShowImage来显示生成的图片
	pic.ShowImage(m)
}

内建的并发机制

Go语言内建了并发机制，无需第三方库的支持就可以方便的创建线程。并且，Go语言包含一个chan类型用于线程间的变量传递，降低了使用共享内存传递的风险，有些类似于unix里的管道。

下面先以一个Equivalent Binary Trees的例子，来介绍并发以及chan的使用，并进一步熟悉Go语言：

package main

import (
	"fmt"
	"tour/tree"
	"sort"
)

// Walk 遍历t，将其所有的内容由ch发送出去
// 我使用递归的方式实现了它
// 注意，Go语言的channel是有类型的
func Walk(t *tree.Tree, ch chan int) {
	if t.Left != nil {
		Walk(t.Left, ch)
	}
	if t.Right != nil {
		Walk(t.Right, ch)
	}
	// 使用 <- 符号将变量值发送到chan
	ch <- t.Value
}

// Same 决定t1、t2是否是具有相同内容的两棵树
func Same(t1, t2 *tree.Tree) bool {
	// 创建两个具有缓存的管道
	// 管理发送的线程将不停的发送，直至缓存溢出，
	// 等到管理接收的线程取出值以后，才能继续发送
	// 这相当于一个固定大小的队列。
	ch1 := make(chan int, 10)
	ch2 := make(chan int, 10)
	// 使用两个数组来存储树的内容	
	a1  := make([]int, 10)
	a2  := make([]int, 10)
	
	// 新建两个线程，同时开始遍历
	go Walk(t1, ch1)
	go Walk(t2, ch2)
	
	// 主线程将不停的接收另外两个线程传来的数据
	for i := 0; i < 10; i++ {
		a1[i] = <- ch1
		a2[i] = <- ch2
	}
	
	// 排序以便于检查其内容是否一致
	sort.Ints(a1)
	sort.Ints(a2)
	for i := 0; i < 10; i++ {
		if a1[i] != a2[i] {
			return false
		}
	}
	
	return true
}

func main() {
	// tree.New(k)可以创建内容包含k, 2k, 3k, ..., nk的树
	t1 := tree.New(1)
	t2 := tree.New(2)
	ch := make(chan int, 10)
	
	// 打印t1树
	fmt.Print("t1: ")
	go Walk(t1, ch)
	for i := 0; i < 10; i++ {
		fmt.Printf("%2d, ", <- ch)
	}
	fmt.Println()
	
	// 打印t2树
	fmt.Print("t2: ")
	go Walk(t2, ch)
	for i := 0; i < 10; i++ {
		fmt.Printf("%2d, ", <- ch)
	}
	fmt.Println()
	
	// 测试Same函数
	fmt.Printf("Is %v that t1 equal t1.\n", Same(t1, t1))
	fmt.Printf("Is %v that t1 equal t2.\n", Same(t1, t2))
}

由例子可以看到管道的使用方式： <- 。发送可以用 channel <- value，接收可以用 variable := <- channel。非常形象。

Go语言中的并发是基于函数的。使用 go function() 即可使此函数在新的线程中运行，父线程将继续运行，不会等待函数结束。

并发更复杂更灵活的运用，请看练习：Web Crawler。

OK，关于Go的简单介绍就到这里，更详细的文档请参阅Go语言官方网站：http://golang.org/。

本专题（Go语言学习）所涉及的代码已经同步到GitHub上，便于分享，下面是链接：

https://github.com/tankery/study-go

注：从今天起，我将以每星期至少一篇的频率写这份博客。

至于每周一篇的频率，是由我常年加班的工作性质决定的。每周一篇，法定节日休息。。。