Go语言中的包
包的本质:创建不同的文件夹，来存放程序文件。
Go语言的源码复用建立在包 (package）基础之上。
main包
Go语言的入口main()函数所在的包必须是main包。
main包想要引用别的代码，则需要import 导入!
包名为main的包为应用程序的入口包，其他包不能使用。
package
Src目录是以代码包的形式组织并保存Go源码文件的
每个代码包都和src目录下的文件夹——对应，每个子目录都是一个代码包。
代码包包名和文件目录名，不要求一致。比如文件目录叫hello，但是代码包包名可以声明为"main"，但是同一个目录下的源码文件第一行声明的所属包，必须一致!
同一个目录下的所有go文件的第一行添加包定义，以标记该文件归属的包，演示语法:
package 包名
关于包的使用:
-
一个目录下的统计文件归属一个包，package的声明要一致
-
package声明的包和对应的目录名可以不一致，但习惯上还是写成一致的
-
同包下的函数不要导入包，可以直接使用
-
main包, main()的数所在的包，其他的包不能使用·导入包的时候，路径要从src下抒写。src
-
对于包外而言，在导入包的时候可以使用"包名.函数名"的方式使用包内函数。fmt
使用包成员之前先要导入包。导入包的关键字时import
package main
//相对路径导入包
import "./pojo/user"
//包的重命名不仅可以用于解决包名冲突，还可以解决包名过长、避免与变量或常量名称冲突等情况。
import "crypto/rand" //默认模式: rand.Function包实现了用于加解密的更安全的随机数生成器。
import R "crypto/rand" //包的别名:通过别名访问该包下的函数等
import . "crypto/rand" //简便模式:可以直接调用该包下的函数等
import _ "crypto/rand"//匿名导入:仅让该包执行init初始化函数
func main() {
}
Go语言使用名称首字母大小写来判断一个对象（全局变量、全局常量、类型、结构字段、函数、方法)的访问权限，相对于包而言同样如此，包的成员名称首字母大小写决定了该成员的访问权限。首字母大写，可被包外访问，即为public(公开的);首字母小写，则仅包内成员可以访问,即为internal (内部的)
Init()函数
Go语言有一个特殊的函数init，先于main函数执行，实现包级别的—些初始化操作。
init函数会在main函数执行之前进行执行、init用在设置包、初始化交量或者其他要在程序运行前优先完成的引导工作.
即使包被导入多次，初始化只需要—次。
init函数通常被用来
- 对变量进行初始化
- 检查/修复程序的状态
- 注册
- 运行一次计算
每个源文件中可以包含多个init函数
init不能被引用
package main
import (
_ "awesomeProject/lesson09/test" //匿名导入
"fmt"
)
// 1、先执行匿名函数的init方法，再执行main
func main() {
fmt.Println("main-----")
//init() 不能被调用
}
// 2、先执行匿名函数导入,在执行当前函数下的方法，最后main
// init函数不需要传入参数，也不会返回任何职。与main相比而言，init没有被声明，因此也不能被引用
func init() {
fmt.Println("main-->init")
}
//3、再次创建test2包->b 在test->a中导入匿名函数 之后执行结果 顺序：
/*
test2->b->init
test->a->init
main-->init
main-----
*/
init执行顺序
为了使用导入的包，首先必须将其初始化。初始化总是以单线程执行，并且按照包的依赖关系顺序执行。这通过Golang的运行时系统控制，如下图所示:
- 初始化导入的包（递归导入）
- 对包块中声明的变量进行计算和分配初始值
- 执行包中的init函数
包：strings
字符串常用操作
package main
import (
"fmt"
"strings"
)
func main() {
//定义一个字符串
str := "xuexiangban,kuangshenshuo"
// Contains是否包含指定的内容，返回布尔值
fmt.Println(strings.Contains(str, "k")) //在str中是否包含k这个字符
fmt.Println(strings.Contains(str, "ka")) //精确匹配，ka
// ContainsAny 是否包含指定的任意一个内容，有一个即可返回布尔值
fmt.Println(strings.ContainsAny(str, "kz")) //有k或者z字符都为true
// Count 统计指定内容在字符串中出现的次数
fmt.Println(strings.Count(str, "z")) //0次
fmt.Println(strings.Count(str, "k")) //1次
fmt.Println(strings.Count(str, "x")) //2次
// HasPrefix 以xx开头
file := "2022.12.29.mp4"
fmt.Println(strings.HasPrefix(file, "2022"))
// HasSuffix 以xx结尾
fmt.Println(strings.HasSuffix(file, ".mp4"))
// Index 寻找指定字符串第一次出现的位置，找到返回下标，找不到返回 -1
fmt.Println(strings.Index(str, "k")) //k在13 因为从0开始数
fmt.Println(strings.Index(str, "z")) //找不到返回-1
//IndexAny 寻找指定字符串任意字符第一次出现的位置，找到返回下标，找不到返回-1
fmt.Println(strings.IndexAny(str, "x")) //第一个x 为0
fmt.Println(strings.IndexAny(str, "n")) //第7个字母第一次出现n ,为6
//LastIndex 寻找指定字符串最后一次出现的位置，找到返回下标，找不到返回-1
fmt.Println(strings.LastIndex(str, "x")) //3
fmt.Println(strings.LastIndex(str, "n")) //20
// Join 用指定符号进行字符串拼接
str2 := []string{"a", "b", "c", "d"}
fmt.Println(strings.Join(str2, "-"))
// Split 按照指定符号分割字符
str3 := "a-b-c"
str4 := strings.Split(str3, "-") //要用切片接收
fmt.Println(str4)
//Repeat重复拼接自己
str5 := "a"
fmt.Println(strings.Repeat(str5, 3)) //重复拼接3次
// Replace 替换指定字符,n代表替换个数,-1替换全部l
fmt.Println(strings.Replace(str, "x", "*", 1)) //替换str中x字符为*,替换个数为1
fmt.Println(strings.Replace(str, "n", "*", -1)) //替换全部的n字符
//ToUpper 字母转大写 ToLower 字母转小写
fmt.Println(strings.ToUpper(str))
fmt.Println(strings.ToLower(str))
//截取字符串 str[start:end]
fmt.Println(str[0:3]) //截取0-3个字符
}
/*
true
false
true
0
1
2
true
true
12
-1
0
6
3
20
a-b-c-d
[a b c]
aaa
*uexiangban,kuangshenshuo
xuexia*gba*,kua*gshe*shuo
XUEXIANGBAN,KUANGSHENSHUO
xuexiangban,kuangshenshuo
xue
*/
包:strconv
string convert
字符串和基本类型之间的转换
package main
import (
"fmt"
"strconv"
)
func main() {
s1 := "true"
b1, _ := strconv.ParseBool(s1) //返回一个bool和erro 将erro类型丢弃
fmt.Printf("b1类型为：%T\n", b1)
fmt.Println(b1)
if b1 { //b1已经转换为bool类型了
fmt.Println(s1)
}
//int类型转换
s2 := "100"
i1, _ := strconv.ParseInt(s2, 10, 64) //ParseInt:传入的字符串,要转换的进制,int类型的大小
fmt.Printf("i1类型为：%T\n", i1)
fmt.Println(i1)
s3 := strconv.FormatInt(100, 2) //FormatInt: 转换的数字,转换的进制
fmt.Printf("s3类型为：%T\n", s3)
fmt.Println(s3)
//itoa int类型转换为字符串类型
s4 := strconv.Itoa(10)
fmt.Printf("s4类型为：%T\n", s4)
fmt.Println(s4 + "abc")
// atoi 字符串转换为int类型
i2, _ := strconv.Atoi("20")
fmt.Printf("i2类型为：%T\n", i2)
fmt.Println(i2 + 10)
}
/*
b1类型为：bool
true
true
i1类型为：int64
100
s3类型为：string
1100100
s4类型为：string
10abc
i2类型为：int
30
*/
时间与时间戳
time包
时间和日期是我们编程中经常会用到的，本文主要介绍了Go语言内置的time包的基本用法
time包提供了时间的显示和测量用的函数
获取当前时间
func time1() {
t1 := time.Now() //获取当前的时间
fmt.Println(t1)
year := t1.Year()
month := t1.Month()
day := t1.Day()
fmt.Printf("%d-%02d-%02d\n", year, month, day) //%02d不足两位时，用0补齐
}
时间格式化
//时间格式化
now := time.Now()
fmt.Println(now.Format("2006-01-02 15:04:05"))
fmt.Println(now.Format("2006/01/02 15:04:05"))
fmt.Println(now.Format("2006/01/02 15:04"))
解析字符串格式的时间
//时区
loc, _ := time.LoadLocation("Asia/Shanghai")
timeobj, _ := time.ParseInLocation("2006-01-02 15:04:05", "2023-01-01 12:00:00", loc)
fmt.Println(timeobj)
fmt.Println(timeobj.Year())
时间戳
//时间戳
timestamp := time.Now().Unix()
fmt.Println(timestamp) //1672325092
time2 := time.Unix(timestamp, 0) //将时间1672325092转换2022/12/29 22:44:52
fmt.Println(time2)
package main
import (
"fmt"
"time"
)
func main() {
//时间戳
timestamp := time.Now().Unix()
fmt.Println(timestamp) //1672325092
time2 := time.Unix(timestamp, 0) //将时间1672325092转换2022/12/29 22:44:52
fmt.Println(time2)
time1()
//时间格式化
now := time.Now()
fmt.Println(now.Format("2006-01-02 15:04:05"))
fmt.Println(now.Format("2006/01/02 15:04:05"))
fmt.Println(now.Format("2006/01/02 15:04"))
//时区
loc, _ := time.LoadLocation("Asia/Shanghai")
timeobj, _ := time.ParseInLocation("2006-01-02 15:04:05", "2023-01-01 12:00:00", loc)
fmt.Println(timeobj)
fmt.Println(timeobj.Year())
}
func time1() {
t1 := time.Now() //获取当前的时间
fmt.Println(t1)
year := t1.Year()
month := t1.Month()
day := t1.Day()
fmt.Printf("%d-%02d-%02d\n", year, month, day) //%02d不足两位时，用0补齐
}
/*
1672325092
2022-12-29 22:44:52 +0800 CST
2022-12-29 22:44:52.7879446 +0800 CST m=+0.038077101
2022-12-29
2022-12-29 22:44:52
2022/12/29 22:44:52
2022/12/29 22:44
2023-01-01 12:00:00 +0800 CST
2023
*/
随机数生成
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
//rand.Seed(5) //Seed；种子 ，种子不一样，生成的随机数也就不同
//i1 := rand.Int() //如果设置的数字没有改变，那么产生的随机数也不会改变
//fmt.Println(i1)
//i2 := rand.Intn(20) //Intn [0-19)随机产生
//fmt.Println(i2)
rand.Seed(time.Now().Unix()) //时间是不停的变化的，所以，这里生成的种子也不停变换，也就能生成随机数
for i := 0; i < 10; i++ {
//20-29
num := rand.Intn(10) + 20
fmt.Println("num=", num)
}
}
定时器与时间判断
时间间隔常量Duration
utime.Duration是time包定义的一个类型，它代表两个时间点之间经过的时间以纳秒为单位，可表示的最长时间段大约290年。
utime包中定义的时间间隔类型的常量如下:
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Mi77isecond
Minute = 60 * Second
Hour = 60 * Minute
)
time.Duration表示1纳秒 time.second表示1秒
定时器
// Tick 心脏心跳
//tick := time.Tick(time.Second)
//for t := range tick {// 每隔一秒执行一次时间
// fmt.Println(t)
//}
for i := 0; i < 10; i++ {
fmt.Println(time.Now())
time.Sleep(time.Second) //让程序停一秒
}
Sub：求两个时间之间的差值
Equal：判断两个时间是否相同，这种方法还会比较地点和时区信息，因此不同时区标准的时间也可以正确比较。
Before：如果t代表的时间点在u之前，返回真;否则返回假。
After：如果t代表的时间点在u之后，返回真;否则返回假。
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now() //现在时间
later := now.Add(time.Hour) //添加一小时后的时间
fmt.Println(now)
fmt.Println(later)
subtime := later.Sub(now) //later时间与现在相差时间为1h0m0s
fmt.Println(subtime)
fmt.Println(now.Equal(now)) //判断时间是否相同
fmt.Println(now.After(later)) //现在的时间是否在later后面false
fmt.Println(now.Before(later)) //是否在前面true
}