012.Go语言中的包

爷爷的足力健

已于 2023-11-30 15:05:07 修改

阅读量62

点赞数

分类专栏： Golang 文章标签： golang

于 2023-08-14 22:48:49 首次发布

本文链接：https://blog.csdn.net/ZGSDMAN/article/details/131675094

版权

Golang 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1.使用包的注意事项

1.main包:main函数所在的包,不能自定义包名为main
2.src包:存放项目源代码的路径,导包的时候,路径要从src下开始写
3.一个包下的文件,package声明要一致,都是 package 包名
4.package声明的包和对应的包路径名可以不一致,但习惯上还是写成一致的
5.同包下的函数不需要导包,可以直接使用
6.对于包外而言,导入包后可以"包名.函数名"使用包内函数
7.如果函数要给别的包使用首字母要大写

2.导包的多种方式


导入包的几种方式
1.一次导入一个包
	导包:
		import "包名"
	使用:
		包名.结构体名{}
2.一次导入多个包
	导包:
		import (
			"包名1"
			"包名2"
		)
	使用:
		包名1.结构体名{}
3.相对路径导包:基于当前文件位置
	导包:
		import "./pojo"
	使用:
		包名.结构体名{}
4.包名冲突的情况下可以给包起别名
	导包:
		p "goBase/day012/pojo"
	使用:
		别名.结构体名{}
5.简便模式:可以直接使用包里的结构体
	导包:
		. "goBase/day012/pojo"
	使用:
		结构体名{}
6.匿名导入：
	导包:
		_ "goBase/day012/pojo"
	使用:
		自动执行结构体下的init函数; func init() {fmt.Println("init")}

3.init函数

init函数:
	1.先于main函数执行,实现包级别的一些初始化操作
	2.一个go文件种可以定义多个init函数
	3.由于init函数首字母是小写的,不能直接调用init函数
	4.匿名方式导包会自动调用对应包中的init函数

执行顺序:
	1.main包中init函数所在包引入的顺序
	2.init函数所在文件文件名的顺序
	3.同一文件中init函数顺序

//测试
1.test2包下
b.txt
    package test2

    import "fmt"

    func init() {
	    fmt.Println("test2-->b-->init1")
    }
c.txt
    package test2

    import "fmt"

    func init() {
	    fmt.Println("test2-->c-->init1")
    }
2.test包下
a.txt
    package test

    import "fmt"
    import _ "goBase/day012/test2" //匿名导入test2包

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

3.main包下
    package main

    import "fmt"
    import _ "goBase/day012/test" //匿名导入test包


    func init() {
	    fmt.Println("main-->init1")
    }
    func main() {
	    fmt.Println("main")
    }

4.执行结果
    test2-->b-->init1
    test2-->c-->init1
    test-->a-->init1
    test-->a-->init2
    test-->a-->init3
    main-->init1
    main

4.strings包常用函数

1.判断字符串中是否包含指定字符串
	strings.Contains(字符串, 指定字符串)
2.判断字符串中是否包含指定字符串中任意一个字符
	strings.ContainsAny(字符串, 指定字符串)
3.统计指定字符串在字符串中出现的次数
	strings.Count(字符串, 指定字符串)
4.判断字符串是否以指定字符串开头
	strings.HasPrefix(字符串, 指定字符串)
5.判断字符串是否以指定字符串结尾
	strings.HasSuffix(字符串, 指定字符串)
6.查找指定字符串在字符串中第一次出现的位置
	strings.Index(字符串, 指定字符串)
7.查找指定字符串在字符串中最后一次出现的位置
	strings.LastIndex(字符串, 指定字符串)
8.查找指定字符串中任意字符在字符串中第一次出现的位置
	strings.IndexAny((字符串, 指定字符串)
9.将切片按指定分隔符拼接成字符串
	strings.Join(切片, 指定分隔符)
10.将字符串按指定分隔符拆分成切片
	strings.Split(字符串, 指定分隔符)
11.将字符串重复拼接指定次数
	strings.Repeat(字符串, 指定次数)
12.将字符串中指定字符替换为指定个数个新字符
	strings.Replace(字符串, 指定字符, 新字符,指定个数)
13.将字符串中指定字符都替换为新字符
	strings.ReplaceAll(字符串, 指定字符, 新字符)
14.字符串转为大写
	strings.ToUpper(字符串)
15.字符串转为小写
	strings.ToLower(字符串)
16.截取字符串:包头不包尾
	字符串[开始索引:结束索引]

//测试
func main() {
	str := "进击的小张"
	fmt.Println(strings.Contains(str, "小张"))    // true
	fmt.Println(strings.ContainsAny(str, "张三")) //true
	fmt.Println(strings.Count(str, "小张"))       // 1
	fmt.Println(strings.HasPrefix(str, "进击"))   // true
	fmt.Println(strings.HasSuffix(str, "小张"))   // true
	fmt.Println(strings.Index(str, "小张"))       // 9 注:在utf8编码中,一个汉字占三个字节
	fmt.Println(strings.LastIndex(str, "击"))     // 3
	fmt.Println(strings.IndexAny(str, "升龙击"))  // 3
    slice := []string{"h", "e", "l", "l", "o"}
	fmt.Println(strings.Join(slice, "-")) // h-e-l-l-o
	str2 := "a,b,c,d,e"
	fmt.Println(strings.Split(str2, ",")) // [a b c d e]
	fmt.Println(strings.Repeat("张三", 3))  // 张三张三张三
	str3 := "用户名:zhangsan,密码:111111"
	fmt.Println(strings.Replace(str3, "1", "*", 3)) //用户名:zhangsan,密码:***111
	fmt.Println(strings.ReplaceAll(str3, "1", "*")) //用户名:zhangsan,密码:******
	upper := strings.ToUpper(str2)
	fmt.Println(upper)                  //A,B,C,D,E
	fmt.Println(strings.ToLower(upper)) //a,b,c,d,e
	fmt.Println(str3[10:18])            //zhangsan
}

5.strconv包常用函数


strconv:字符串与基本类型之间的相互转换

func main() {
	//1.字符串与布尔类型的相互转换
	//字符串解析为布尔类型
	s1 := "true"
	b1, err1 := strconv.ParseBool(s1)
	if err1 == nil {
		fmt.Printf("b1:%t,type:%T\n", b1, b1) //b1:true,type:bool
		//布尔类型格式换为字符串
		s2 := strconv.FormatBool(b1)
		fmt.Printf("s2:%s,type:%T\n", s2, s2) //s2:true,type:string
	}

	//2.字符串与整型的相互转换
	//字符串解析为整数
	s3 := "6"
	i1, err2 := strconv.ParseInt(s3, 10, 64) // 字符串,进制,整数类型int(0,8,16,32,64)是数据范围,不是指定返回值是指定的类型
	if err2 == nil {
		fmt.Printf("i1:%d,type:%T\n", i1, i1) //i1:6,type:int64
		//整数格式化为字符串
		s4 := strconv.FormatInt(i1, 10)       //整数,进制
		fmt.Printf("s4:%s,type:%T\n", s4, s4) //s4:6,type:string
	}

	//3.字符串与浮点型的相互转换
	//字符串解析为浮点型
	s5 := "3.14"
	f1, err3 := strconv.ParseFloat(s5, 64) //字符串,浮点数类型float(32,64)是数据范围,不是指定返回值是指定的类型
	if err3 == nil {
		fmt.Printf("f1:%f,type:%T\n", f1, f1) //f1:3.140000,type:float64
		//浮点型格式化为字符串 
        //不完全是四舍五入,具体可参考这篇文章：https://blog.csdn.net/xz_studying/article/details/112434821
		s6 := strconv.FormatFloat(f1, 'f', 2, 64) 
		fmt.Printf("s6:%s,type:%T\n", s6, s6)     //s6:3.14,type:string
	}

	//4.字符串与整型的快速转换
	//整数快速转换为字符串
	s7 := strconv.Itoa(8)
	fmt.Printf("s7:%s,type:%T\n", s7, s7) //s7:8,type:string
	//字符串快速转换为整数
	i2, err4 := strconv.Atoi(s7)
	if err4 == nil {
		fmt.Printf("i2:%d,type:%T\n", i2, i2)//i2:8,type:int
	}
}

6.time包常用函数

//时间与时间戳
func main() {
	//1.获取当前时间
	now := time.Now()
	fmt.Println(now)//2023-08-14 22:14:26.75245 +0800 CST m=+0.000162709
	//2.获取年月日时分秒
	year := now.Year()
	month := now.Month()
	day := now.Day()
	hour := now.Hour()
	minute := now.Minute()
	second := now.Second()
	//打印日期:不足两位的用0补齐
	fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)//2023-08-14 22:14:26
	//3.日期转换为字符串
	
	s1 := now.Format("2006-01-02 15:04:05") //24时制
	fmt.Printf("s1,%s,type:%T\n", s1, s1)//s1,2023-08-14 22:14:26,type:string
	
	s2 := now.Format("2006-01-02 03:04:05 PM") //12时制:上午用AM,下午用PM区分
	fmt.Printf("s2,%s,type:%T\n", s2, s2)//s2,2023-08-14 10:14:26 PM,type:string
	//转换为其他形式的日期字符串
	s3 := now.Format("2006-01-02 15:04")
	s4 := now.Format("2006/01/02 15:04:05")
	s5 := now.Format("15:04:05 2006-01-02")
	/*
	2023-08-14 22:14
	2023/08/14 22:14:26
	22:14:26 2023-08-14
	*/
	fmt.Printf("%v\n%v\n%v\n", s3, s4, s5)
	//校验时区:如果存在返回时区标识,不存在则报错
	location, err := time.LoadLocation("Asia/Shanghai")
	if err == nil {
		fmt.Println(location) //Asia/Shanghai
		//4.字符串格式的日期解析为日期格式:  时间格式,时间字符串,时区
		date, err2 := time.ParseInLocation("2006-01-02 15:04:05", s1, location)
		if err2 == nil {
			fmt.Printf("date:%v,type:%T\n", date, date)//date:2023-08-14 22:14:26 +0800 CST,type:time.Time
		}
	}
	//5.时间转换为时间戳
	unix := now.Unix()
	fmt.Println(unix)//1692022466
	//6.时间戳转换为时间对象
	time := time.Unix(unix, 0)
	fmt.Println(time)// 2023-08-14 22:14:26 +0800 CST
}

7.math/rand包生成随机数

func main() {
	//1.设置随机数种子
	// rand.Seed(time.Now().Unix()) 1.20版本之前需要设置随机数种子,不然生成的随机数是一样的
	//2.生成一个随机数
	num := rand.Int()
	fmt.Println(num)
	//3.生成[0,100)之间的随机数
	num2 := rand.Intn(100)
	fmt.Println(num2)
	//4.生成[100,130)之间的随机数
	num3 := rand.Intn(30) + 100
	fmt.Println(num3)
}

8.定时器、时间计算、时间比较

func main() {
	//1.定时器
	tick := time.Tick(time.Second * 3) //每三秒执行一次
	fmt.Println(tick)//地址值
	for t := range tick {
		fmt.Println(t)//每三秒打印一次当前时间
	}
	//2.时间计算
	//获取当前时间
	now := time.Now()
	fmt.Println(now)//2023-08-14 22:44:02.18167 +0800 CST m=+0.000109792
	//获取一个小时之后的时间
	now2 := now.Add(time.Hour)
	fmt.Println(now2)//2023-08-14 23:44:02.18167 +0800 CST m=+3600.000109792
	//获取一个小时之前的时间
	now3 := now.Add(time.Hour * -1)
	fmt.Println(now3)//2023-08-14 21:44:02.18167 +0800 CST m=-3599.999890208
	//获取两个时间的时间差
	sub := now2.Sub(now3)
	fmt.Println(sub) //2h0m0s
	//3.时间比较
	//两个时间是否相等
	fmt.Println(now.Equal(now2))//false
	//时间1是否大于时间2
	fmt.Println(now.After(now2))//false
	//时间1是否小于时间2
	fmt.Println(now.Before(now2))//true
}