golang第五卷---包以及常用内置包归纳

包以及常用内置包归纳

  • 包的概念
  • math包
  • time包
  • sync包

Go 语言官方的包文档网站:包文档

包的概念

Go语言是使用包来组织源代码的,包(package)是多个 Go 源码的集合,是一种高级的代码复用方案。

任何源代码文件必须属于某个包,同时源码文件的第一行有效代码必须是package pacakgeName 语句,通过该语句声明自己所在的包。

包的习惯用法:

  • 包名一般是小写的,使用一个简短且有意义的名称。
  • 包名一般要和所在的目录同名,也可以不同,包名中不能包含- 等特殊符号。
  • 包名为 main 的包为应用程序的入口包,编译不包含 main 包的源码文件时不会得到可执行文件。
  • 一个文件夹下的所有源码文件只能属于同一个包,同样属于同一个包的源码文件不能放在多个文件夹下。

包的导入

import "包的路径"

分为两种:1、单行导入

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

2、多行导入

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

包的绝对路径就是GOROOT/src/GOPATH后面包的存放路径

包的引用格式
四种:

1、标准引用格式

import "fmt"

2、自定义别名引用格式

//其中F就是fmt包的别名,使用时我们可以使用F.来代替标准引用格式的fmt.来作为前缀使用fmt包中的方法
import F "fmt"

3、省略引用格式

import . "fmt"

这种格式相当于把 fmt 包直接合并到当前程序中,在使用 fmt 包内的方法是可以不用加前缀fmt.,直接引用。

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

import _ "fmt"

math包

  1. Abs(x float64) float64:返回 x 的绝对值。
  2. Ceil(x float64) float64:返回大于或等于 x 的最小整数。
  3. Floor(x float64) float64:返回小于或等于 x 的最大整数。
  4. Max(x, y float64) float64:返回 x 和 y 中的较大值。
  5. Min(x, y float64) float64:返回 x 和 y 中的较小值。
  6. Mod(x, y float64) float64:取余运算
  7. Pow(x, y float64) float64:返回 x 的 y 次方。
  8. Sqrt(x float64) float64:返回 x 的平方根。
  9. Log(x float64) float64:求自然对数
  10. Log2(x float64) float64:求2为底自然对数
  11. Log10(x float64) float64:求10为底自然对数
  12. Sin(x float64) float64:返回 x 的正弦值。
  13. Cos(x float64) float64:返回 x 的余弦值。
  14. Tan(x float64) float64:返回 x 的正切值。
  15. Trunc(x float64):返回x的整数部分
  16. IsNaN(f float64) (is bool):判断f是否表示一个NaN(Not A Number)的值。

Go语言中,除数为0时并不会返回error或者nil,而是返回无穷大—> NAN(正无穷),表明数字太大溢出的情况

time包

在Go语言的 time 包里面有两个时区变量,如下:

  • time.UTC:UTC 时间(协调世界时,是世界上最主要的时间标准之一,如东八区的北京时间是 UTC+8,西五区的纽约时间是 UTC-5)
  • time.Local:本地时间
  1. time.Now() 函数来获取当前的时间对象,然后通过事件对象来获取当前的时间信息
  2. time.Unix() 函数将时间戳转为时间格式,时间戳是自 1970 年 1 月 1 日(08:00:00GMT)至当前时间的总毫秒数,它也被称为 Unix 时间戳(UnixTimestamp)
    如下:
package main
import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()                  //获取当前时间
    timestamp := now.Unix()            //时间戳
    timeObj := time.Unix(timestamp, 0) //将时间戳转为时间格式
    fmt.Println(timeObj)
    year := timeObj.Year()     //年
    month := timeObj.Month()   //月
    day := timeObj.Day()       //日
    hour := timeObj.Hour()     //小时
    minute := timeObj.Minute() //分钟
    second := timeObj.Second() //秒
    fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

运行结果如下:

在这里插入图片描述

  1. func (t Time) Sub(u Time) Duration:求两个时间之间的差值

返回一个时间段 t - u 的值。如果结果超出了 Duration 可以表示的最大值或最小值,将返回最大值或最小值,要获取时间点 t - d(d 为 Duration),可以使用 t.Add(-d)

  1. func (t Time) Equal(u Time) bool:判断两个时间是否相同
  2. func (t Time) Before(u Time) bool:判断一个时间点是否在另一个时间点之前

如果 t 代表的时间点在 u 之前,则返回真,否则返回假

  1. func (t Time) After(u Time) bool:判断一个时间点是否在另一个时间点之后

如果 t 代表的时间点在 u 之后,则返回真,否则返回假。

sync包

  1. sync.Mutex互斥锁,它使得程序互斥访问共享资源(不可以同时访问,独占资源时候可以使用),互斥锁的0值是未锁定的互斥体
  2. sync.RWMutex读写锁,分为两种:读锁和写锁。当一个goroutine获取读锁之后,其他的goroutine如果是获取读锁会继续获得锁,如果是获取写锁就会等待;当一个goroutine获取写锁之后,其他的goroutine无论是获取读锁还是写锁都会等待。
  3. sync.WaitGroup等待组,指的是等待一组goroutine完成

sync.WaitGroup拥有一个内部计数器。当计数器等于0时,则Wait()方法会立即返回。否则它将阻塞执行Wait()方法的goroutine直到计数器等于0时为止。
要增加计数器,我们必须使用Add(int)方法。要减少它,我们可以使用Done()(将计数器减1),也可以传递负数给Add方法把计数器减少指定大小,Done()方法底层就是通过Add(-1)实现的

如下:

wg := &sync.WaitGroup{}

for i := 0; i < 8; i++ {
  wg.Add(1)
  go func() {
    // Do something
    wg.Done()
  }()
}

wg.Wait()
// 继续往下执行...
  1. sync.Map是一个并发版本的Go语言的map
  • 使用Store(interface {},interface {})添加元素。
  • 使用Load(interface {}) interface {}检索元素。
  • 使用Delete(interface {})删除元素。
  • 使用LoadOrStore(interface {},interface {}) (interface {},bool)检索或添加之前不存在的元素。如果键之前在map中存在,则返回的布尔值为true。
  • 使用Range遍历元素。

示例代码如下:

m := &sync.Map{}

// 添加元素
m.Store(1, "one")
m.Store(2, "two")

// 获取元素1
value, contains := m.Load(1)
if contains {
  fmt.Printf("%s\n", value.(string))
}

// 返回已存value,否则把指定的键值存储到map中
value, loaded := m.LoadOrStore(3, "three")
if !loaded {
  fmt.Printf("%s\n", value.(string))
}

m.Delete(3)

// 迭代所有元素
m.Range(func(key, value interface{}) bool {
  fmt.Printf("%d: %s\n", key.(int), value.(string))
  return true
})
  1. sync.Pool是一个并发池,负责安全地保存一组对象
    两个导出方法:
    Get() interface{} 用来从并发池中取出元素。
    Put(interface{}) 将一个对象加入并发池。

来自各个文章的总结,还有的包还在更新中~

你可能感兴趣的:(golang,golang,开发语言)