Go语言编程开发入门简介

 Go语言编程开发入门简介: Go语言是google开发的一门新的系统级语言，项目主页：http://golang.org/

1. 安装go语言环境

目前go语言主要用于Linux环境，提供源代码方式安装。关系安装的完整介绍请参考
官方网站：  http://golang.org/doc/install.html。

这里的文档主要是针对Linux系统的用户。go采用Mercurial管理代码，因此需要现安装
Mercurial工具。除此之外，go的编译还依赖以下工具：bison/gcc/libc6-dev/ed/gawk
和make。

先创建一个空目录，假设为 $HOME/go，可以用以下命令获取源代码：

代码: 全选
$ hg clone -r release https://go.googlecode.com/hg/  $HOME/go
然后配置环境变量：

代码: 全选
export GOROOT=$HOME/go
export GOARCH=386
export  GOOS=linux
export  GOBIN=$HOME/bin
其中GOARCH对应CPU类型，如果是32位的则为386，64位的为amd64，另外还有arm类型。
GOBIN对应go编译工具放置的目录，要确保对应的目录存在。然后将GOBIN目录添加到PATH中：

代码: 全选
export PATH=$GOBIN:$PATH
用以下命令再查看一下环境变量是否已经设置好：

代码: 全选
$ env | grep ‘^GO’
如果一切就绪的话就可以开始编译go了：

代码: 全选
$ cd $GOROOT/src
$ ./all.bash
如果编译成功，可以看到以下结尾信息：
代码:  全选
— cd ../test
N known bugs; 0 unexpected  bugs
编译成功后，可以试试godoc命令是否可用。

2. Hello, 世界

让我们来看看经典的”Hello, World”程序在go中是什么样子：

代码: 全选
package main

func main() {
print(“Hello, 世界\n”)
}
保存到hello.go文件中，然后用以下命令编译：

代码: 全选
8g hello.go
8l  hello.8
./8.out
其中8g/8l是对应386类型CPU的编译命令，如果是64位系统请将8替换为6。如果一切正常，
应该可以输出结果：

代码: 全选
Hello, 世界
关于go更多的语言细节，这里先不展开了。读者可以参考：

http://golang.org/doc/go_tutorial.html

3. 用make方式编译

对于正式的工程，一般都用make方式编译。Go语言中使用make非常简单。我们先建一个Makefile
文件，内容如下：

代码: 全选
include $(GOROOT)/src/Make.$(GOARCH)

TARG=hello
GOFILES=hello.go

include  $(GOROOT)/src/Make.cmd
其中第一行和最后一行比较固定。TARG指定输出文件名，GOFILES指定对应的go程序源文件。
我们这里只有一个hello.go文件，输出名为hello。

重新编译，并安装到 $GOBIN ：

代码: 全选
make clean
make
make install
如果要删除所有的编译结果和取消安装：

代码: 全选
make nuke
4. 构建自己的包

对于传统的C语言，很多通用的代码通常组织为库。在go语言中库以包的方式来组织。我们
现在用go中的fmt包来输出”Hello,  World”：

代码: 全选
package main

import “fmt”

func main() {
fmt.Printf(“Hello,  世界\n”)
}
但是，我们想构建我自己的fmt包，怎么办呢？而且，我们可以同时有多个功能不相同的包。
我们假设自己的包都以mypkg为前缀，例如：mypkg/hello、mypkg/fmt等。

由于Printf是一个相对复杂的函数，我们现在目的只是演示如何制作包。因此，只实现一个
简单的函数，函数本身没有参数：

代码: 全选
package hello

import “fmt”

func PrintHello() {
fmt.Printf(“Hello, 世界\n”)
}
将上面这段代码保存到  ./mypkg/hello/hello.go 文件中。然后创建 ./mypkg/hello/Makefile
文件，内容如下：

代码: 全选
include $(GOROOT)/src/Make.$(GOARCH)

TARG=mypkg/hello
GOFILES=hello.go

include  $(GOROOT)/src/Make.pkg
其中TARG对应包的全名，这里包含mypkg前缀。GOFILES对应库的源文件。最后一行为Make.pkg，
表示工程为包。如果最后一行为Make.cmd，则表示为可执行文件，例如前面讲到的。

然后我们编译并安装包mypkg/hello：

代码: 全选
make
make install
安装后我们可以发现go目录多了  $GOROOT/pkg/linux_386/mypkg/hello.a 文件，对于我们
的创建的包。

5. 包测试

由于我们已经安装了包mypkg/hello，因此可以像标准库那样使用：

代码: 全选
package main

import “mypkg/hello”

func main()  {
print(“hello,”)
hello.PrintHello()
}
那如何在不安装包的情况下进行简单测试呢。为了实现这个目的，我们需要完善包的Makefile文件。
新的  ./mypkg/hello/Makefile 文件在末尾增加了几行代码：

代码: 全选
include $(GOROOT)/src/Make.$(GOARCH)

TARG=mypkg/hello
GOFILES=hello.go

include $(GOROOT)/src/Make.pkg

# Simple test programs

%: install %.go
$(GC) $*.go
$(LD) -o $@  $*.$O
在测试前我们先要删除安装的mypkg/hello包，用以下命令（删除后最好确认一下）：

代码: 全选
cd mypkg/hello
make  nuke
然后在mypkg/hello创建测试程序，对应helloapp.go文件：

代码: 全选
package main

import “mypkg/hello”

func main()  {
print(“hello,”)
hello.PrintHello()
}
然后直接编译helloapp：

代码: 全选
make  helloapp
我们发现目录中多了一个helloapp可执行文件。上面的命令在编译helloapp的时候，会自动
编译mypkg/hello/包。如果还有新的测试程序，名字为helloapp2，那么可以用以下方式
编译：

代码: 全选
make helloapp2
make后的参数是可选的。当然，这里的测试程序比较短小，只对应一个源文件。

6. gotest

前面的测试只是临时的。如果要编写更专业的单元测试，我们可以用go提供的gotest工具。

还是在./mypkg/hello/目录，增加一个hello_test.go文件。注意：hello_test名字
是包名hello加_test后缀。hello_test.go内容如下：

代码: 全选
package hello

import “testing”

func TestPrintHello(t *testing.T) {
// ok
}

func TestError(t *testing.T) {
t.Errorf(“my  error”)
}
这里的一些细节可以先不要深究。其中每个以Test为前缀的是要进行测试的函数。我们这里有
两个测试函数，其中第二个认为输出了一个错误。

在当前目录输入gotest进行测试，输出以下结果：

代码: 全选
[chai@localhost hello]$ gotest
rm -f _test/mypkg/hello.a  _gotest_.8
/home/chai/bin/8g -o _gotest_.8 hello.go hello_test.go
rm -f  _test/mypkg/hello.a
/home/chai/bin/gopack grc _test/mypkg/hello.a  _gotest_.8
— FAIL: hello.TestError
my error
FAIL
7. 使用C语言函数

 Go语言编程开发入门简介 go编译器有两套：go自带的和gccgo。其中gccgo是以gcc为后端，编译后的go代码可以和
gcc编译的C/C++代码集成。go自带的编译器中有一个叫cgo的工具，可以用于在go中集成C
语言库。

在go中如果需要访问C语言函数，一般是先将C语言函数包装成go的包。前面我们已经讲了如何
构建一个包，现在我们演示如何在包中访问C语言函数。

我们现在创建和mypkg/hello功能类似的包：mypkg/hello2。hello2.go的内容如下：

代码: 全选
package hello2

/*
#include <stdio.h>
*/
import “C”

func PrintHello() {
C.puts(C.CString(“Hello,  world\n”))
}
在这个例子中我们使用C语言的puts函数输出结果。由于C语言不支持UTF8，我们这里只输出
英文字母。这里的import行用于引入C语言库，在该指令之前紧挨着的注释会被当作C语言编译。
然后，C语言的函数可以通过加C.前缀的方式来使用，例如：C.puts。

由于GO语言的不同数据类型之间是不能转换的，因此将go的数据类型传递给C语言的数据类型
需要强制转换。C语言的类型和C语言函数的使用方式类似，也要用C.前缀，例如：C.int、
C.float等。需要注意的是go中字符串和C语言中的字符指针是不同的，因此有一个专门的函数
C.CString用于将go字符串转换为C语言字符串。

另外，目前cgo不支持从go中访问C语言中可变参数的函数（例如printf）。如果将上目的puts
换为printf函数，那么在编译的时候可能得到以下错误提示：

代码: 全选
unexpected type: …
其中三个点为printf函数声明中表示可变参数的部分。

Makefile文件也要作相应的更新，主要是将GOFILES该为CGOFILES。CGOFILES对应有
C语言代码的go文件，用cgo编译。如果工程中有纯go的代码，则还是对于GOFILES。改动
后的Makefile如下：

代码: 全选
include $(GOROOT)/src/Make.$(GOARCH)

TARG=mypkg/hello2

CGOFILES=hello2.go

include $(GOROOT)/src/Make.pkg

# Simple test programs

%: install %.go
$(GC) $*.go
$(LD) -o $@  $*.$O
go是支持垃圾内存自动回收的。对于C语言函数中申请的内存，也应该有C语言模块负责回收。
对于C.CString返回的字符串空间由go还是C语言负责回收还不清楚。

当然，将go中的数组传递给C语言也是可以的。例如，下面的代码用C语言函数打印数组：

代码: 全选
package hello2

/*
#include <stdio.h>

int printArray(void *p, int len) {
int *v = (int*)p;
int i;

for(i = 0; i < len; i++) {
printf(“v[%d]: %d\n”, i,  v[i]);
}
return i;
}
*/
import “C”
import “unsafe”
import  “fmt”

func PrintHello() {
C.puts(C.CString(“Hello, world\n”))
}

func PrintSlice(v []int) {
n := C.printArray(unsafe.Pointer(&v[0]),  C.int(len(v)))
fmt.Printf(“n = %d\n”, int(n))
}
我们在import  “C”前面的注释中定义了一个printArray函数，用C语言方式打印数组。
然后在PrintSlice中通过C.printArray方式调用，unsafe.Pointer(&v[0])
用于将go中的数组地址转换为C语言的void指针，C.int(len(v))指定数组的长度。

然后将函数返回值保存在变量n中，数据类型为C.int。在输出n的时候，我们强制转换为
go语言的int类型。

测试函数为hello2app.go，内容如下：

代码: 全选
package main

import “mypkg/hello2″

func main() {
print(“hello,”)
hello2.PrintHello()

hello2.PrintSlice([]int{ 3, 5, 1})
}
编译运行后输出以下结果：

代码: 全选
[chai@localhost hello2]$ ./hello2app
hello,Hello, world

v[0]: 3
v[1]: 5
v[2]: 1
n =  3
如果我们需要在C语言函数中分配空间，然后在go中以数组的方式来访问，可以用以下方式：

代码: 全选
/*
void* getString() {
return “test  string”;
}
*/
import “C”
import “unsafe”

func TryGetString
p :=  (*[100]uint8)(unsafe.Pointer(C.getString()))
fmt.Printf(“ss: %v\n”,  string(p[0:10]))
}

这样我们就可以实现go和C语言之间指针的双向传递了。出了指针之外，go中还可以访问C语言的
结构体。例如：

代码: 全选
/*
typedef struct {
int a;
} CStruct;
*/
import  “C”
import “fmt”

func TryStruct() {
v := C.CStruct{ a:10 }
fmt.Printf(“v struct: %v\n”,  v2)
}