目录
一、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-d-d d:d:d\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:373. 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-d-d d:d:d\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()) // 16412875312. 时间间隔常量
// 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) // 1h0m0s3. 实践操作函数：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) // false4. 定时器：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内存地址0xc00001c0903. 指针传值
每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。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 用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针。
,
