Go语言中的包机制

包的声明与导入

包(package)是Go语言中实现代码复用的重要手段。包的存在可以让我们只关心包中的有用的函数。

Go语言自带100多个标准包，这些包使Go语言用起来便捷，进行服务器端、Web端编程几乎不需要第三方框架就可以开发。

可依据函数、接口、方法之间的关联性来对包进行划分，关联性高的功能会放在一个包内，便于理解和后续修改维护。这种模块化特性，允许我们在不同的项目内甚至世界范围内共享和复用代码。

指定编译的速度快是Go语言的优势：

导入方便 : 每个源码文件用到的导入文件都在开头显式地列出来，这样编译器就不需要遍历文件查找。
避免循环引用 : Go语言避免循环引用，也就是说引用都是有向无环的引用。
编译速度快 : Go语言编译输出的目标文件不仅记录自己的导出信息，也记录依赖包的导出信息，所以在一个包内很快可以编译整个包的文件。

init函数

package main

//init()函数在main函数执行之前进行执行，init用在设置包，初始化变量或者程序运行之前优先完成的引导工作
//即使包被导入多次，初始化只需要一次
//匿名导包
import (
	_ "bao/test"
	"fmt"
)

// init函数不需要传入参数，也不会返回任何值。与main相比而言，init没有被声明，因此不会被引用
func init() {
	fmt.Println("main-init")
}

func main() {
	fmt.Println("main")
}

Text文件夹下

import "fmt"
import _ "bao/test2"

func init() {
	fmt.Println("test-a-init1")
}
func init() {
	fmt.Println("test-a-init2")
}
func init() {
	fmt.Println("test-a-init3")
}



import "fmt"

func init() {
	fmt.Println("test2-b-init1")
}
func init() {
	fmt.Println("test2-b-init2")
}
func init() {
	fmt.Println("test2-b-init3")
}

strings包常用函数

func main() {
	//定义一个字符串
	str := "xuexiangban,nansang"
	//判断是否包含
	fmt.Println(strings.Contains(str, "z"))
	fmt.Println(strings.Contains(str, "g"))
	//containAny模糊查询查找，任意一个存在即可
	fmt.Println(strings.ContainsAny(str, "ghk"))
	//Count在字符中出现的次数
	fmt.Println(strings.Count(str, "a"))
	//HasPrefix以。。。开头
	filename := "20031016.mp4"
	if strings.HasPrefix(filename, "2003") {
		fmt.Println("我找到了2003年的文件")
	}
	//HasSuffix结尾

	if strings.HasSuffix(filename, ".mp4") {
		fmt.Println("是以.MP4结尾的文件")
	}
	//index 寻找指定字符串任意字符第一次出现的位置，找到并返回下标，找不到返回-1
	fmt.Println(strings.Index(str, "a"))
	//indexAny 跟containsAny一样
	fmt.Println(strings.IndexAny(str, "ghk"))
	//LastIndex 字符串最后一次出现的位置
	fmt.Println(strings.LastIndex(str, "a"))
	//Join用指定符号进行字符串拼接
	str2 := []string{"a", "b", "c"}
	str3 := strings.Join(str2, "-")
	fmt.Println(str3)
	//Split按照指定符号分割
	str4 := strings.Split(str3, "-")
	fmt.Println(str4)
	//Repeat
	str5 := strings.Repeat("a", 5)
	fmt.Println(str5)
	//Replace替换指定的字符
	str6 := strings.Replace(str, "u", "*", -1)
	fmt.Println(str6)
	//ToUpper字母转大写ToLower字母转小写
	fmt.Println(strings.ToUpper(str))
	fmt.Println(strings.ToLower(str))
	//截取字符串
	str7 := str[0:5]
	fmt.Println(str7)
	str8 := str[5:]
	fmt.Println(str8)

}

strconv包常用函数

// Parse把字符串转换成相应的类型
// Format把类型转换成字符串
// 10 int atoi数字字符串转换成十进制  itoa十进制转换成数字字符串
func main() {
	s1 := "true"
	//将字符串转换成bool类型
	b1, _ := strconv.ParseBool(s1)
	fmt.Printf("%T\n", b1)
	fmt.Println(b1)
	if b1 {
		fmt.Println("b1是bool类型")
	}
	s2 := strconv.FormatBool(b1)
	fmt.Printf("%T\n", s2)
	fmt.Println(s2)
	//把字符串看成以十进制的形式转换
	s3 := "100"
	i1, _ := strconv.ParseInt(s3, 10, 64)
	fmt.Println(i1)
	//整型转换成二进制的字符串
	s4 := strconv.FormatInt(100, 2)
	fmt.Printf("%T\n", s4)
	fmt.Println(s4)
	//10 int atoi  itoa
	i2, _ := strconv.Atoi("-20")
	fmt.Printf("%T\n", i2)
	fmt.Println(i2)
	str := strconv.Itoa(i2)
	fmt.Printf("%T\n", str)
	fmt.Println(str)

}

时间与时间戳

func main() {
	timestamp := time.Now().Unix()
	fmt.Println(timestamp)
	time1 := time.Unix(timestamp, 0)
	fmt.Println(time1)

	//time1()
	now := time.Now()
	fmt.Println(now.Format("2006-01-02 15:04:05"))
	fmt.Println(now.Date())
	//把字符串转换成Time对象的方法
	loc, _ := time.LoadLocation("Asia/Shanghai")
	timeObj, _ := time.ParseInLocation("2006/01/02 15:04:05", "2023/01/01 12:12:00", loc)
	fmt.Println(timeObj)
}

func time1() {
	//获取当前时间
	now := time.Now()
	fmt.Println(now)
}

随机数生成

func main() {
	//rand.Seed(11)
	//num1 := rand.Intn(10)//Intn(10) [0,9)
	//fmt.Println(num1)
	//设置随机数，可以设置时间戳
	rand.Seed(time.Now().Unix())
	for i := 0; i < 10; i++ {
		num := rand.Intn(100)
		fmt.Println(num)

	}
}

定时器与时间判断

func main() {
	tick心脏  想象成一个通道每隔一秒放一个数据
	//ticker := time.Tick(time.Second)
	//for t := range ticker {
	//	fmt.Println(t)
	//}
	//
	//for i := 0; i < 10; i++ {
	//	fmt.Println(time.Now())
	//	time.Sleep(time.Second)
	//}
	now := time.Now()
	later := now.Add(time.Hour)
	fmt.Println(now)
	fmt.Println(later)

	subtime := later.Sub(now)
	fmt.Println(subtime)
	fmt.Println(now.Equal(later))
	fmt.Println(now.After(later))
	fmt.Println(now.Before(later))
}