厄索斯

# 9. Go语言包（package）

# 9.1 包的常用操作

# 9.1.1 包的基本概念

Go语言是使用包来组织源代码的，包（package）是多个 Go 源码的集合，是一种高级的代码复用方案。Go语言中为我们提供了很多内置包，如 fmt、os、io 等。任何源代码文件必须属于某个包，同时源码文件的第一行有效代码必须是package pacakgeName语句，通过该语句声明自己所在的包。

Go语言的包借助了目录树的组织形式，一般包的名称就是其源文件所在目录的名称，虽然Go语言没有强制要求包名必须和其所在的目录名同名，但还是建议包名和所在目录同名，这样结构更清晰。

包可以定义在很深的目录中，包名的定义是不包括目录路径的，但是包在引用时一般使用全路径引用。比如在GOPATH/src/a/b/下定义一个包 c。在包 c 的源码中只需声明为package c，而不是声明为package a/b/c，但是在导入 c 包时，需要带上路径，例如import "a/b/c"。

包的习惯用法：

  • 包名一般是小写的，使用一个简短且有意义的名称。
  • 包名一般要和所在的目录同名，也可以不同，包名中不能包含-等特殊符号。
  • 包一般使用域名作为目录名称，这样能保证包名的唯一性，比如 GitHub 项目的包一般会放到GOPATH/src/github.com/userName/projectName目录下。
  • 包名为 main 的包为应用程序的入口包，编译不包含 main 包的源码文件时不会得到可执行文件。
  • 一个文件夹下的所有源码文件只能属于同一个包，同样属于同一个包的源码文件不能放在多个文件夹下。

# 9.1.2 自定义包

我们创建的自定义的包需要将其放在 GOPATH 的 src 目录下（也可以是 src 目录下的某个子目录），而且两个不同的包不能放在同一目录下，这样会引起编译错误。一个包中可以有任意多个文件，文件的名字也没有任何规定（但后缀必须是 .go），这里我们假设包名就是 .go 的文件名（如果一个包有多个 .go 文件，则其中会有一个 .go 文件的文件名和包名相同）。

下面通过示例来演示一下如何创建一个名为 demo 的自定义包，并在 main 包中使用自定义包 demo 中的方法。

在 GOPATH 下的 src 目录中新建一个 demo 文件夹 ，并在 demo 文件夹下创建 demo.go 文件，demo.go文件内容如下：

package demo

import "fmt"

var Adata int = 5
var bdata int = 6

func PrintA() {
	fmt.Println(Adata)
}

func printB() {
	fmt.Println(bdata)
}
  1. 首先包要求在同一个目录下的所有文件的第一行添加如下代码，以标记该文件归属的包：

package 包名

包的特性如下：

  • 一个目录下的同级文件归属一个包。
  • 包名可以与其目录不同名。
  • 包名为 main 的包为应用程序的入口包，编译源码没有 main 包时，将无法编译输出可执行的文件。

所以demo包第一行 package demo 即表明了该文件在包 demo 中。

  1. 在 Go语言中，如果想在一个包里引用另外一个包里的标识符（如类型、变量、常量等）时，必须首先将被引用的标识符导出，将要导出的标识符的首字母大写就可以让引用者可以访问这些标识符了。通俗点，需要其他包能引用自定义包的函数 变量或者类型的时候，则需要将该 变量 函数 类型定义首字母大写，在我们自己定义的 demo 包中， Adata变量， PrintA()函数是可以被外界调用的，而 printB()函数， bdata变量只能在本包内调用。

    同样的在被导出的结构体或接口中，如果它们的字段或方法首字母是大写，外部可以访问这些字段和方法，首字母小写则不可。

# 9.1.3 包的导入

在 9.1.2 包的自定义完成后，我们需要在使用该包的地方调用包方法 变量或者类型，则需要先导入包，导入有两种基本格式，即单行导入和多行导入，两种导入方法的导入代码效果是一致的。

  • 单行导入

    单行导入格式如下：

    import "包1的路径"
import "包2的路径"

  • 多行导入

    当多行导入时，包名在 import 中的顺序不影响导入效果，格式如下：

    import(
    "包1的路径"
    "包2的路径"
    …
)

  • 匿名导入

    在引用某个包时，如果只是希望执行包初始化的 init 函数，而不使用包内部的数据时，可以使用匿名引用格式，如下所示：

    import _ "fmt"

    匿名导入的包与其他方式导入的包一样都会被编译到可执行文件中。

  • 自定义别名导入

    在导入包的时候，我们还可以为导入的包设置别名，如下所示：

    import F "fmt"

    其中 F 就是 fmt 包的别名，使用时我们可以使用F.来代替标准引用格式的fmt.来作为前缀使用 fmt 包中的方法。示例代码如下：

    package main
import F "fmt"
func main() {
    F.Println("C语言中文网")
}

包的引用路径有两种写法，分别是全路径导入和相对路径导入。

绝对路径

包的绝对路径就是GOROOT/src/或GOPATH/src/后面包的存放路径，如下所示：

import "lab/test"
import "database/sql/driver"
import "database/sql"

上面代码的含义如下：

  • test 包是自定义的包，其源码位于GOPATH/src/lab/test目录下；
  • driver 包的源码位于GOROOT/src/database/sql/driver目录下；
  • sql 包的源码位于GOROOT/src/database/sql目录下。

相对路径

相对路径只能用于导入GOPATH下的包，标准包的导入只能使用全路径导入。

例如包 a 的所在路径是GOPATH/src/lab/a，包 b 的所在路径为GOPATH/src/lab/b，如果在包 b 中导入包 a ，则可以使用相对路径导入方式。示例如下：

// 相对路径导入
import "../a"

当然了，也可以使用上面的全路径导入，如下所示：

// 全路径导入
import "lab/a"

# 9.2 常用内置包

# 9.2.1 time包

  • # 当前时间

    import (
	"fmt"
	"time"
)

func main() {
	now := time.Now() //获取当前CST时间
	fmt.Println("CST:", now)
	fmt.Println("Year:", now.Year()) //输出当前cst时间年份
	fmt.Println("Month:", now.Month()) //输出当前cst时间月份,英文格式
	fmt.Println("int Month:", int(now.Month())) //输出当前cst时间月份,数字格式
	fmt.Println("Day:", now.Day()) //输出当前cst时间日
	fmt.Println("Hour:", now.Hour()) //输出当前cst时间小时
	fmt.Println("Minute:", now.Minute()) //输出当前cst时间分针
	fmt.Println("Second:", now.Second()) //输出当前cst时间秒
	fmt.Println("Unix:", now.Unix()) //输出当前cst时间秒时间戳
	fmt.Println("UnixNano:", now.UnixNano()) //输出当前cst时间纳秒时间戳
	fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second()) //2021-04-15 17:02:31格式时间
}

    输出结果：

    CST: 2021-04-15 17:22:47.9992393 +0800 CST m=+0.004983801
Year: 2021
Month: April
int Month: 4
Day: 15
Hour: 17
Minute: 22
Second: 47
Unix: 1618478567
UnixNano: 1618478567999239300
2021-04-15 17:22:47

  • 时间戳与日期转换（时间格式化）

    时间类型有一个自带的方法Format与ParseInLocation进行日期和时间戳格式化与转换，需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S而是使用Go的诞生时间2006年1月2号15点04分。

    import (
	"fmt"
	"time"
)

func main() {

	u := 1618437813 //变量U，存放时间戳

	//时间戳转字符串日期格式, golang转换模式时间只能是 "2006-01-02 15:04:05" 这个go的诞生时间
	f1 := time.Unix(int64(u), 0).Format("2006-01-02 15:04:05")    //时间戳转为 2006-01-02 15:04:05 格式日期
	f2 := time.Unix(int64(u), 0).Format("2006/01/02 15/04/05")    //时间戳转为 2006/01/02 15/04/05 格式日期
	f3 := time.Unix(int64(u), 0).Format("2006-01-02 15:04:05 PM") //时间戳转为 2006-01-02 15:04:05 PM 格式日期
	fmt.Println(f1)
	fmt.Println(f2)
	fmt.Println(f3)

	//字符串日期格式转时间戳转
	u1 := "2018-05-05 17:55:22"                                         //变量u1,存放日期
	t, _ := time.ParseInLocation("2006-01-02 15:04:05", u1, time.Local) //将字符串转为当前时间戳
	fmt.Println("Unix:", t.Unix())
}

    输出结果：

    2021-04-15 06:03:33
2021/04/15 06/03/33
2021-04-15 06:03:33 AM
Unix: 1525514122

  • 时间操作

    我们在日常的编码过程中可能会遇到要求时间增加 减少以及判断是否相关操作，下面可以利用以下函数对时间进行操作，详情具体参考代码：

    import (
	"fmt"
	"time"
)

func main() {

	now := time.Now()                                                   //获取当前CST时间
	f1 := time.Unix(int64(now.Unix()), 0).Format("2006-01-02 15:04:05") //当前时间日期
	fmt.Println(f1)

	addNow := now.Add(time.Hour * 24) //新增24小时
	d, _ := time.ParseDuration("+48h")
	addNow2 := now.Add(d)                                                      //新增48小时
	addf1 := time.Unix(int64(addNow.Unix()), 0).Format("2006-01-02 15:04:05")  //增加24小时后的时间日期
	addf2 := time.Unix(int64(addNow2.Unix()), 0).Format("2006-01-02 15:04:05") //增加48小时后的时间日期
	fmt.Println(addf1)
	fmt.Println(addf2)

	subNow := now.Sub(addNow2)                            //比较两个时间相差
	fmt.Println(subNow, subNow.Hours(), subNow.Seconds()) //打印相差的时间 小时 以及秒

	u1 := "2018-05-05 17:55:22"
	u2 := "2018-05-05 17:55:22"
	u3 := "2018-05-18 17:55:22"
	e1, _ := time.ParseInLocation("2006-01-02 15:04:05", u1, time.Local) //将u1日期转为time格式
	e2, _ := time.ParseInLocation("2006-01-02 15:04:05", u2, time.Local) //将u2日期转为time格式
	e3, _ := time.ParseInLocation("2006-01-02 15:04:05", u3, time.Local) //将u3日期转为time格式
	fmt.Println("e1 = e2 ? ", e1.Equal(e2))                              //比较时间1与时间2是否相等
	fmt.Println("e1 = e3 ? ", e1.Equal(e3))                              //比较时间1与时间3是否相等

	fmt.Println("e1 < e2 ? ", e1.After(e2))  //判断时间1在时间2之后
	fmt.Println("e1 < e3 ? ", e1.Before(e3)) //判断时间1在时间3前面
	fmt.Println("e3 > e1 ? ", e3.After(e1))  //判断时间3在时间1之后
}

    输出结果：

    2021-04-15 18:32:02
2021-04-16 18:32:02
2021-04-17 18:32:02
-48h0m0s -48 -172800
e1 = e2 ?  true
e1 = e3 ?  false
e1 < e2 ?  false
e1 < e3 ?  true
e3 > e1 ?  true

  • 定时器

    time包的定时器主要有 time.Timer 与 time.Ticker 两类，time.Timer 主要函数有：

    • func NewTimer(d Duration) *Timer 创建一个 Timer
    • func (t *Timer) Stop() bool 停止Timer
    • func (t *Timer) Reset(d Duration) bool 重置Timer

    time.Timer 使用示例：

    import (
	"fmt"
	"time"
)

func main() {
	timer := time.NewTimer(5 * time.Second) //创建一个5秒的Timer
	i := 0
	defer timer.Stop() //程序结束后关闭Timer
	go func() {
		for {
			select {
			case <-timer.C: //超时后处理
				i++
				if i < 5 {
					timer.Reset(1 * time.Second) //重置Timer为1秒
				}
				fmt.Println("I Love you")
			}
		}
	}()
	time.Sleep(15 * time.Second)
	fmt.Println("run end")
}

    输出结果：

    I Love you
I Love you
I Love you
I Love you
I Love you
run end

    如果学会了Timer那么Ticker就很简单了，Timer和Ticker结构体的结构是一样的，举一反三，其实Ticker就是一个重复版本的Timer，它会重复的在时间d后向Ticker中写数据

    • func NewTicker(d Duration) *Ticker // 新建一个Ticker
    • func (t *Ticker) Stop() // 停止Ticker
    • func Tick(d Duration) <-chan Time // Ticker.C 的封装

    Ticker 和 Timer 类似，区别是：Ticker 中的runtimeTimer字段的 period 字段会赋值为 NewTicker(d Duration) 中的d，表示每间隔d纳秒，定时器就会触发一次。使用示例：

    import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(1 * time.Second) //创建一个间隔为1秒的 Ticker，也可以使用 time.Tick(1 * time.Second)创建
	defer ticker.Stop()                       //程序结束后关闭ticker
	go func() {
		for {
			select {
			case <-ticker.C: //超时后处理
				fmt.Println("I Love you")
			}
		}
	}()
	time.Sleep(15 * time.Second)
	fmt.Println("run end")
}

    也可以使用 range 处理 Ticker，改写代码如下：

    import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(1 * time.Second) //创建一个间隔为1秒的 Ticker，也可以使用 time.Tick(1 * time.Second)创建
	defer ticker.Stop()                       //程序结束后关闭ticker
	go func() {
		for t := range ticker.C {
			fmt.Println(t)
			fmt.Println("I Love you")
		}
	}()
	time.Sleep(15 * time.Second)
	fmt.Println("run end")
}

# 9.2.2 runtime包

最后更新时间: 3/2/2023, 4:55:04 PM

←