golang. - time 时间

Geeks.

于 2024-10-10 19:10:31 发布

阅读量296

点赞数 7

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

本文链接：https://blog.csdn.net/Darling912/article/details/142829869

版权

Go 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

回顾

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

作业：

将我的案例都自己写一遍
利用定时器写一些小工具
随机数写一个彩票生成器

预习：I/O，不预习很痛苦。。

Geeks.

关注

7
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录