七叶笔记 » golang编程 » golang中级进阶(一):time包、日期函数、指针详解

golang中级进阶(一):time包、日期函数、指针详解

目录

一、time包

1. time包的基本使用

2. format 格式化时间

3. unix 时间戳相互转换

二、日期函数

1. 字符串 转时间戳

2. 时间间隔常量

3. 实践操作函数:Add、Sub、Equal、Befor、After

4. 定时器:Ticker、Sleep

三、指针

1. 定义指针

2. 指针取值

3. 指针传值

4. new make函数

一、time包

1. time包的基本使用

 package main
 
 import  (
    "fmt"
    "time"
)
 
func main() {
    // 1.time包引用及基本使用
now := time.Now()
fmt.Println(now) // 2022-04-08 15:07:36.11502 +0800 CST m=+0.000130549
// 获取可阅读的
Y := now.Year()
m := now.Month()
d := now.Day()
H := now.Hour()
i := now. Minute ()
s := now.Second()
fmt.Printf("%d-%d-%d %d:%d:%d\n", Y, m, d, H, i, s)           // 2022-4-8 15:12:51
fmt.Printf("%d-%.2d-%.2d %.2d:%.2d:%.2d\n", Y, m, d, H, i, s) // 2022-04-08 15:13:22
fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", Y, m, d, H, i, s) // 2022-04-08 15:13:22
}  

2. format 格式化时间

由于golang诞生于2006年01月02日 15点04分05秒,所以格式化的方式为:

12小时制:2006-01-02 03:04:05

24小时制:2006-01-02 15:04:05

     // 2. format 格式化时间
/*
由于 go 诞生于2006年01月02号 15点04分05秒。所以格式化的方式:
12小时制:2006-01-02 03:04:05
24小时制:2006-01-02 15:04:05
*/fmt.Println(now.Format("2006-01-02 15:04:05")) //2022-04-08 15:22:37
fmt.Println(now.Format("2006-01-02 03:04:05")) //2022-04-08 03:22:37  

3. unix 时间戳相互转换

time.Unix(第一个参数接受的int64格式的,0)

 // 3. 获取当前unix时间戳
timestamp1 := now.Unix()     // 毫秒级别
timestamp2 := now.UnixNano() // 纳秒级别(较少使用)
fmt.Println(timestamp1)      // 1649402681
fmt.Println(timestamp2)      // 1649402681151226000
 
// 4.1格式化时间戳
timestamp := 1649402681
timeObj := time.Unix(int64(timestamp), 0)
fmt.Println(timeObj) // 2022-04-08 15:24:41 +0800 CST
 
year := timeObj.Year()
month := timeObj.Month()
day := timeObj.Day()
hour := timeObj.Hour()
minute := timeObj.Minute()
second := timeObj.Second()
fmt.Printf("%d-%d-%d %d:%d:%d\n", year, month, day, hour, minute, second)           // 2022-4-8 15:24:41
fmt.Printf("%d-%.2d-%.2d %.2d:%.2d:%.2d\n", year, month, day, hour, minute, second) // 2022-04-08 15:24:41
fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second) // 2022-04-08 15:24:41
 
// 4.2 利用format格式化
fmt.Println(timeObj.Format("2006-01-02 03:04:05")) // 2022-04-08 03:24:41
fmt.Println(timeObj.Format("2006-01-02 15:04:05")) // 2022-04-08 15:24:41  

二、日期函数

1. 字符串转时间戳

 // 5. 字符串转换成时间戳
t1 := "2022-01-04 17:12:11"
tmp := "2006-01-02 15:04:05"
end, _ := time.ParseInLocation(tmp, t1, time.Local) // 参数为:格式,要转换的时间,暂时未知。返回两个值 time error
fmt.Println(end.Unix())                             // 1641287531  

2. 时间间隔常量

 // 6. 时间间隔常量
fmt.Println(time.Nanosecond)  // 1ns
fmt.Println(time.Microsecond) // 1µs
fmt.Println(time.Millisecond) // 1ms
fmt.Println(time.Second)      // 1s
fmt.Println(time.Minute)      // 1m0s
fmt.Println(time.Hour)        // 1h0m0s  

3. 实践操作函数:Add、Sub、Equal、Befor、After

 // 7. 时间操作函数:Add增加时间,Sub时间差值,Equal判断时间相等,Befor判断是否在之后,After判断是否在之前
t2 := time.Now()
fmt.Println(t2) // 2022-04-08 16:58:58.56189 +0800 CST m=+0.000248774
later := t2.Add(time.Hour)
fmt.Println(later) // 2022-04-08 17:58:58.56189 +0800 CST m=+3600.000248774
 
sub := now.Sub(later)
fmt.Println(sub) // -1h0m0.000224485s
 
equal := now.Equal(later)
fmt.Println(equal) // false
 
befor := now.Before(later)
fmt.Println(befor) // true
 
after := now.After(later)
fmt.Println(after) // false  

4. 定时器:Ticker、Sleep

 // 8.定时器 1.ticker 2.sleep
ticker := time.NewTicker(time.Second) // 时间间隔为1秒
n := 5
// ticker.C 只返回一个值
for v := range ticker.C {
fmt.Println(v) // 每隔一秒执行一次
n--
if n == 0 {
ticker.Stop() // 终止执行,如果没有stop 会占用内存
break
}
}
for {
time.Sleep(time.Second)
fmt.Println("我在执行......")
}  

三、指针

1. 定义指针

指针也是一个变量,但它是一种特殊的变量,它存储的数据不是一个普通的值,而是另 一个变量的内存地址。

通过前面的教程我们知道变量是用来存储数据的,变量的本质是给存储数据的内存地址 起了一个好记的别名。比如我们定义了一个变量 a := 10 ,这个时候可以直接通过 a 这个变量 来读取内存中保存的 10 这个值。在计算机底层 a 这个变量其实对应了一个内存地址。

 package main
 
import "fmt"
 
func main() {
    // 定义指针
var a = 10
fmt.Printf("a的值为:%v a的类型:%T a的内存地址:%p\n", a, a, &a) // a的值为:10 a的类型:int a的内存地址:0xc00001c070
p := &a
fmt.Printf("p的值:%v p的类型:%T p的内存地址:%p\n", p, p, &p) // p的值:0xc00001c070 p的类型:*int p的内存地址:0xc00000e030
*p = 21
fmt.Printf("a的值为:%v a的类型:%T a的内存地址:%p\n", a, a, &a) // a的值为:21 a的类型:int a的内存地址:0xc00001c070
 
}  

2. 指针取值

要搞明白 Go 语言中的指针需要先知道 3 个概念:指针地址、指针类型和指针取值 Go 语言中的指针操作非常简单,我们只需要记住两个符号:&(取地址)和 *(根据地址 取值)

 // 指针取值 *xxx
var b = 10
c := &b
d := *c
fmt.Printf("b值%v b类型%T b内存地址%p\n", b, b, &b) // b值10 b类型int b内存地址0xc0000b2020
fmt.Printf("c值%v c类型%T c内存地址%p\n", c, c, &c) // c值0xc0000b2020 c类型*int c内存地址0xc0000ac028
fmt.Printf("d值%v d类型%T d内存地址%p\n", d, d, &d) // d值10 d类型int d内存地址0xc00001c090  

3. 指针传值

每个变量在运行时都拥有一个地址,这个地址代表变量在内存中的位置。Go 语言中使用& 字符放在变量前面对变量进行取地址操作。 Go 语言中的值类型(int、 float bool string 、 array、 struct )都有对应的指针类型,如:*int、*int64、*string 等。

 package main
 
import "fmt"
 
func fn1(x int) {
x = 10
}
 
func fn2(x *int) {
*x = 20
}
 
func main() {
    // 指针传值 引用数据类型 随之改变
var e = 5
fn1(e)
fmt.Println(e) // 5
fn2(&e)
fmt.Println(e) // 20
}  

取地址操作符&和取值操作符*是一对互补操作符,&取出地址,*根据地址取出地址 指向的值。

4. new make函数

在 Go 语言中对于引用类型的变量,我们在使用 的时候不仅要声明它,还要为它分配内存空间,否则我们的值就没办法存储。而对于值类型 的声明不需要分配内存空间,是因为它们在声明的时候已经默认分配好了内存空间。要分配 内存,就引出来今天的 new 和 make。 Go 语言中 new 和 make 是内建的两个函数,主要用 来分配内存。

 // new make
// make针对 slice map channel 而 new 针对 指针
var userinfo map[string]string
userinfo["username"] = "张三"
fmt.Println(userinfo) //panic: assignment to entry in nil map 报错原因就是map是引用数据类型需要make创建
 
var user = make(map[string]string)
user["username"] = "张三"
fmt.Println(user) // map[username:张三]
 
var f *int
*f = 100
fmt.Println(*f) // panic:  runtime error : invalid memory address or nil pointer dereference 报错原因一致
 
 var  g *int
g = new(int)
*g = 100
fmt.Println(*g) // 100 主要原因是要分配一个内存地址  

new 与 make 的区别:

1. 二者都是用来做内存分配的。

2. make 只用于 slice、map 以及 channel 的初始化,返回的还是这三个引用类型本身

3. 而 new 用于类型的内存分配,并且内存对应的值为类型零值,返回的是指向类型的指针。

相关文章