golang语言渐入佳境[28]-time包核心方法

time包核心方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
package main

import (
"time"
"fmt"
)

/*
//1、Now()返回当前本地时间

//2、Local()将时间转成本地时区,但指向同一时间点的Time。

//3、UTC()将时间转成UTC和零时区,但指向同一时间点的Time。

//4、Date()可以根据指定数值,返回一个本地或国际标准的时间格式。

//5、Parse()能将一个格式化的时间字符串解析成它所代表的时间。就是string转time

//6、Format()根据指定的时间格式,将时间格式化成文本。就是time转string

//7、String()将时间格式化成字符串,格式为:"2006-01-02 15:04:05.999999999 -0700 MST"

//8、Unix()将t表示为Unix时间(时间戳,一个int64整数),即从时间点January 1, 1970 UTC到时间点t所经过的时间(单位秒)。

//9、UnixNano()将t表示为Unix时间(时间戳,一个int64整数),即从时间点January 1, 1970 UTC到时间点t所经过的时间(单位纳秒)。

//10、Equal()判断时间是否相等

//11、Before()如果t代表的时间点在u之前,返回真;否则返回假。

//12、After()如果t代表的时间点在u之后,返回真;否则返回假。

//13、Date()返回时间点对应的年、月、日信息

//14、Year()返回时间点对应的年的信息

//15、Month()返回时间点对应的月的信息

//16、Day()返回时间点对应的日的信息

//17、Weekday()返回时间点对应的星期的信息

//18、Clock()返回时间点对应的时、分、秒信息

//19、Hour()返回时间点对应的小时的信息

//20、Minute()返回时间点对应的分的信息

//21、Second()返回时间点对应的秒的信息

//22、Nanosecond()返回时间点对应的纳秒的信息

//23、Sub()返回一个时间段t-u。

//24、Hours()将时间段表示为float64类型的小时数。

//25、Minutes()将时间段表示为float64类型的分钟数。

//26、Seconds()将时间段表示为float64类型的秒数。

//27、Nanoseconds()将时间段表示为int64类型的纳秒数,等价于int64(d)。

//28、String()返回时间段采用"72h3m0.5s"格式的字符串表示。

//29、ParseDuration解析一个时间段字符串。

//30、Add()返回时间点t+d。

//31、AddDate()返回增加了给出的年份、月份和天数的时间点Time。
*/
func main() {
time1 := time.Now()
testTime()
time2 := time.Now()
//计算函数执行时间
fmt.Println(time2.Sub(time1).Seconds())
}

func testTime() {
//1、Now()返回当前本地时间
t := time.Now()
fmt.Println("1、", t)

//2、Local()将时间转成本地时区,但指向同一时间点的Time。
fmt.Println("2、", t.Local())

//3、UTC()将时间转成UTC和零时区,但指向同一时间点的Time。
fmt.Println("3、", t.UTC())

//4、Date()可以根据指定数值,返回一个本地或国际标准的时间格式。
t = time.Date(2018, time.January, 1, 1, 1, 1, 0, time.Local)
fmt.Printf("4、本地时间%s , 国际统一时间:%s \n", t, t.UTC())

//5、Parse()能将一个格式化的时间字符串解析成它所代表的时间。就是string转time
//预定义的ANSIC、UnixDate、RFC3339
//ANSIC = "Mon Jan _2 15:04:05 2006"//1 1 2 3 4 5 6
t, _ = time.Parse("2006-01-02 15:04:05", "2018-07-19 05:47:13")
fmt.Println("5、", t)

//6、Format()根据指定的时间格式,将时间格式化成文本。就是time转string
fmt.Println("6、" , time.Now().Format("2006-01-02 15:04:05"))

//7、String()将时间格式化成字符串,格式为:"2006-01-02 15:04:05.999999999 -0700 MST"
fmt.Println("7、" , time.Now().String())

//8、Unix()将t表示为Unix时间(时间戳,一个int64整数),即从时间点January 1, 1970 UTC到时间点t所经过的时间(单位秒)。
fmt.Println("8、" , time.Now().Unix())

//9、UnixNano()将t表示为Unix时间(时间戳,一个int64整数),即从时间点January 1, 1970 UTC到时间点t所经过的时间(单位纳秒)。
fmt.Println("9、" , time.Now().UnixNano())

//10、Equal()判断时间是否相等
fmt.Println("10、" , t.Equal(time.Now()))

//11、Before()如果t代表的时间点在u之前,返回真;否则返回假。
fmt.Println("11、" , t.Before(time.Now()))

//12、After()如果t代表的时间点在u之后,返回真;否则返回假。
fmt.Println("12、" , t.After(time.Now()))

//13、Date()返回时间点对应的年、月、日信息
year , month , day := time.Now().Date()
fmt.Println("13、" , year , month ,day)

//14、Year()返回时间点对应的年的信息
fmt.Println("14、" , time.Now().Year())

//15、Month()返回时间点对应的月的信息
fmt.Println("15、" , time.Now().Month())

//16、Day()返回时间点对应的日的信息
fmt.Println("16、" , time.Now().Day())

//17、Weekday()返回时间点对应的星期的信息
fmt.Println("17、" , time.Now().Weekday())

//18、Clock()返回时间点对应的时、分、秒信息
hour , minute , second := time.Now().Clock()
fmt.Println("18、" , hour , minute , second)

//19、Hour()返回时间点对应的小时的信息
fmt.Println("19、" , time.Now().Hour())

//20、Minute()返回时间点对应的分的信息
fmt.Println("20、" , time.Now().Minute())

//21、Second()返回时间点对应的秒的信息
fmt.Println("21、" , time.Now().Second())

//22、Nanosecond()返回时间点对应的纳秒的信息
fmt.Println("22、" , time.Now().Nanosecond())

//23、Sub()返回一个时间段t-u。
fmt.Println("23、" , time.Now().Sub(time.Now()))

//24、Hours()将时间段表示为float64类型的小时数。
fmt.Println("24、" , time.Now().Sub(time.Now()).Hours())

//25、Minutes()将时间段表示为float64类型的分钟数。
fmt.Println("25、" , time.Now().Sub(time.Now()).Minutes())

//26、Seconds()将时间段表示为float64类型的秒数。
fmt.Println("26、" , time.Now().Sub(time.Now()).Seconds())

//27、Nanoseconds()将时间段表示为int64类型的纳秒数,等价于int64(d)。
fmt.Println("27、" , time.Now().Sub(time.Now()).Nanoseconds())

//28、String()返回时间段采用"72h3m0.5s"格式的字符串表示。
fmt.Println("28、" , "时间间距:", t.Sub(time.Now()).String())

//29、ParseDuration解析一个时间段字符串。
d,_:=time.ParseDuration("1h30m")
fmt.Println("29、" , d)

//30、Add()返回时间点t+d。
fmt.Println("30、" , "交卷时间:" , time.Now().Add(d))

//31、AddDate()返回增加了给出的年份、月份和天数的时间点Time。
fmt.Println("31、" , "一年一个月零一天之后的日期:" , time.Now().AddDate(1,1,1))

}