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 用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针。