[golang note] 包和导入

package的作用

√ package是golang最基本的分发单位和工程管理中依赖关系的体现。

√ 每个golang源代码文件开头都拥有一个package声明，表示该golang代码所属的package。

√ 要生成golang可执行程序，必须建立一个名为main的package，并且在该package中必须包含一个名为main()的函数。

√ 在golang工程中，同一个路径下只能存在一个package，一个package可以拆成多个源文件组成。

√ import关键字导入的是package路径，而在源文件中使用package时，才需要package名。经常可见的import的目录名和源文件中使用的package名一致容易造成import关键字后即是package名的错觉，真正使用时，这两者可以不同。

• 《Go语言编程》中calc实例

▶ 工程目录

<calcproj>
├─<src>
├─<calc>
├─calc.go
├─<simplemath>
├─add.go
├─add_test.go
├─sqrt.go
├─sqrt_test.go
├─<bin>
├─<pkg>

▶ 详细源码

Δ add.go

package sm

func Add(a int, b int) int {
return a + b
}

Δ sqrt.go

package sm

import "math"

func Sqrt(i int) int {
v := math.Sqrt(float64(i))
return int(v)
}

Δ add_test.go

package sm

import "testing"

func TestAdd1(t *testing.T) {
r := Add(1, 2)

if r != 3 {
t.Errorf("Add(1, 2) failed. Got %d, expected 3.", r)
}
}

Δ sqrt_test.go

package sm

import "testing"

func TestSqrt1(t *testing.T) {
v := Sqrt(16)

if v != 4 {
t.Errorf("Sqrt(16) failed. Got %v, expected 4.", v)
}
}

Δ calc.go

package main

import "os"
import "fmt"
import "strconv"
import "simplemath"

var Usage = func() {
fmt.Println("USAGE: calc command [arguments] ...")
fmt.Println("\nThe commands are:\n\tadd\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[1] {
case "add":
if len(args) != 4 {
fmt.Println("USAGE: calc add <integer1> <integer2>")
return
}

v1, err1 := strconv.Atoi(args[2])
v2, err2 := strconv.Atoi(args[3])
if err1 != nil || err2 != nil {
fmt.Println("USAGE: calc add <integer1> <integer2>")
return
}

ret := sm.Add(v1, v2)
fmt.Println("Result: ", ret)
case "sqrt":
if len(args) != 3 {
fmt.Println("USAGE: calc sqrt <integer>")
return
}

v, err := strconv.Atoi(args[2])
if err != nil {
fmt.Println("USAGE: calc sqrt <integer>")
return
}

ret := sm.Sqrt(v)
fmt.Println("Result: ", ret)
default:
Usage()
}
}

▶ 源码说明

calcproj工程中src\simplemath目录下只存在sm一个package，而sm包由四个源文件构成。calc.go文件中可以看到import导入的是simplemath而非sm，而在使用sm包中的Add和Sqrt函数时，使用的才是真正的包名sm。

import关键字

√ 使用import语句导入源代码文件所依赖的package路径。

√ 不得导入源代码文件中没有用到的package，否则golang编译器会报编译错误。

• import语法

▶ 风格一

import "package1"
import "package2"
import "package3"
...

▶ 风格二

import (
"package1"
"package2"
"package3"
...
)

• import原理

如果编译时main包导入了其他的包，那么这些包将被依次导入。

当一个包被导入时，如果该包还导入了其它的包，那么先将其他的包导入进来，然后再对该包的包级常量和变量进行初始化，最后执行init函数（如果存在）。包的导入如上图所示，是一个递归地过程，等所有被导入的包加载完毕，就会对main包中的包级常量和变量进行初始化，然后执行main包中的init函数（如果存在），最后执行main函数。

如果一个包被多个包同时导入，那么它只会被导入一次。

• import修饰操作

• 点（.）操作

点（.）操作的含义是：点（.）标识的包导入后，调用该包中函数时可以省略前缀包名。点（.）操作的语法为：

import . "package1"
import . "package2"
import . "package3"
...

import (
. "package1"
. "package2"
. "package3"
...
)

下面的示例中，fmt包将使用点操作省略前缀包名，os包用法保持不变：

package main

import (
. "fmt"
"os"
)

func main() {
for _, value := range os.Args {
Println(value)
}
}

• 别名操作

别名操作的含义是：将导入的包命名为另一个容易记忆的别名。别名操作的语法为：

import p1 "package1"
import p2 "package2"
import p3 "package3"
...

import (
p1 "package1"
p2 "package2"
p3 "package3"
...
)

下面的示例中，fmt包将使用别名操作重新命名为f，os包用法保持不变：

package main

import (
f "fmt"
"os"
)

func main() {
for _, value := range os.Args {
f.Println(value)
}
}

• 下划线（_）操作

下划线（_）操作的含义是：导入该包，但不导入整个包，而是执行该包中的init函数，因此无法通过包名来调用包中的其他函数。使用下划线（_）操作往往是为了注册包里的引擎，让外部可以方便地使用。下划线（_）操作的语法为：

import _ "package1"
import _ "package2"
import _ "package3"
...

import (
_ "package1"
_ "package2"
_ "package3"
...
)