golang 常用包
Go语言中的包. package import
- main 、main() 未来一个项目中只需要一个程序的入口
- init() 函数，在main函数执行之前执行，可以有多个，执行顺序（注册、初始化、一次性的计算… 检查系统环境…）
**strings：**字符串的很多常用方法
- 截取字符串
- 查找字符串
- 替换字符串
- 以xx结尾或者开头
- 统计数量
- …
strconv
bool - 字符串 ，“true” = 转换 true
数字 - 字符串， “3.99” / 转换为数字才可以进行计算
package main
import (
"fmt"
"strconv"
)
// 项目：前端（网页、小程序、app） 后端代码-接收前端的请求
/*
func http(request) response{
string:= request.getUrlParm
// 数据库
// 计算
// 字符串的转换
}
*/
// string convert = strconv
func main() {
// bool
s1 := "true"
// 转化 - 字符串转bool（解析：parse）
// func ParseBool(str string) (bool, error)
b1, err := strconv.ParseBool(s1)
if err != nil {
fmt.Println(err)
return
}
fmt.Printf("%T,%t\n", b1, b1) // bool,true
// bool转字符串（格式化 format）
s2 := strconv.FormatBool(b1)
fmt.Printf("%T,%s\n", s2, s2) // string,true
// 整数->字符串 Format 字符串->整数
s3 := "100000"
// 整数： 数字、进制、大小
// 参数：1、str 2、 进制（10） 3、大小
i1, _ := strconv.ParseInt(s3, 10, 64)
fmt.Printf("%T,%d\n", i1, i1) // int64,100
s4 := strconv.FormatInt(i1, 10)
fmt.Printf("%T,%s\n", s4, s4) // string,100000
// 10进制转换字符串，简便方法 atoi itoa
atoi, _ := strconv.Atoi("-20")
fmt.Printf("%T,%d\n", atoi, atoi) // int,-20
itoa := strconv.Itoa(30)
fmt.Printf("%T,%s\n", itoa, itoa) // string,30
}
time 时间
一切的代码，都是为了解决现实生活中可能出现的业务，时间是很重要的。
time包
- 获取当前时间
- 格式化时间
package main
import (
"fmt"
"time"
)
// time
func main() {
}
// 获取当前时间 now
func time1() {
// 返回值为Time结构体 ： 常量：日月年时分秒 周日-周六 方法：获取常量，计算。
now := time.Now()
year := now.Year()
month := now.Month()
day := now.Day()
hour := now.Hour()
minute := now.Minute()
second := now.Second()
// 2023-2-23 20:40:31
// Printf ： 整数补位--02如果不足两位，左侧用0补齐输出
fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}
func time2() {
//time1()
// 打印时间
now := time.Now()
// 时间格式化 2023-02-23 20:43:49
// 格式化模板： yyyy-MM-dd HH:mm:ss
// Go语言诞生的时间作为格式化模板：2006年1月2号下午3点4分
// Go语言格式化时间的代码：2006-01-02 15:04:05 （记忆方式：2006 12 345）
// 固定的："2006-01-02 15:04:05"
fmt.Println(now.Format("2006-01-02 15:04:05")) // 24小时制
fmt.Println(now.Format("2006-01-02 03:04:05 PM")) // 12小时制
fmt.Println(now.Format("2006/01/02 15:04")) // 2023/02/23 20:52
fmt.Println(now.Format("15:04 2006/01/02")) // 20:52 2023/02/23
fmt.Println(now.Format("2006/01/02")) // 2023/02/23
}
// 将字符串格式化为Time对象 (获取到网页传递的时间字符串，需要转化为Time才能在代码中使用)
func time3() {
// 其他地方的时区格式：https://www.zeitverschiebung.net/cn/all-time-zones.html
// 获取时间的时区 // "Asia/Shanghai" 必须要大写 手动构建 ，如果不对，会报未知的时间错误
loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
fmt.Println(err)
return
}
// 将字符串解析为时间 Time
timeStr := "2023-02-23 20:53:08"
// layout 格式 时间字符串 时区位置 , 需要和前端传递的格式进行匹配
// func ParseInLocation(layout, value string, loc *Location)
timeObj, _ := time.ParseInLocation("2006-01-02 15:04:05", timeStr, loc)
fmt.Println(timeObj)
}
// 时间戳：更多时候和随机数结合
func time4() {
// 格林威治时间自1970年1月1日(00:00:00 GMT)至当前时间的总秒数
// 时间戳 Unix ： 1970.1.1 00:00:00 - 当下的一个毫秒数，Unix 时间戳，不会重复的。
now := time.Now()
timestamp1 := now.Unix() // 时间戳
timestamp2 := now.UnixNano() // 纳秒的时间数
fmt.Println(timestamp1)
fmt.Println(timestamp2)
//
// 通过 Unix 转换time对象
timeObj := time.Unix(timestamp1, 0) // 返回time对象
year := timeObj.Year()
month := timeObj.Month()
day := timeObj.Day()
hour := timeObj.Hour()
minute := timeObj.Minute()
second := timeObj.Second()
// 2023-2-23 20:40:31
// Printf ： 整数补位--02如果不足两位，左侧用0补齐输出
fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}
随机数
package main
import (
"fmt"
"math/rand"
"time"
)
// random随机数- math/rand
func main() {
// 获取一个随机数
num1 := rand.Int()
fmt.Println("num1:", num1) // 5577006791947779410
// 随机需要一个随机数的种子，如果种子一样，那么结果一致
// n范围（0-n）
num2 := rand.Intn(100)
fmt.Println("num2:", num2) // 7
// 需要一个随时都在发生变化的量 时间戳
timestamp := time.Now().Unix()
// 设置随机数种子, 使用时间戳
// 种子只需要设置一次即可。
rand.Seed(timestamp) // 每次执行都不同
for i := 0; i < 5; i++ {
// Intn [0,n)
// 20-29
num1 := rand.Intn(200) // 抽奖程序
// 必中的逻辑
num2 := rand.Intn(5) // 抽奖程序
if i == num2 {
fmt.Println(10)
continue
}
fmt.Println(num1)
}
}
定时器-时间操作
时间间隔常量 Duration
time.Duration是time包定义的一个类型，它代表两个时间点之间经过的时间
以纳秒为单位，可表示的最长时间段大约290年。
time包中定义的时间间隔类型的常量如下：
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)
time.Duration表示1纳秒，time.Second表示1秒。
定时器
// 定时器： 每隔xxx s执行一次, 其余的关于定时器，放到chan讲
ticker := time.Tick(time.Second) // 每一秒都会触发。
for i := range ticker {
fmt.Println(i)
}
时间判断
package main
import (
"fmt"
"time"
)
func main() {
// 加 减 比较（在xxx之前 在xxx之后 相等）
now := time.Now()
later := now.Add(time.Hour)
fmt.Println(later)
// 两个时间的差值
subTime := later.Sub(now)
fmt.Println(subTime) // 1h0m0s
// 比较时间, init() 校验时间 当地时间和网络时间是否一致
fmt.Println(now.Equal(later)) // fasle
fmt.Println(now.Before(later)) // true
fmt.Println(now.After(later)) // fasle
}
// 定时器 - 本质是一个通道chan
func d1() {
// 定时器： 每隔xxx s执行一次, 其余的关于定时器，放到chan讲
ticker := time.Tick(time.Second) // 每一秒都会触发。
for i := range ticker {
fmt.Println(i)
}
}
小案例：
package main
import (
"syscall"
"time"
"unsafe"
)
func main() {
ticker := time.Tick(time.Second) // 每一秒都会触发。
for i := range ticker {
msgBox(i.Format("2006-01-02 15:04:05"))
}
}
func msgBox(timeStr string) {
user32 := syscall.NewLazyDLL("user32.dll")
messageBox := user32.NewProc("MessageBoxW")
hwnd := 0 // 0表示将弹窗放在桌面的中心位置
title := "Hello"
text := timeStr
flags := 0x00000000 | 0x00000040 // 0x00000000表示弹出消息框并且默认按钮为OK，0x00000040表示消息框的图标为信息图标
messageBox.Call(uintptr(hwnd), uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(text))), uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(title))), uintptr(flags))
}
获取文件信息 file
计算机中的文件是存储在外部介质（通常是磁盘）上的数据集合，文件分为文本文件和二进制文件。
file类是在os:操作系统包中的，封装了底层的文件描述符和相关信息，同时封装了Read：读和Write：写的实现。
- 获取文件信息
- 创建目录，创建文件
- IO 读、写
- 文件复制
- 断点续传
- bufio
FileInfo 接口， os.stat() // 获取文件信息
package main
import (
"fmt"
"os"
)
// file
// fileInfo
/*
type FileInfo interface {
Name() string // base name of the file
Size() int64 // length in bytes for regular files; system-dependent for others
Mode() FileMode // file mode bits ： 权限
ModTime() time.Time // modification time
IsDir() bool // abbreviation for Mode().IsDir()
// 获取更加详细的文件信息， *syscall.Stat_t 反射来获取
Sys() any // underlying data source (can return nil)
*/
func main() {
// 获取某个文件的状态
fileinfo, err := os.Stat("D:\\Environment\\GoWorks\\src\\xuego\\lesson11\\demo01.go")
if err != nil {
return
}
fmt.Println(fileinfo.Name()) // demo01.go
fmt.Println(fileinfo.IsDir()) // false
fmt.Println(fileinfo.ModTime()) // 2023-02-23 20:25:43.1772351 +0800 CST
fmt.Println(fileinfo.Size()) // 1186 字节数
fmt.Println(fileinfo.Mode()) // -rw-rw-rw-
}
科普：权限
r：可读 w：可写 x 可执行
- --- --- ---
type owner group ohters
- rw- rw- rw-
d rw- rw- rw-
---，代表的文件读写可执行 字母 r w x，如果没有那个权限就用 - 代替
八进制表示权限
r 004
w 002
x 001
- 000
- rwx rwx rwx
- 4+2+1 4+2+1 4+2+1
chomd 7 7 7
chomd 6 6 6
作业：
- 将我的案例都自己写一遍
- 利用定时器写一些小工具
- 随机数写一个彩票生成器
810
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
