Go语言的代码组织结构详细介绍

包(package)

一个程序以一个包的形式构建，这个包还可以使用其他包提供的一些设施。

一个golang程序的创建是通过链接一组包。

一个包可以由多个源码文件组成。

导入包中的名字可以通过packagename.Itemname访问。

源码文件结构

golang每个源码文件包括：

- 一个package字句(文件归属于哪个包)；其名字将作为导入包时的默认名字。

package fmt

import "fmt" //使用默认名字

import myFmt "fmt" //使用名字myFmt

- 0个或多个全局或“包级别”声明。

单一文件包

package main // 这个文件是包main的一部分

import "fmt" // 这个文件使用了包"fmt"
const hello = "Hello, 世界\n"
func main() {

fmt.Print(hello)

}

main和main.main

每个Go程序包含一个名为main的包以及其main函数，在初始化后，程序从main开始执行。类似C,C++中的main()函数。

main.main函数没有参数，没有返回值。当main.main返回时，程序立即退出并返回成功。

os包

os包提供Exit函数以及访问文件I/O以及命令行参数的函数等。

// A version of echo(1) 

package main 

 

import ( 

 "fmt" 

 "os" 

) 

 

func main() { 

 if len(os.Args) < 2 { // length of argument slice 

 os.Exit(1) 

 } 

 for i := 1; i < len(os.Args); i++ { 

 fmt.Printf("arg %d: %s\n", i, os.Args[i]) 

 } 

} // falling off end == os.Exit(0) 

全局作用域与包作用域

在一个包中，所有全局变量、函数、类型以及常量对这个包的所有代码可见。

对于导入该包的包而言，只有以大写字母开头的名字是可见的：全局变量、函数、类型、常量以及方法和结构体中全局类型以及变量的字段。

const hello = "you smell" // 包内可见

const Hello = "you smell nice" //全局可见

const _Bye = "stinko!" // _不是大写字母

初始化

有两种方法可以在main.main执行前初始化全局变量：

1) 带有初始化语句的全局声明
2) 在init函数内部，每个源文件中都可能有init函数。

包依赖可以保证正确的执行顺序。

初始化总是单线程的。

初始化例子：

package transcendental 

 

import "math" 

 

var Pi float64 

 

func init() { 

 Pi = 4*math.Atan(1) // init function computes Pi 

} 

 

package main 

 

import ( 

 "fmt" 

 "transcendental" 

) 

 

var twoPi = 2*transcendental.Pi // decl computes twoPi 

 

func main() { 

 fmt.Printf("2*Pi = %g\n", twoPi) 

} 

输出: 2*Pi = 6.283185307179586

包与程序构建

要构建一个程序，包以及其中的文件必须按正确的次序进行编译。包依赖关系决定了按何种次序构建包。

在一个包内部，源文件必须一起被编译。包作为一个单元被编译，按惯例，每个目录包含一个包，忽略测试，

cd mypackage

6g *.go

构建fmt包

% pwd

/Users/r/go/src/pkg/fmt

% ls

Makefile fmt_test.go format.go print.go # …

% make # hand-written but trivial

% ls

Makefile _go_.6 _obj fmt_test.go format.go print.go # …

% make clean; make

…

编写Makefiles时通常使用Make.pkg提供的帮助。看源码。

测试

要测试一个包，可在这个包内编写一组Go源文件；给这些文件命名为*_test.go。

在这些文件内，名字以Test[^a-z]开头的全局函数会被测试工具gotest自动执行，这些函数应使用下面函数签名：

func TestXxx(t *testing.T)

一个测试例子

摘自fmt_test.go中的一段有趣代码：

import ( 

 "testing" 

) 

 

func TestFlagParser(t *testing.T) { 

 var flagprinter flagPrinter 

 for i := 0; i < len(flagtests); i++ { 

 tt := flagtests[i] 

 s := Sprintf(tt.in, &flagprinter) 

 if s != tt.out { 

 // method call coming up – obvious syntax. 

 t.Errorf("Sprintf(%q, &flagprinter) => %q,"+" want %q", tt.in, s, tt.out) 

 } 

 } 

} 

gotest（译注：在go 1中gotest工具用go test命令替代）

% ls

Makefile fmt.a fmt_test.go format.go print.go # …

% gotest # by default, does all *_test.go

PASS

wally=% gotest -v fmt_test.go

=== RUN fmt.TestFlagParser

— PASS: fmt.TestFlagParser (0.00 seconds)

=== RUN fmt.TestArrayPrinter

— PASS: fmt.TestArrayPrinter (0.00 seconds)

=== RUN fmt.TestFmtInterface

— PASS: fmt.TestFmtInterface (0.00 seconds)

=== RUN fmt.TestStructPrinter

— PASS: fmt.TestStructPrinter (0.00 seconds)

=== RUN fmt.TestSprintf

— PASS: fmt.TestSprintf (0.00 seconds) # plus lots more

PASS

%

一个benchmark的测试例子

Benchmark的函数签名如下：

func BenchmarkXxxx(b *testing.B)

并被循环执行b.N次；其余的由testing包完成。

下面是一个来自fmt_test.go中的benchmark例子：

package fmt // package is fmt, not main 

import ( 

 "testing" 

) 

func BenchmarkSprintfInt(b *testing.B) { 

 for i := 0; i < b.N; i++ { 

 Sprintf("%d", 5) 

 } 

} 

Benchmarking: gotest

% gotest -bench="." # regular expression identifies which

fmt_test.BenchmarkSprintfEmpty 5000000

310 ns/op

fmt_test.BenchmarkSprintfString 2000000

774 ns/op

fmt_test.BenchmarkSprintfInt

5000000

663 ns/op

fmt_test.BenchmarkSprintfIntInt 2000000

969 ns/op

…

%

库

库就是包。

目前的库规模是适中的，但还在增长。

一些例子：

包 目的 例子
fmt 格式化I/O Printf、Scanf
os OS接口 Open, Read, Write
strconv numbers<-> strings Atoi, Atof, Itoa
io 通用I/O Copy, Pipe
flag flags: –help等 Bool, String
log 事件日志 Logger, Printf
regexp 正则表达式 Compile, Match
template html等 Parse, Execute
bytes 字节数组 Compare, Buffer

更多关于fmt

fmt包包含一些熟悉的名字：

Printf – 打印到标准输出

Sprintf – 返回一个字符串

Fprintf – 写到os.Stderr等

还有

Print, Sprint, Fprint – 无格式no format

Println, Sprintln, Fprintln – 无格式，但中间加入空格，结尾加入\n

fmt.Printf("%d %d %g\n", 1, 2, 3.5)

fmt.Print(1, " ", 2, " ", 3.5, "\n")

fmt.Println(1, 2, 3.5)

每个都输出相同的结果："1 2 3.5\n"

库文档

源码中包含注释。

命令行或web工具可以将注释提取出来。

链接：http://golang.org/pkg/

命令：

% godoc fmt

% godoc fmt Printf

本文Go语言的代码组织结构详细介绍到此结束。如果你独自一人笑了，那是真心的笑。小编再次感谢大家对我们的支持！