Go语言的构建方法总结

趁着近期要换工做的空闲时间，看了一下Go语言，与C++相比，Go语言的确在很多地方轻便了很多，例如：增长了内置的字符串类型、多个返回值、支持协程、简单的构建方法等等。使得在生产效率方面有了很多的提升。今天这里对Go语言的构建方法作个简单的总结。

在C/C++的工程中，极少使用单个命令来编译代码，通常是经过一些工具来进行自动化的编译，刚开始的时候手动写makefile，再后来是繁复的Autotools，以后又出现了CMake，按照时间的推移，所需咱们作的工做愈来愈少，例如在Autotools咱们大体须要以下工做：

1. autoscan扫描工做目录，以后手动修改生成的configure.ac。
2. 使用aclocal命令，经过configure.ac来生成aclocal.m4。
3. 使用autoconf命令生成configure脚本。
4. 使用autoheader命令生成config.h.in。
5. 手动建立Makefile.am文件，按照工程须要配置后再使用automake命令来生成Makefile.in文件。
6. 再执行configure脚本，最后生成Makefile。

完成上述步骤后，才能够make，make install 来完成工程的编译的安装。而以后的CMake则简便很多，只须要配置几个CMakeList.txt，以后执行CMake命令，便可生成编译和安装所需的Makefile文件。

虽然随着技术的发展，C/C++会有更好的构建方法出现。但目前看来，是摆脱不了Makefile的，而在Go1发布时，舍弃了Makefile，直接引入了更为方便的方法：**Go命令行工具**。

Go命令行工具直接舍弃的工程文件的概念，只经过目录结构和包的名字来推倒工程结构和构建顺序，下面咱们使用一个简单的例子(取自《Go语言编程》)来讲明下Go中的基本工程管理方法。

这个例子是一个基于命令行的计算器。基本用法以下所示：

$calc help
USAGE: calc command [argument] ...

The Command are:
sqrt Square root of a non-negative value
add Addation of two values

$ calc sqrt 4 #对4进行开方
2
$ calc add 1 2
3

根据需求，咱们能够把工程分为两个部分，主程序和算法库，这样，当咱们算法进行更新的时候，只修改实现就能够了，而不用修改对外的接口，这样就能够达到低耦合。工程目录以下所示：

calculator
|----src
　　|----calc
　　　　|----calc.go
　　|----simplemath
　　　　|----add.go
　　　　|----add_test.go
　　　　|----sqrt.go
　　　　|----sqrt_test.go
|----bin
|----pkg

在上面，斜体表示目录，正常文章表示文件，**xx_test.go表示是对xx.go的单元测试文件**，这是Go工程的命名规则。同时，工程下的目录src表示是源码目录，bin表示安装后的可执行程序目录，pkg表示包目录，这也是Go工程的命名规则。下面就是这个工程的代码了。
calc.go

// calc.go

package main

import (

    "fmt"

    "os"

    "simplemath"

    "strconv"

)

var Usage = func() {

    fmt.Println("USAGE: calc command [arguments]...")

    fmt.Println("\nThe commands are: \n\tAddition of two values.\n\tsqrt\tSquare root of a non-negative value")

}

func main() {

    args := os.Args

    if args == nil || len(args) < 2 {

        Usage()

        return

    }

    switch args[0] {

    case "add":

        if len(args) != 3 {

            fmt.Println("USAGE:calc add <integer1> <integer2>")

            return

        }

        v1, err1 := strconv.Atoi(args[1])

        v2, err2 := strconv.Atoi(args[2])

        if err1 != nil || err2 != nil {

            fmt.Println("USAGE:calc add <integer1> <integer2>")

            return

        }

        ret := simplemath.Add(v1, v2)

        fmt.Println("Result: ", ret)

    case "sqrt":

        if len(args) != 2 {

            fmt.Println("USAGE: calc sqrt <integer>")

            return

        }

        v, err := strconv.Atoi(args[1])

        if err != nil {

            fmt.Println("USAGE: calc sqrt <integer>")

            return

        }

        ret := simplemath.Sqrt(v)

        fmt.Println("Result: ", ret)

    default:

        Usage()

    }

}

add.go

1 // add.go
2 package simplemath
3 
4 func Add(a int, b int) int {
5     return a + b
6 }

add_test.go

 1 // add_test.go
 2 package simplemath
 3 
 4 import "testing"
 5 
 6 func TestAdd1(t *testing.T) {
 7     r := Add(1, 2)
 8     if r != 3 {
 9         t.Errorf("Add(1, 2) failed, Got %d, expected 3", r)
10     }
11 }

sqrt.go

1 // sqrt.go
2 package simplemath
3 
4 import "math"
5 
6 func Sqrt(i int) int {
7     v := math.Sqrt(float64(i))
8     return int(v)
9 }

因为篇幅问题，sqrt的单元测试代码在此省略。

完成代码后，就要进行编译了。首先须要设置环境变量**GOPATH**的值，将**calcuator的目录赋给GOPATH**,保存后从新载入便可。假设calcuator的目录是"~/gobuild",那么在linux下能够执行如下命令：

export GOPATH=~/gobuild/calcuator
source ~/.bashrc

设置完环境变量后，就能够开始构建工程了，进入calcuator的目录，执行命令：

cd bin
go build calc

以后就能够在目录下发现名字为calc的可执行程序。按照先前的功能进行试验，便可以看到对应的执行结果。

以上就是Go进行构建的过程，按照Go的要求组织好目录后，真正进行构建的就只是**go build calc**这条命令。能够说是很是简单快捷。而一样，进行单元测试，在bin目录下执行命令：
go test simplemath便可。

以上就是Go进行构建的一个简单总结。因为是刚开始接触Go语言，若是有错误的地方，请指正。谢谢
xiaoniu
[2/30]

参考资料：

Go语言编程