go破冰之旅·2·go语言“包“及主要代码结构

不念不忘少年蓝@ 2022-10-15 12:58 182阅读 0赞

> 本文对包的介绍比较丰富并给出了详细的总结。在阅读过程中如有任何问题或建议欢迎提出。
> 
> \--该系列送给喜欢go、准备学习go，基于go开发、工作的朋友们。初衷是希望广大朋友们能少走弯路，花最少的时间获得更多的知识！

**目录**

一般结构

特殊的函数

包

重要规则

多行导入包

包初始化&引入(执行)顺序

包的其它写法

点.

下划线

给包起别名

--------------------

# 一般结构 #

先看一段代码

package main
    
    import "fmt"
    
    
    func init() {  // IDE 中输入init根据提示直接回车可打出
    	
    }
    
    const const_var1 = "A"  
    var s string
    
    // 单行注释  按ctrl + l 快捷键可打出
    func main() {
    	fmt.Println("lan: start the world")
    	/* 多行注释 按ctrl + shift + l 快捷键可打出*/
    }

以上代码有这几个要点：

1，package用来声明包

2，import用来声明引入的包，内容是包的路径。如main函数中通过fmt包作了输出，因此引入了标准库的fmt包；引入包的定义通常放在开头包声明语句的下面；

3，定义了init函数，定义函数使用关键字func，函数相关的在后面的章节中具体详述；

4，有两处定义了注释，分别是不同的定义注释的方式，前者是单行注释，后者是多行注释；被注释包起来的部分程序会忽略不会执行；

5，const 关键字用来定义常量；

6，行与行之间不需要用分号分割，单行代表一个语句；代码中无需分号；

7，左大括号\{不能另起一行写，只能跟在本行之后：

func init() { }    // 正确
    
    func init()        // 错误
     { }

# 特殊的函数 #

main函数

1，是go程序的入口；

2，一个go目录(包)下最多只能有一个main函数，如果要运行则需要一个main函数，而好多个main函数时编译会报错无法运行；

3，main函数必须属于main包；

init函数

1，和main一样是一个指定名称的函数，可以定义也可以不定义；

2，在包初始化时自动调用；

3，同包下可以有多个init函数。

# 包 #

## 重要规则 ##

1，可以导入一个包也可以导入多个包，根据具体需要来；

2，包的名称可以跟目录不同名，也可以同名；

3，同包的同级目录下的go文件的包名必须相同（属于同一个包）；

4，如果定义了init函数，则init函数会在main函数之前执行；

5，如果调用了某个包下的函数a，且该包下定义了init函数，则先调用该包下的init函数，然后才会调用函数a；

6，初始化包时，会初始化包下所有定义了的init函数；

7，如果要引入的包下又有要引入的其它包，则先导入内层所引入的包，层层遍历最后回到main包；

8，重复的包只会导入一次；

9，import了的包必须使用，否则报错（IDE下编译器会自动删除未使用的包）。

## 多行导入包 ##

import (
        "第1个包的路径"
        "第2个包的路径"
    )
    
    或
    
    import   "第1个包的路径"
    import   "第2个包的路径"

## 包初始化&引入(执行)顺序 ##

几个关键环节的初始化顺序，从网上找到该图，很形象的能说明问题

![303b39b1962b3411db7f10007407275b.png][]

即main调用了pkg1，pkg1调用了pkg2，pkg2调用了pkg3，此时先初始化pkg3下的内容，顺序从前往后依次为：常量、变量、Init()函数；

pkg3完成初始化后返回继续通过同样的顺序初始化调用它的pkg2包，依次类推，最后返回main包。

举个例子。我们定义以下代码，结构如图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hZWlhfOTk4Nw_size_16_color_FFFFFF_t_70][]

我们让主程序调用test1\_pkg包，并打出当前具体时间。

其中test2\_pkg包下和test1\_pkg包下有完全相同的文件名称，只是其中要打印的标识与各自的包对应，我们来看下一些文件内容：

test1\_pkg.a1.go

package test1_pkg
    
    import (
    	"fmt"
    	"go_example/test1_pkg/test1_inner_pkg"
    	"go_example/test2_pkg"
    )
    
    func init() {
    	fmt.Println("test1_pkg:a1")
    }
    
    func Test1_pkg_a1() {
    	fmt.Println("func test1_pkg:a1")
    	test2_pkg.Test2_pkg_a1()
    	fmt.Println("---------------")
    	test1_inner_pkg.Test1_inner_pkg_a1()
    }

test2\_pkg.a1.go

package test2_pkg
    
    import "fmt"
    
    func init(){
    	fmt.Println("test2_pkg:a1")
    }
    
    func Test2_pkg_a1(){
    	fmt.Println("func test2_pkg:a1")
    }

test1\_inner\_pkg.a1.go

package test1_inner_pkg
    
    import (
    	"fmt"
    )
    
    func init(){
    	fmt.Println("test1_inner_pkg:a1")
    }
    
    func Test1_inner_pkg_a1(){
    	fmt.Println("func test1_inner_pkg:a1")
    }

再看看test1\_pkg.b+1.go

package test1_pkg
    
    import "fmt"
    
    func init(){
    	fmt.Println("test1_pkg:b+1")
    }

test2\_pkg.b+1.go

package test2_pkg
    
    import "fmt"
    
    func init(){
    	fmt.Println("test2_pkg:b+1")
    }

可以看到，文件下各自内容和文件名相对应，都有左定义的init函数，其余文件内容很简单就不一一列出啦。感兴趣的小伙伴也可以去下载源码在本地直接查看运行：[https://github.com/jialanli/go\_example.git][https_github.com_jialanli_go_example.git]

分析下主调用路线：main--->test1\_pkg包，test1\_pkg包--->test2\_pkg包的Test2\_pkg\_a1()函数、test1\_inner\_pkg的Test1\_inner\_pkg\_a1()函数。我们看看结果：

test1_inner_pkg:a1
    test2_pkg:a1
    test2_pkg:b+1
    test2_pkg:b-1
    test2_pkg:b-2
    test2_pkg:b1
    test2_pkg:b_1
    test2_pkg:b_2
    test2_pkg:p1
    test2_pkg:p2
    test2_pkg:t-1
    test2_pkg:t12
    test2_pkg:tt
    test1_pkg:a1
    test1_pkg:b+1
    test1_pkg:b-1
    test1_pkg:b-2
    test1_pkg:b1
    test1_pkg:b_1
    test1_pkg:b_2
    test1_pkg:p1
    test1_pkg:p2
    test1_pkg:t-1
    test1_pkg:t12
    test1_pkg:tt
    main
    main:other_a
    main:other_b
    lan: start the world
    func test1_pkg:a1
    func test2_pkg:a1
    ---------------
    func test1_inner_pkg:a1
    2021-05-25 15:03:32

此时你应该有很多疑问，我们基于实践结果并通过问答的方式来一一解决。

**1问：为什么先打印test1\_inner\_pkg:a1**

总体顺序：如果有层层调用，则先初始化最内层的包。这个就是某包导入其内层的包和同级的包谁先初始化的问题，具体分析如下。

main通过层层调用，最内层级的有两处：test2\_pkg包的Test2\_pkg\_a1()函数、test1\_inner\_pkg的Test1\_inner\_pkg\_a1()函数，而他们的包分别是test2\_pkg、test1\_inner\_pkg，这两个名称go编译器会从左往右进行比较，前面四个字母都相同，第五个字母时前者为2，后者为1，值已经不同因此不会继续比较下去，此时根据由小到大的顺序先初始化test1\_inner\_pkg包，然后初始化test2\_pkg包，因此自然而然的会先执行test1\_inner\_pkg包的init函数打印出**test1\_inner\_pkg:a1**。

**2问：为什么先打出了test2\_pkg:a1  ，而test2\_pkg:b+1在其后面？**

a1.go和b+1.go 按照名称从左往右检查，a小于b，因此先调用a1.go的init函数。

**3问：为什么先打出了test2\_pkg:b+1  ，而test2\_pkg:b-1在其后面？**

同第二个，按照名称从左往右检查，+ 的顺序高于- ，因此先调用b+1.go的init函数。（顺序为go官方指定定义，且根据实践所得，并不代表其他领域或范畴下符号的优先级）。

**4问：从整体来看，先调用了test2\_pkg包下的init，而后调用了test1\_pkg包下的init？**

因为main中先调用的test1\_pkg包，然后test1\_pkg下的文件又调用了test2\_pkg包的函数，层级角度下test2\_pkg包在内层，先初始化被调用了的内层的包。

**5问：这三个的顺序：test1\_pkg:t-1 、test1\_pkg:t12、test1\_pkg:tt为什么是这样？**

\+先于-   ，    -  先于数字，数字先于下划线， 下划线先于字母，所以是这个结果。

后面以func开始的标识都是正常的函数调用，先调用谁后调用谁都是按代码逻辑顺序来，没什么问题。

总结：不论是数字还是字母，总体是按由小到大的顺序。

## 包的其它写法 ##

### 点. ###

package main
    
    import (
    	"fmt"
    	. "github.com/jialanli/lacia/utils"
    	"go_example/test1_pkg"
    	"time"
    )
    
    
    func main() {
    	fmt.Println("lan: start the world")
    	/* 注释 按ctrl + shift + l 快捷键可打出*/
    	ts := time.Now().Unix()
    	str := GetTimeStrOfDayTimeByTs(ts)   // here
    	fmt.Println(str)
    }

如这段代码，GetTimeStrOfDayTimeByTs()函数是第三方库lacia中的代码，我不想用其包名来调，只想直接写函数来调用，就可以给包导入的前面加一个点，用来表示不加包名访问其属性。

### 下划线 ###

go中\_很常见，一般用于把赋值的结果丢弃掉，给它搞成匿名的。

给包的前面加下划线即该包成了匿名包。该方式下只会执行该包的初始化函数。我们引入一个go官方io包：

package main
    
    import (
    	"fmt"
    	. "github.com/jialanli/lacia/utils"
    	"go_example/test1_pkg"
        _ "io"
    	"time"
    )
    
    
    func main() {
    	fmt.Println("lan: start the world")
    	/* 注释 按ctrl + shift + l 快捷键可打出*/
    	ts := time.Now().Unix()
    	str := GetTimeStrOfDayTimeByTs(ts)   // here
    	fmt.Println(str)
    }

另外此时如果要强行引入此包且不加下划线，则会编译报错，下划线也会使得编译成功。

### 给包起别名 ###

package main
    
    import (
    	"fmt"
    	mypkg "github.com/jialanli/lacia/utils"
    	"go_example/test1_pkg"
    	"time"
    )
    
    
    func main() {
    	fmt.Println("lan: start the world")
    	/* 注释 按ctrl + shift + l 快捷键可打出*/
    	ts := time.Now().Unix()
    	str := mypkg.GetTimeStrOfDayTimeByTs(ts)   // here
    	fmt.Println(str)
    }

相信你已经看出来了，给包的前面写自己定义的新名称，使用改包时通过新名称来调用其属性。

[303b39b1962b3411db7f10007407275b.png]: /images/20221014/b29d40d47da441308e1d7a54d15659c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hZWlhfOTk4Nw_size_16_color_FFFFFF_t_70]: /images/20221014/d49ee8ac252f467ba8872947a391c56e.png
[https_github.com_jialanli_go_example.git]: https://github.com/jialanli/go_example.git