Go 的标准库

Go语言的标准库覆盖网络、系统、加密、编码、图形等各个方面，可以直接使用标准库的 http 包进行 HTTP 协议的收发处理；网络库基于高性能的操作系统通信模型（Linux 的 epoll、Windows 的 IOCP）；所有的加密、编码都内建支持，不需要再从第三方开发者处获取

Go 语言的编译器也是标准库的一部分，通过词法器扫描源码，使用语法树获得源码逻辑分支等。Go 语言的周边工具也是建立在这些标准库上。在标准库上可以完成几乎大部分的需求

Go 语言的标准库以包的方式提供支持，下表是 Go 语言标准库中常见的包及其功能

Go语言标准库包名	功能
bufio	带缓冲的 I/O 操作
bytes	实现字节操作
container	封装堆、列表和环形列表等容器
crypto	加密算法
database	数据库驱动和接口
debug	各种调试文件格式访问及调试功能
encoding	常见算法如 JSON、XML、Base64 等
flag	命令行解析
fmt	格式化操作
go	Go 语言的词法、语法树、类型等。可通过这个包进行代码信息提取和修改
html	HTML 转义及模板系统
image	常见图形格式的访问及生成
io	实现 I/O 原始访问接口及访问封装
math	数学库
net	网络库，支持 Socket、HTTP、邮件、RPC、SMTP 等
os	操作系统平台不依赖平台操作封装
path	兼容各操作系统的路径操作实用函数
plugin	Go 1.7 加入的插件系统。支持将代码编译为插件，按需加载
reflect	语言反射支持。可以动态获得代码中的类型信息，获取和修改变量的值
regexp	正则表达式封装
runtime	运行时接口
sort	排序接口
strings	字符串转换、解析及实用函数
time	时间接口
text	文本模板及 Token 词法器

fmt（格式化操作）

动词	功能
%v	按值的本来值输出
%+v	在 %v 基础上，对结构体字段名和值进行展开
%#v	输出 Go 语言语法格式的值
%T	输出 Go 语言语法格式的类型和值
%%	输出 % 本体
%b	整型以二进制方式显示
%o	整型以八进制方式显示
%d	整型以十进制方式显示
%x	整型以十六进制方式显示
%X	整型以十六进制、字母大写方式显示
%U	Unicode 字符
%f	浮点数完整精度输出；%.2f 2位精度输出
%p	指针，十六进制方式显示

strings（字符串操作）

 package main
  
 import (
     "fmt"
     "strings"
     "strconv"
 )
  
 func main(){
     var strTest string = " http://www.cnblog.com/kaichenkai "
  
     // 是否以 http:// 开头
     ret1 := strings.HasPrefix(strTest, "http://")
     fmt.Println("HasPrefix result:", ret1)  // HasPrefix result: false
  
     // 是否以 .com 结尾
     ret2 := strings.HasSuffix(strTest, ".com")
     fmt.Println("HasSuffix result:", ret2)  // HasSuffix result: false
  
     // 返回 k 在字符串中首次出现的位置，没有则返回 -1
     ret3 := strings.Index(strTest, "k")
     fmt.Println("Index is:", ret3)  // Index is: 23
  
     // 返回 k 在字符串中最后出现的位置，没有则返回 -1
     ret4 := strings.LastIndex(strTest, "k")
     fmt.Println("LastIndex is:", ret4)  // LastIndex is: 30
  
     // 将 kai 换成 空格，替换1次，返回操作后的结果字符串
     ret5 := strings.Replace(strTest, "kai", " ", 1)
     fmt.Println("replace complete, strTest is:", ret5)  // replace complete, strTest is:  http://www.cnblog.com/ chenkai
  
     // 统计子字符串 kai 的出现次数
     ret6 := strings.Count(strTest, "kai")
     fmt.Println("Count is:", ret6)  // Count is: 2
  
     // 将字符串重复 n 次，返回操作后的结果字符串
     ret7 := strings.Repeat(strTest, 2)
     fmt.Println("Repeat result is:", ret7)  // Repeat result is:  http://www.cnblog.com/kaichenkai  http://www.cnblog.com/kaichenkai
  
     // 转小写
     ret8 := strings.ToLower(strTest)
     fmt.Println("Lower result is:", ret8)  // Lower result is:  http://www.cnblog.com/kaichenkai
  
     // 转大写
     ret9 := strings.ToUpper(strTest)
     fmt.Println("Upper result is:", ret9)  // Upper result is:  HTTP://WWW.CNBLOG.COM/KAICHENKAI
  
     // 去掉收尾空白字符，返回操作后的结果字符串
     ret10 := strings.TrimSpace(strTest)
     fmt.Println("TrimSpace:", ret10)  // TrimSpace: http://www.cnblog.com/kaichenkai
  
     // 去掉首尾指定字符，返回操作后的结果字符串
     ret11 := strings.Trim(strTest, "http://")
     fmt.Println("Trim:", ret11)  // Trim:  http://www.cnblog.com/kaichenkai
  
     // 去掉左侧指定字符，返回操作后的结果字符串
     ret12 := strings.TrimLeft(strTest, " http://")
     fmt.Println("TrimLeft:", ret12)  // TrimLeft: www.cnblog.com/kaichenkai
  
     // 去掉右侧指定字符，返回操作后的结果字符串
     ret13 := strings.TrimRight(strTest, "kai ")
     fmt.Println("TrimRight:", ret13)  // TrimRight:  http://www.cnblog.com/kaichen
  
     // 以空格分割，返回子串的 slice
     ret14 := strings.Fields(strTest)
     fmt.Println("Fields:", ret14)  // Fields: [http://www.cnblog.com/kaichenkai]
  
     // 以 .（点）进行分割，返回子串的 slice
     ret15 := strings.Split(strTest, ".")
     fmt.Println("Split:", ret15)  // Split: [ http://www cnblog com/kaichenkai ]
  
     // 以 $ 将 slice 中的元素进行拼接
     ret16 := strings.Join(ret15, "$")
     fmt.Println("Join:", ret16)  // Join:  http://www$cnblog$com/kaichenkai
  
     // 将整数转换为字符串
     ret17 := strconv.Itoa(1000)
     fmt.Println("Itoa:", ret17)  // Itoa: 1000
  
     // 将字符串转换为数字，前提是字符串是纯数字组成，不然会报错
     ret18, error := strconv.Atoi("100")
     if error == nil{
         fmt.Println("Atoi:", ret18)  // Atoi: 100
     }
 }

time（时间接口）

使用之前需要导入 time 包

time 包中的常量

 const (
     Nanosecond  Duration = 1
     Microsecond  = 1000 * Nanosecond
     Millisecond  = 1000 * Microsecond
     Second       = 1000 * Millisecond
     Minute       = 60 * Second
     Hour         = 60 * Minute
 )

时间的类型为 Duration，而 Duration 实际是一个 int64 的类型，可以转换；

Duration.String() 可以将 Duration 的值转为字符串

获取当前时间

 now := time.Now()
 fmt.Printf("type:%T \n", now)
 fmt.Printf("value:%v \n", now)
  
 运行结果：
 type:time.Time
 value:2019-05-25 17:57:57.9463214 +0800 CST m=+0.003026301

自定义时间

格式：func Parse(layout, value string) (Time, error)

Parse 解析一个格式化的时间字符串并返回它代表的时间。 layout 定义输入的时间格式，value 的时间格式需与 layout 保持一致

     now := time.Now()
     format := now.Format("2006-01-02 15:04:05 Mon Jan")
     t, error := time.Parse("2006-01-02 15:04:05", "2019-05-25 19:00:00")
     if error == nil {
         fmt.Printf("%T \n", t)
         fmt.Printf("%v \n", t)
     }
     fmt.Println(format)
 
  
 运行结果：
 time.Time
 2019-05-25 19:00:00 +0000 UTC 
 2024-08-28 17:29:18 Wed Aug

获取time.Time 类型的年，月，日，时，分，秒

year := time.Now().Year()
month := time.Now().Month()
day := time.Now().Day()
hour := time.Now().Hour()
minute := time.Now().Minute()
second := time.Now().Second(

获取当前时间戳、时间戳转时间

     // 秒级
     timestamp := time.Now().Unix()
     fmt.Printf("秒级时间戳：%v\n", timestamp)
 
     // 毫秒
     milliTimestamp := time.Now().UnixNano() / 1e6
     fmt.Printf("毫秒时间戳：%v\n", milliTimestamp)
 
     // 纳秒
     NanoTimestamp := time.Now().UnixNano()
     fmt.Printf("纳秒时间戳：%v\n", NanoTimestamp)
     
     /*
        将时间戳转化为时间
     */
     //如果时间戳以秒为单位 
     //使用Unix方法将时间戳转换为time.Time类型
     sm := time.Unix(timestamp, 0)
     // 打印转换后的时间
     fmt.Println("秒级 时间戳转换为时间对象:", sm)
     // 如果你想格式化时间输出，可以使用Format方法
     fmt.Printf("秒级 格式化后的时间: %s\n", sm.Format("2006-01-02 15:04:05"))
 
     // 如果时间戳以毫秒为单位
     timestampInSeconds := milliTimestamp / 1000
     hsm := time.Unix(timestampInSeconds, (milliTimestamp%1000)*1e6)
     // 打印转换后的时间
     fmt.Println("毫秒 时间戳转换为时间对象:", hsm)
     // 如果你想格式化时间输出，可以使用Format方法
     fmt.Printf("毫秒 格式化后的时间: %s\n", hsm.Format("2006-01-02 15:04:05"))
     
 运行结果：
 秒级时间戳：1724838703
 毫秒时间戳：1724838703676                                   
 纳秒时间戳：1724838703676957200                             
 秒级 时间戳转换为时间对象: 2024-08-28 17:51:43 +0800 CST    
 秒级 格式化后的时间: 2024-08-28 17:51:43                    
 毫秒 时间戳转换为时间对象: 2024-08-28 17:51:43.676 +0800 CST
 毫秒 格式化后的时间: 2024-08-28 17:51:43

Demo：统计程序运行耗时

 # 方法一
 func stats() {
     time.Sleep(time.Second * 2)
 }
 
 func main() {
     startTime := time.Now()
     stats()
     runDuration := time.Since(startTime)
     fmt.Println("use time:", runDuration)
     fmt.Println(startTime)
     fmt.Printf("type:%T \n", runDuration)
 }
  
 运行结果：
 use time: 2.0046399s
 2024-08-28 17:51:15.5338686 +0800 CST m=+0.001994501
 type:time.Duration
 
 # 方法二
     var startTime int64 = time.Now().Unix()
     stats()
     var endTime int64 = time.Now().Unix()
     fmt.Println("use time:", endTime-startTime)
     fmt.Println(startTime, endTime)
     fmt.Printf("type:%T \n", startTime)
  
 运行结果：
 use time: 2
 1724838589 1724838591
 type:int64

regexp（正则表达式封装）

Syntax

本包采用的正则表达式语法，默认采用perl标志。某些语法可以通过切换解析时的标志来关闭。

         .              任意字符（标志s==true时还包括换行符）
         [xyz]          字符族
         [^xyz]         反向字符族
         \d             Perl预定义字符族
         \D             反向Perl预定义字符族
         [:alpha:]      ASCII字符族
         [:^alpha:]     反向ASCII字符族
         \pN            Unicode字符族（单字符名），参见unicode包
         \PN            反向Unicode字符族（单字符名）
         \p{Greek}      Unicode字符族（完整字符名）
         \P{Greek}      反向Unicode字符族（完整字符名）

结合：

         xy             匹配x后接着匹配y
         x|y            匹配x或y（优先匹配x）

重复：

         x*             重复>=0次匹配x，越多越好（优先重复匹配x）
         x+             重复>=1次匹配x，越多越好（优先重复匹配x）
         x?             0或1次匹配x，优先1次
         x{n,m}         n到m次匹配x，越多越好（优先重复匹配x）
         x{n,}          重复>=n次匹配x，越多越好（优先重复匹配x）
         x{n}           重复n次匹配x
         x*?            重复>=0次匹配x，越少越好（优先跳出重复）
         x+?            重复>=1次匹配x，越少越好（优先跳出重复）
         x??            0或1次匹配x，优先0次
         x{n,m}?        n到m次匹配x，越少越好（优先跳出重复）
         x{n,}?         重复>=n次匹配x，越少越好（优先跳出重复）
         x{n}?          重复n次匹配x

边界匹配：

         ^              匹配文本开始，标志m为真时，还匹配行首
         $              匹配文本结尾，标志m为真时，还匹配行尾
         \A             匹配文本开始
         \b             单词边界（一边字符属于\w，另一边为文首、文尾、行首、行尾或属于\W）
         \B             非单词边界
         \z             匹配文本结尾

转义序列：

         \a             响铃符（\007）
         \f             换纸符（\014）
         \t             水平制表符（\011）
         \n             换行符（\012）
         \r             回车符（\015）
         \v             垂直制表符（\013）
         \123           八进制表示的字符码（最多三个数字）
         \x7F           十六进制表示的字符码（必须两个数字）
         \x{10FFFF}     十六进制表示的字符码
         \*             字面值'*'
         \Q...\E        反斜线后面的字符的字面值

Perl字符族：

         \d             == [0-9]
         \D             == [^0-9]
         \s             == [\t\n\f\r ]
         \S             == [^\t\n\f\r ]
         \w             == [0-9A-Za-z_]
         \W             == [^0-9A-Za-z_]

Demo：匹配判断

匹配判断使用Match方法或MatchString方法，两者区别仅是Match参数为字节类型，MatchString为字符串类型

     text := "12study"
     //匹配,参数为字符串
     matchResult, _ := regexp.MatchString("study", text)
     fmt.Println(matchResult) //true
 
     //匹配，参数为[]byte
     byteMatchResult, _ := regexp.Match(`\d+`, []byte(text))
     fmt.Println(byteMatchResult) //true
 
 运行结果：
 true
 true

Demo：查找

查找主要方法有FindString、FindAllString、FindStringIndex

     text := "2333412studysstudy好好学习"
     //查询所有，指定参数最多查询个数为2， 负数表示查所有，如-1
     queryAllResult := regexp.MustCompilePOSIX(`study`).FindAllString(text, 2)
     fmt.Println(queryAllResult) //[study study]
 
     //查询第一个匹配字符串
     queryResult := regexp.MustCompile("study").FindString(text)
     fmt.Println(queryResult) //study
 
     //最短匹配
     shortTxt := regexp.MustCompile(`st|study`).FindString(text)
     fmt.Println(shortTxt) //st
 
     //最长匹配
     longTxt := regexp.MustCompilePOSIX(`st|study`).FindString(text)
     fmt.Println(longTxt) //study
 
     //查询匹配串位置
     findIdxResult := regexp.MustCompile(`study`).FindStringIndex(text)
     println(findIdxResult)
 
     //Unicode使用，如\p{Han}表示中文
     hanResult := regexp.MustCompile(`[\p{Han}]+`).FindString(text)
     println(hanResult) //好好学习
 
     //非贪婪，添加标识?
     notGreedyResult := regexp.MustCompile(`\d+?3`).FindString(text)
     println(notGreedyResult) //23
     //贪婪
     greedyResult := regexp.MustCompile(`\d+3`).FindString(text)
     println(greedyResult) //2333

strconv（类型转换）

 package main
 
 import (
     "fmt"
     "strconv"
 )
 
 func main() {
     // 将string类型转换为int类型 Atoi()
     num, err := strconv.Atoi("100")
     if err != nil {
         fmt.Printf("err is:%v", err)
     } else {
         fmt.Printf("将string类型转换为int类型: type:%T val:%v\n", num, num)
     }
     // 将int类型转换为string类型 Itoa()
     str1 := strconv.Itoa(123)
     fmt.Printf("将int类型转换为string类型: type:%T val:%v\n", str1, str1)
 
     //将string转换为bool类型 ParseBool()
     b1, err := strconv.ParseBool("1")
     fmt.Println(b1, err)
     b2, err := strconv.ParseBool("aaa")
     fmt.Println(b2, err)
 
     //将string转换为float类型
     f1, err := strconv.ParseFloat("3.1415926535", 64)
     fmt.Printf("%T, %v\n", f1, f1)
 
     //将string转换为int类型
     i1, err := strconv.ParseInt("8", 10, 64)
     fmt.Printf("%T, %v\n", i1, i1)
 
     //将bool转换为string类型
     s64 := strconv.FormatFloat(3.5, 'g', -1, 64)
     s32 := strconv.FormatFloat(3.5, 'g', -1, 32)
     fmt.Printf("%T, %v\n", s64, s64)
     fmt.Printf("%T, %v\n", s32, s32)
 }

Go 的标准库使用