Go语言中切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import "fmt"

func rplus(b int) (int) {
return b + 1
}


func main() {
// 切片 相同类型可变长度的序列 基于数组再次封装
// 切片 是一个引用类型 它的内部结构包含 内存地址(第一个元素的) 长度 容量
// 定义 var name []T name 变量名 T 切片中元素类型
a := []int{1, 3, 5, 7}
// fmt.Printf("%T, %d, %d\n", a, len(a), cap(a))
// 追加元素
a = append(a, 9)
fmt.Printf("%T, %d, %d\n", a, len(a), cap(a))
b := 1
fmt.Println(rplus(b) + rplus(b))
// 删除元素
a = append(a[:2], a[3:]...)
fmt.Println(a)
}

Go语言中map

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
package main

import (
"fmt"
"strings"
)

func main() {
// 声明map
// map 是无序 基于key-value 的数据结构 map 是引用类型 必须先初始化才能使用
// 定义语法 map[KeyType]ValueType
// a := map[string]int
// make 申请内存 初始化
// a := make(map[string]int, 8)
// a["test"] = 1
// fmt.Println(a)
// fmt.Printf("%#v", a)

// scoreMap := make(map[string]int)
// scoreMap["张三"] = 60
// scoreMap["李四"] = 90
// fmt.Println(scoreMap)
// 判断某个键是否存在
// 语法 value, ok := map[key]
// v, ok := scoreMap["李四"]
// if ok {
// fmt.Println(v)
// } else {
// fmt.Println("此人记录不存在")
// }

// 遍历
// 语法 for range
// 只遍历key
// for k := range(scoreMap) {
// fmt.Println(k)
// }
// 只遍历value
// for _, v := range(scoreMap) {
// fmt.Println(v)
// }
// 遍历
// for k, v := range(scoreMap) {
// fmt.Println(k, v)
// }

// 删除某个键值对
// 语法 delete(map, key)
// delete(scoreMap, "李四")
// fmt.Println(scoreMap)

// scoreMap := make(map[string]int, 50)
// for i := 1; i <= 50; i++ {
// key := fmt.Sprintf("stu%02d", i)
// value := rand.Intn(100)
// scoreMap[key] = value
// }
// fmt.Println(scoreMap)
// map 是无序
// for k, v := range(scoreMap) {
// fmt.Println(k, v)
// }

// 取出所有key存放切片中 对切片进行排序 然后通过key取出value
// keys := make([]string, 0, 50)
// for key := range scoreMap {
// keys = append(keys, key)
// }
// sort.Strings(keys)
// for _, key := range keys {
// fmt.Println(key, scoreMap[key])
// }

// 定义map类型的切片
// mapSlice := make([]map[string]string, 3)
// for index, value := range mapSlice {
// fmt.Printf("index: %d, value: %v\n", index, value)
// }
// mapSlice[0] = make(map[string]string, 10)
// mapSlice[0]["name"] = "zhangsan"
// mapSlice[0]["passwd"] = "niubimima"
// mapSlice[0]["address"] = "nibuzhidaodedifang"
// for index, value := range mapSlice {
// fmt.Printf("index: %d, value: %v\n", index, value)
// }

// 值为切片类型的map
// sliceMap := make(map[string][]string, 3)
// fmt.Println(sliceMap)
// key := "李四"
// value, ok := sliceMap[key]
// if !ok {
// value = make([]string, 0, 2)
// }
// value = append(value, "张三", "王二")
// sliceMap[key] = value
// fmt.Println(sliceMap)

s1 := "how do you do"
slice1 := strings.Split(s1, " ")
// fmt.Printf("%T", slice1)
map1 := make(map[string]int)
for _, value := range(slice1) {
_, ok := map1[value]
if ok {
map1[value] ++
} else {
map1[value] = 1
}
}
fmt.Println(map1)
}

Go语言中函数

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
package main

import (
"fmt"
"strings"
)

func main() {
// 声明map
// map 是无序 基于key-value 的数据结构 map 是引用类型 必须先初始化才能使用
// 定义语法 map[KeyType]ValueType
// a := map[string]int
// make 申请内存 初始化
// a := make(map[string]int, 8)
// a["test"] = 1
// fmt.Println(a)
// fmt.Printf("%#v", a)

// scoreMap := make(map[string]int)
// scoreMap["张三"] = 60
// scoreMap["李四"] = 90
// fmt.Println(scoreMap)
// 判断某个键是否存在
// 语法 value, ok := map[key]
// v, ok := scoreMap["李四"]
// if ok {
// fmt.Println(v)
// } else {
// fmt.Println("此人记录不存在")
// }

// 遍历
// 语法 for range
// 只遍历key
// for k := range(scoreMap) {
// fmt.Println(k)
// }
// 只遍历value
// for _, v := range(scoreMap) {
// fmt.Println(v)
// }
// 遍历
// for k, v := range(scoreMap) {
// fmt.Println(k, v)
// }

// 删除某个键值对
// 语法 delete(map, key)
// delete(scoreMap, "李四")
// fmt.Println(scoreMap)

// scoreMap := make(map[string]int, 50)
// for i := 1; i <= 50; i++ {
// key := fmt.Sprintf("stu%02d", i)
// value := rand.Intn(100)
// scoreMap[key] = value
// }
// fmt.Println(scoreMap)
// map 是无序
// for k, v := range(scoreMap) {
// fmt.Println(k, v)
// }

// 取出所有key存放切片中 对切片进行排序 然后通过key取出value
// keys := make([]string, 0, 50)
// for key := range scoreMap {
// keys = append(keys, key)
// }
// sort.Strings(keys)
// for _, key := range keys {
// fmt.Println(key, scoreMap[key])
// }

// 定义map类型的切片
// mapSlice := make([]map[string]string, 3)
// for index, value := range mapSlice {
// fmt.Printf("index: %d, value: %v\n", index, value)
// }
// mapSlice[0] = make(map[string]string, 10)
// mapSlice[0]["name"] = "zhangsan"
// mapSlice[0]["passwd"] = "niubimima"
// mapSlice[0]["address"] = "nibuzhidaodedifang"
// for index, value := range mapSlice {
// fmt.Printf("index: %d, value: %v\n", index, value)
// }

// 值为切片类型的map
// sliceMap := make(map[string][]string, 3)
// fmt.Println(sliceMap)
// key := "李四"
// value, ok := sliceMap[key]
// if !ok {
// value = make([]string, 0, 2)
// }
// value = append(value, "张三", "王二")
// sliceMap[key] = value
// fmt.Println(sliceMap)

s1 := "how do you do"
slice1 := strings.Split(s1, " ")
// fmt.Printf("%T", slice1)
map1 := make(map[string]int)
for _, value := range(slice1) {
_, ok := map1[value]
if ok {
map1[value] ++
} else {
map1[value] = 1
}
}
fmt.Println(map1)
}

Go语言中结构体

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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
package main

import "fmt"

// MyInt type 自定义类型
// MyInt 是一种新类型 它具有int的特性
type MyInt int

// SayHi 给自定义MyMyInt添加方法
func (m MyInt) SayHi() {
fmt.Println("Hello World!")
}

// 类型别名 Type TypeAlias = Type
// type byte = uint8
// type rune = int32

// 类型自定义与类型别名区别
// type NewInt int
// 代码中存在
// type MyInt = int

// 结构体 struct
// type 类型名 struct {
// 字段名 字段类型
// 字段名 字段类型
// ……
// }

type person struct {
name string
age int8
addr string
}

// 定义方法
func (p person) Sleep() {
fmt.Printf("%s非常想睡觉\n", p.name)
}

// 类似于其他面向对象语言中self或this 修改实例变量
func (p *person) Modage(newage int8) {
p.age = newage
}

// 接收者类型是值类型 运行时会拷贝一份副本 无法修改接收者变量本身
func (p person) Modage2(newage int8) {
p.age = newage
}

// People 结构体匿名字段
type People struct {
string
int8
}

// 因结构体字段名必须唯一 匿名字段同一类型只有一个

// Address 结构体嵌套
type Address struct {
province string
city string
createtime string
}

// User 定义结构体
type User struct {
name string
gender string
address Address
}

// Renmen 嵌套匿名结构体
// 访问结构体成员时会先在结构体中查找该字段 找不到再去匿名结构体中查找
type Renmen struct {
name string
gender string
Address
}

// Email 嵌套结构体 字段名冲突
type Email struct {
account string
createtime string
}

// NiuBi 自定义结构体
type NiuBi struct {
name string
gender string
Address
Email
}

// Animal 动物
// 结构体的“继承”
type Animal struct {
name string
}

func (a *Animal) move() {
fmt.Printf("%s会动\n", a.name)
}

// Dog 够
type Dog struct {
age int8
// 通过嵌套匿名结构体实现继承
*Animal
}

func (d *Dog) jiao() {
fmt.Printf("%s会汪汪汪叫\n", d.name)
}

// Xueyuan 学员结构体
type Xueyuan struct {
ID int
Name string
Gender string
}

func main() {
// var a NewInt
// var b MyInt
// fmt.Printf("type of a: %T\n", a)
// fmt.Printf("type of b: %T\n", b)
// type of a: main.NewInt
// type of b: int

// 结构体实例化
// var 结构体实例 结构体类型 通过. 访问结构体的字段
// var p1 person
// p1.name = "Ropon"
// p1.age = 20
// p1.addr = "Chengdu"
// fmt.Printf("p1 = %v\n", p1)
// fmt.Printf("p1 = %#v\n", p1)

// 匿名结构体
// var user struct {
// name string
// age int
// }
// user.name = "Pengge"
// user.age = 22
// fmt.Printf("user = %#v\n", user)

// 创建指针类型结构体
// var p2 = new(person)
// fmt.Printf("%T\n", p2)
// fmt.Printf("p2 = %#v\n", p2)
// 指针结构类型也支持通过.访问结构体的字段
// p2.name = "West"
// p2.age = 28
// p2.addr = "Beijing"
// fmt.Printf("p2 = %#v\n", p2)
// fmt.Println(p2.name)

// 取结构体的地址进行实例化
// p3 := &person{}
// fmt.Printf("%T\n", p3)
// fmt.Printf("p3 = %#v\n", p3)
// p3.name = "Niubi"
// p3.age = 30
// p3.addr = "Shanghai"
// fmt.Printf("p2 = %#v\n", p3)
// fmt.Println(p3.name)

// 结构体初始化 没有初始化结构体 其成员都是对应类型的默认值

// 使用键值对初始化
// p4 := person{
// name: "Lisi",
// age: 26,
// addr: "Shenzhen",
// }
// fmt.Printf("p4 = %#v\n", p4)

// 指针类型结构体也可以通过键值对初始化
// p5 := &person{
// name: "Lisi",
// age: 26,
// addr: "Shenzhen",
// }
// fmt.Printf("p5 = %#v\n", p5)
// 初始化值时,字段名可以不写,那么没有指定值就是该类型的默认值

// 使用值的列表初始化 必须初始化结构体所有字段 顺序必须一致 不能与键值混用
// p6 := &person{
// "Lisi",
// 26,
// "Shenzhen",
// }
// fmt.Printf("p6 = %#v\n", p6)

// 结构体内存布局 占用一块连续的内存
// type test struct {
// a int8
// b int8
// c int8
// d int8
// }
// t := test{
// 1, 2, 3, 4,
// }
// fmt.Printf("t.a %p\n", &t.a)
// fmt.Printf("t.b %p\n", &t.b)
// fmt.Printf("t.c %p\n", &t.c)
// fmt.Printf("t.d %p\n", &t.d)

// 练习
// type student struct {
// name string
// age int
// }
// m := make(map[string]*student)
// stus := []*student{
// {name: "Ropon", age: 18},
// {name: "Pengge", age: 20},
// {name: "Rencai", age: 22},
// }
// for _, stu := range stus {
// // fmt.Println(stu.name)
// // fmt.Printf("%P\n", stu.name)
// m[stu.name] = stu
// }
// for k, v := range m {
// fmt.Println(k, "=>", v.name)
// // fmt.Println(k, "=>", (*v).name)
// }
// Ropon => Ropon
// Pengge => Pengge
// Rencai => Rencai

// 方法
// 定义格式
// func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
// 函数体
// }
// 接收者变量 一般使用接收者类型的第一个小写字母 而不是self this
// 接收者类型 与参数类似 可以是指针类型或值类型
// 方法名、参数列表 返回参数 与函数定义相同
// p4 := person{
// name: "Lisi",
// age: 26,
// addr: "Shenzhen",
// }
// p4.Sleep()
// p4.Modage(28)
// fmt.Println(p4)
// p4.Modage2(30)
// fmt.Println(p4)
// 方法与函数区别: 函数不属于任何类型 方法属于特定类型
// 什么情况该使用指针类型接收者
// 需要修改接收者中的值
// 接收者拷贝代价高的大对象
// 方法接收者类型统一

// 任意类型 添加方法
var m1 MyInt
m1.SayHi()
m1 = 100
fmt.Printf("%#v %T\n", m1, m1)
p1 := People{
"rencai",
22,
}
fmt.Printf("%#v\n", p1)
fmt.Println(p1.string, p1.int8)

u1 := User{
name: "Pengge",
gender: "男",
address: Address{
province: "Sc",
city: "Cd",
},
}
fmt.Println(u1)
fmt.Printf("%#v\n", u1)

var u2 Renmen
u2.name = "Ropon"
u2.gender = "男"
u2.Address.province = "Sc"
u2.Address.city = "Cd"
fmt.Printf("%#v\n", u2)

var u3 NiuBi
u3.name = "Niubi666"
u3.gender = "Man"
// u3.createtime = "2019"
u3.Address.createtime = "2020"
u3.Email.createtime = "2020"
fmt.Printf("%#v\n", u3)

d1 := &Dog{
age: 4,
Animal: &Animal{
name: "erduo",
},
}
d1.jiao()
d1.move()

// 结构体字段可见性
// 结构体字段大写表示公有 小写表示私有(仅在定义当前结构体中可访问) 通过包导入无法访问

x := &Xueyuan{
1,
"Ropon",
"男",
}
fmt.Println(x)
}

// 结构体 <==> JSON
package main

import (
"encoding/json"
"fmt"
)

// Student 班级
type Student struct {
ID int
Gender string
Name string
}

// Class 班级
type Class struct {
Title string
Students []*Student
}

// Student2 结构体
// 结构体标签 Tag
// 语法
// `key1:"value1" key2:"value2"`

//Student2 测试学生信息
type Student2 struct {
ID int `json:"id"`
Gender string
Name string
}

func main() {
c := &Class{
Title: "101",
Students: make([]*Student, 0, 200),
}
for i := 0; i < 5; i++ {
stu := &Student{
Name: fmt.Sprintf("stu%02d", i),
Gender: "男",
ID: i,
}
c.Students = append(c.Students, stu)
}

//JSON序列化: 结构体 --> JSON格式的字符串
//data, err := json.Marshal(c)
//if err != nil {
// fmt.Println("json marshal failed")
// return
//}
//fmt.Printf("json:%s\n", data)

//JSON反序列化:JSON格式的字符串-->结构体
jsonstr := `
{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},
{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},
{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"}]}`

c1 := &Class{}
err := json.Unmarshal([]byte(jsonstr), c1)
if err != nil {
fmt.Println("json unmarshal failed!")
return
}
//fmt.Printf("%#v\n", c1.Students)
for index, value := range c1.Students {
fmt.Println(index, value.Name, value.ID)
}

//s1 := Student2{
// 1,
// "男",
// "人才",
//}
//data, err := json.Marshal(s1)
//if err != nil {
// fmt.Println("json marshal failed!")
// return
//}
//fmt.Printf("json str: %s\n", data)
}

Go语言中包

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
//定义一个包

package addpkg

import "fmt"

//定义 addpkg包
//对外可见 标识符首字母必须大写

//以下结构体对外可见
type Student struct {
Id int
Name string
Gender string
}
//对外不可见
var x = 100

// Add 加法
func Add(a, b int) int {
fmt.Println(x)
return a + b
}

// 使用包

package main

import (
"fmt"
"ropon.top/day03/3package/cacl"
)

//import 导包通常放到包声明下面
//import 别名 "包的路径"
//匿名导包 只导入包,不导入包内部数据
//import _ "包的路径"

//导包时会自动触发包内部init()函数
//init 函数执行时机 全局变量等声明=>init()=>main()

//init函数执行顺序
//导包顺序
//main => imort A => import B => import C
//init执行顺序
//main.init() <= A.init() <= B.init() <= C.init()
var aa = 10

func init() {
fmt.Println(aa)
fmt.Println("main包初始化~")
}

func f1(a string) string {
return "a"
}

func main() {
//res := addpkg.Add(1, 3)
//fmt.Println(res)
//fmt.Printf("recai\n")
//
//stu1 := addpkg.Student{
// Id: 1,
// Name: "Ropon",
// Gender: "man",
//}
//fmt.Println(stu1)
//f1("sss")
r1 := cacl.Add(6, 2)
r2 := cacl.Jian(6, 2)
r3 := cacl.Chen(6, 2)
r4 := cacl.Chu(6, 2)
fmt.Println(r1, r2, r3, r4)
}

Go语言标准库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
package main

import (
"fmt"
"time"
)

//time.Unix() 将时间戳转换为时间格式
func timestamp2Time(timestamp int64) {
timeObj := time.Unix(timestamp, 0) //将时间戳转换为时间格式
fmt.Printf("当前时间: \n", timeObj)
//年
fmt.Println(timeObj.Year())
//月
fmt.Println(timeObj.Month())
//日
fmt.Println(timeObj.Day())
//时
fmt.Println(timeObj.Hour())
//分
fmt.Println(timeObj.Minute())
//秒
fmt.Println(timeObj.Second())
}

func tickDemo() {
ticker := time.Tick(time.Second)
for i := range ticker {
//每秒执行一次
fmt.Println(i)
}
}

func main() {
//now := time.Now()
//fmt.Printf("当前时间: \n", now)
////年
//fmt.Println(now.Year())
////月
//fmt.Println(now.Month())
////日
//fmt.Println(now.Day())
////时
//fmt.Println(now.Hour())
////分
//fmt.Println(now.Minute())
////秒
//fmt.Println(now.Second())
////时间戳
//fmt.Println(now.Unix())
////纳秒时间戳
//fmt.Println(now.UnixNano())
//timestamp2Time(1573626296)

//time.Duration 是time包定义的一个类型 表示2个时间点经过的时间 纳秒为单位
//表示1纳秒
//time.Duration()
//表示1秒
//time.Second
//表示1分钟
//time.Minute
//表示1小时
//time.Hour

//time.Sleep(time.Second*5)
//fmt.Println("睡了5秒~")

//时间操作
// Add 函数 时间 + 时间间隔
//func (t Time) Add(d Duration) Time
//later := now.Add(time.Hour)
//fmt.Println(later)

//Sub 函数 请两个时间之间差值
//func (t Time) Sub(u Time) Duration
//返回 t - u 时间差值

//Equal 函数 判断两个时间是否相同 不同时区也可以正常比较
//func (t Time) Equal(u Time) bool

//Before 函数
//func (t Time) Before(u Time) bool t表示时间在u之前返回真 否则为假

//After 函数
//func (t Time) After(u Time) bool t表示时间在u之后返回真 否则为假

//定时器
//time.Tick(d Duration) 定时器本质是一个通道(channel)
//tickDemo()

//时间格式化
//时间类型有Format方法进行格式化
//格式化模板 Go出生时间2006年1月2号15点04分05秒.000 Mon Jan
//fmt.Println(now.Format("2006-01-02 15:04:05 Mon Jan"))
//fmt.Println(now.Format("2006-01-02 03:04:05 PM Mon"))
//fmt.Println(now.Format("2006/01/02"))

//字符串时间转时间类型
//loc, err := time.LoadLocation("Asia/Shanghai")
//if err != nil {
// fmt.Println(err)
// return
//}
//timeObj, err := time.ParseInLocation("2006-01-02 15:04:05", "2019-11-02 15:04:05", loc)
//if err != nil {
// fmt.Println(err)
// return
//}
//fmt.Println(timeObj)
//fmt.Println(timeObj.Sub(now))

//练习
//fmt.Println(now.Format("2006/01/02 15:04:05"))

start := time.Now()
fmt.Println("代码执行中……")
fmt.Println("代码执行中……")
fmt.Println("代码执行中……")
fmt.Println("代码执行中……")
fmt.Println("代码执行中……")
fmt.Println("代码执行中……")
//time.Sleep(time.Second*2)
dr := time.Now().Sub(start)
//fmt.Printf("%T", dr)
fmt.Printf("程序执行了%d微秒", dr.Microseconds())
}

Go语言中interface接口

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
package main

import "fmt"

//接口是一种类型 一种抽象的类型
//面向接口编程
//语法

//type 接口类型名 interface {
// 方法名1(参数列表1) 返回值列表1
// 方法名1(参数列表1) 返回值列表1
//}

//接口类型名 一般在后门加er 如Writer Singer
//接口类型名、方法名 首字母大写时,对外可见
//参数列表、返回列表中参数变量名可以省略 只需写类型

type Sayer interface {
say()
}

type dog struct {

}

type cat struct {

}

func (d dog) say() {
fmt.Println("汪汪汪")
}

func (c cat) say() {
fmt.Println("喵喵喵")
}

type Mover interface {
move()
}

//值接收者实现接口
//此时实现接口是dog类型
//func (d dog) move() {
// fmt.Println("狗会动~")
//}

//指针类型接收者实现接口
func (d *dog) move() {
fmt.Println("狗会动~")
}

//接口嵌套
type Animaler interface {
Sayer
Mover
}

type cat2 struct {
name string
}

func (c cat2) say() {
fmt.Println("喵喵喵")
}

func (c cat2) move() {
fmt.Println("猫会动")
}

func main() {
//var x Sayer
//a := dog{}
//b := cat{}
//x =a
//x.say()
//x = b
//x.say()

//var xx Mover
//wangcai := dog{}
//xx = wangcai 不能接收dog值类型
//xx.move()
//fugui := &dog{}
//xx = fugui
//xx.move()
//不管dog结构体还是结构体指针*dog类型的变量 都可以赋值给Mover接口变量
//go语言语法糖对指针变量取值会自动加*fugui

//一个类型可以实现多个接口
//多个类型可以实现一个接口

var x Animaler
x = cat2{name:"耳朵"}
x.say()
x.move()
}

// 接口应用

package main

import "fmt"

//空接口
// 没有定义任何方法的接口
// 也就是说任意类型都可以实现空接口
//换言之空接口类型的变量可以存储任意类型的变量

//定义x 空接口 比较繁琐
//type x interface {}


func Show(a interface{}) {
fmt.Printf("Type: %T Value: %v\n",a, a)
}

func main() {
//通常通过以下语法定义空接口
//var x interface{}
//s := "人才牛"
//x = s
//fmt.Printf("Type: %T Value: %v\n",x, x)
//i := 200
//x = i
//fmt.Printf("Type: %T Value: %v\n",x, x)
//b := true
//x = b
//fmt.Printf("Type: %T Value: %v\n",x, x)

//空接口应用
//作为函数传参 空接口作为函数参数 可以接收任意类型变量
//x := 666
//Show(x)
//y := "Pengge 666"
//Show(y)

//空接口可以作为mao的值
//var studentInfo = make(map[string]interface{})
//studentInfo["name"] = "Ropon"
//studentInfo["age"] = 18
//studentInfo["status"] = true
//fmt.Println(studentInfo)
//fmt.Printf("%#v", studentInfo)
//
//var testInfo = make(map[interface{}]interface{})
//testInfo[11] = 23
//testInfo["niubi"] = true
//testInfo["arg"] = "lihaile"
//fmt.Println(testInfo)
//fmt.Printf("%#v", testInfo)

//类型断言
//语法
//x.(T) x 表示类型为interface{}的变量 T 表示要断言的类型
//返回两个参数 第一个参数是x转化为T类型后的变量 第二参数是布尔值 true表示断言成功,否则断言失败
//var x interface{}
//x = "haolihaio"
//v, ok := x.(string)
//if ok {
// fmt.Println(v)
//} else {
// fmt.Println("类型断言失败")
//}

//switch
var x interface{}
//x = "niubi"
x = 11
//x = true
switch v := x.(type) {
case string:
fmt.Printf("x is a string value is %v\n", v)
case int:
fmt.Printf("x is a int value is %v\n", v)
case bool:
fmt.Printf("x is a bool value is %v\n", v)
}
}

Go语言标准库file

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
package main

import (
"fmt"
"io/ioutil"
"os"
)

//文件操作
func main() {
//os.Open() 函数打开文件 返回*File和err
file, err := os.Open("./config.ini")
if err != nil {
fmt.Println("文件打开失败, 错误信息: ", err)
return
}
fmt.Println(file)
defer file.Close()

//读文件
//func (f *os.File) Read(b[]byte) (n int, err error)
//var tmp = make([]byte, 128)
//n, err := file.Read(tmp)
//if err == io.EOF {
// fmt.Println("已读到文件末尾")
// return
//}
//if err != nil {
// fmt.Println("读取文件失败, 错误信息: ", err)
// return
//}
//fmt.Printf("读取了%d字节数据", n)
//fmt.Println(string(tmp[:n]))

//循环读取
//var content []byte
//var tmp = make([]byte, 128)
//for {
// n, err := file.Read(tmp)
// if err == io.EOF {
// fmt.Println("已读到文件末尾")
// break
// }
// if err != nil {
// fmt.Println("读取文件失败, 错误信息: ", err)
// return
// }
// content = append(content, tmp[:n]...)
//}
//fmt.Println(string(content))

//bufio按行读取
//var ss string
//reader := bufio.NewReader(file)
//for {
// line, err := reader.ReadString('\n') //字符分隔
// if err == io.EOF {
// fmt.Println("已读到文件末尾")
// break
// }
// if err != nil {
// fmt.Println("读取文件失败, 错误信息: ", err)
// return
// }
// ss = ss + line
//}
//fmt.Println(ss)

//ioutil读取整个文件
content, err := ioutil.ReadFile("./config.ini")
if err != nil {
fmt.Println("读取文件失败, 错误信息: ", err)
return
}
fmt.Println(string(content))
}

// 写入操作

package main

import (
"fmt"
"io/ioutil"
)

//文件写入
//os.OpenFile(name string, flag int, perm FileMode) (*File, error) 以指定模式打开文件
//name 需要操作的文件名
//flag 打开模式

//os.O_WRONLY 只写
//os.O_CREATE 创建文件
//os.O_RDONLY 只读
//os.O_RDWR 读写
//os.O_TRUNC 清空
//os.O_APPEND 追加

//perm 文件权限 一个八进制数 r 04 w 02 x 01

func main() {
//file, err := os.OpenFile("test.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
//if err != nil {
// fmt.Println("打开文件异常, 报错: ", err)
// return
//}
//defer file.Close()
//str := "优秀,非常优秀\n"
//file.Write([]byte(str)) // 通过字节切片写入文件
//file.WriteString("我们都很优秀") //直接将字符串写入文件

//bufio.NewWriter
//writer := bufio.NewWriter(file)
//for i := 0; i < 10; i ++ {
// writer.WriteString("bufio你好,中国\n") // 先将数据写入缓存
//}
//writer.Flush() // 将缓存的内容写入文件

//ioutil.WriteFile
str := "ioutil优秀,非常优秀\n"
err := ioutil.WriteFile("test.txt", []byte(str), 0666)
if err != nil {
fmt.Println("打开文件异常, 报错: ", err)
return
}
}

Go语言中指针

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
package main

import "fmt"

// 指针
// 区别于c/c++ Go语言指针不能进行偏移和运算 是安全指针
// 指针地址
// 指针类似
// 指针取值
// & 取地址 * 根据地址取值

// 指针传值例子
func mod1(x int) {
x = 100
}
func mod2(x *int) {
*x = 100
}
func modArry(a1 *[3]int) {
a1[0] = 20
}
// new 内置函数 接收一个类型参数 返回指向该类型的内存地址的指针
// func new(Type) *Type {

// }
// 得到一个int类型的指针
// var a = new(int)

// make 返回类型本身
// func make(t Type, size ...IntergerType) Type {

// }

func main() {
// a := 10
// b := &a
// fmt.Printf("a: %d ptr: %p\n", a, &a)
// fmt.Printf("b: %p type: %T\n", b, b)
// print(&b)
// print(*b)

a := 20
mod1(a)
fmt.Println(a)
mod2(&a)
fmt.Println(a)
a2 := [3]int{1, 2, 3}
modArry(&a2)
fmt.Println(a2)
}

Go语言中日志库demo

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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
// logger.go
package logger

import "strings"

//日志库

//Loglevelmap 定义日志级别map
var Loglevelmap = map[string]int{
"debug": 0,
"info": 1,
"warn": 2,
"error": 3,
"fatal": 4,
}

//Logger 是一个日志接口
type Logger interface {
Debug(format string, args ...interface{})
Info(format string, args ...interface{})
Warn(format string, args ...interface{})
Error(format string, args ...interface{})
Fatal(format string, args ...interface{})
Close()
}

// Getlevel 获取日志级别
func Getlevel(level string) int {
//统一转成小写
level = strings.ToLower(level)
val, ok := Loglevelmap[level]
if ok {
return val
}
return 1
}

// file.go
package logger

import (
"fmt"
"os"
"path"
"time"
)

// FileLogger 日志结构体
type FileLogger struct {
Level string
Filepath string
Filename string
file *os.File
errFile *os.File
maxSize int64
lastTime time.Time
}

// NewFileLogger 构造日志结构体函数
func NewFileLogger(Level, Filepath, Filename string) *FileLogger {
FileObj := &FileLogger{
Level: Level,
Filepath: Filepath,
Filename: Filename,
maxSize: 10 * 1024 * 1024,
lastTime: time.Now(),
}
FileObj.initFile()
return FileObj
}

func (f *FileLogger) initFile() {
logName := path.Join(f.Filepath, f.Filename)
fileObj, err := os.OpenFile(logName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
if err != nil {
panic(fmt.Errorf("打开日志文件%s异常, 报错:%v", logName, err))
}
f.file = fileObj
errLogName := fmt.Sprintf("err_%s", logName)
errFileObj, err := os.OpenFile(errLogName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
if err != nil {
panic(fmt.Errorf("打开日志文件%s异常, 报错:%v", errLogName, err))
}
f.errFile = errFileObj
}

//再次封装写日志函数
func (f *FileLogger) wLog(logLevel string, format string, args ...interface{}) {
if Getlevel(f.Level) > Getlevel(logLevel) {
return
}
// 按大小拆分日志
// f.file = f.checkSplitLog(f.file)
f.checkSplitLog()
msgInfo := fmt.Sprintf(format, args...)
nowStr := time.Now().Format("2006-01-02 15:04:05.000")
funcName, fileName, line := getCallerInfo(3)
logMsg := fmt.Sprintf("[%s] [%s] [%s:%s] %d %s", nowStr, logLevel, fileName, funcName, line, msgInfo)
_, _ = fmt.Fprintln(f.file, logMsg)
if Getlevel(logLevel) >= Getlevel("ERROR") {
// 按大小拆分时需要
// f.errFile = f.checkSplitLog(f.errFile)
_, _ = fmt.Fprintln(f.errFile, logMsg)
}
}

//日志拆分
func (f *FileLogger) checkSplitLog() {
// 按大小拆分
// fileInfo, _ := file.Stat()
// fileSize := fileInfo.Size()
// if fileSize < f.maxSize {
// return file
// }
// 按时间拆分
timeD := time.Now().Sub(f.lastTime).Minutes()
if timeD >= 1 {
fileName := f.file.Name()
backupName := fmt.Sprintf("%s_bak%v", fileName, time.Now().Unix())
_ = f.file.Close()
_ = os.Rename(fileName, backupName)
fileObj, err := os.OpenFile(fileName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
if err != nil {
panic(fmt.Errorf("打开日志文件%s异常, 报错:%v", fileName, err))
}

errFileName := f.errFile.Name()
errBackupName := fmt.Sprintf("%s_bak%v", errFileName, time.Now().Unix())
_ = f.errFile.Close()
_ = os.Rename(errFileName, errBackupName)
errFileObj, err := os.OpenFile(errFileName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
if err != nil {
panic(fmt.Errorf("打开日志文件%s异常, 报错:%v", errFileName, err))
}
// 将当前时间复制给上次拆分时间
f.lastTime = time.Now()
f.file = fileObj
f.errFile = errFileObj
}
}

// Debug 调试日志
func (f *FileLogger) Debug(format string, args ...interface{}) {
f.wLog("DEBUG", format, args...)
}

// Info 一般日志
func (f *FileLogger) Info(format string, args ...interface{}) {
f.wLog("INFO", format, args...)
}

// Warn 警告日志
func (f *FileLogger) Warn(format string, args ...interface{}) {
f.wLog("WARN", format, args...)
}

// Error 错误日志
func (f *FileLogger) Error(format string, args ...interface{}) {
f.wLog("ERROR", format, args...)
}

// Fatal 严重错误日志
func (f *FileLogger) Fatal(format string, args ...interface{}) {
f.wLog("FATAL", format, args...)
}

// Close 关闭文件句柄
func (f *FileLogger) Close() {
_ = f.file.Close()
_ = f.errFile.Close()
}

// utils.go
package logger

import (
"path"
"runtime"
)

func getCallerInfo(skip int) (funcName, fileName string, line int) {
pc, fileName, line, ok := runtime.Caller(skip)
if !ok {
panic("获取程序信息失败")
}
funcName = path.Base(runtime.FuncForPC(pc).Name())
fileName = path.Base(fileName)
return
}

// console.go
package logger

import (
"fmt"
"os"
"time"
)

// ConsoleLogger 终端结构体
type ConsoleLogger struct {
Level string
}

// NewConsoleLogger 构造终端结构体函数
func NewConsoleLogger(Level string) *ConsoleLogger {
ConsoleObj := &ConsoleLogger{
Level: Level,
}
return ConsoleObj
}

//再次封装写日志函数
func (f *ConsoleLogger) wLog(logLevel string, format string, args ...interface{}) {
if Getlevel(f.Level) > Getlevel(logLevel) {
return
}
msgInfo := fmt.Sprintf(format, args...)
nowStr := time.Now().Format("2006-01-02 15:04:05.000")
funcName, fileName, line := getCallerInfo(3)
logMsg := fmt.Sprintf("[%s] [%s] [%s:%s] %d %s", nowStr, logLevel, fileName, funcName, line, msgInfo)
_, _ = fmt.Fprintln(os.Stdout, logMsg)
}

// Debug 调试日志
func (f *ConsoleLogger) Debug(format string, args ...interface{}) {
f.wLog("DEBUG", format, args...)
}

// Info 一般日志
func (f *ConsoleLogger) Info(format string, args ...interface{}) {
f.wLog("INFO", format, args...)
}

// Warn 警告日志
func (f *ConsoleLogger) Warn(format string, args ...interface{}) {
f.wLog("WARN", format, args...)
}

// Error 错误日志
func (f *ConsoleLogger) Error(format string, args ...interface{}) {
f.wLog("ERROR", format, args...)
}

// Fatal 严重错误日志
func (f *ConsoleLogger) Fatal(format string, args ...interface{}) {
f.wLog("FATAL", format, args...)
}

// Close 终端不需要关闭
func (f *ConsoleLogger) Close() {

}

// 使用方法
package main

import (
"time"

logger "ropon.top/day04/1logger"
)

// blog测试项目

//定义全局变量log 接口
var log logger.Logger

func main() {
//往文件中写日志
//log = logger.NewFileLogger("Debug", "./", "blog.log")
//往终端写日志
log = logger.NewConsoleLogger("Info")
defer log.Close()
for i := 0; i < 10; i++ {
x := 100
log.Debug("这是一条Debug信息,调试程序而已")
log.Info("这是一条Info信息,测试记录变量值%d", x)
log.Error("这是一条Error信息,天啦程序奔溃")
log.Fatal("这是一条Fatal信息,哇程序出错啦")
time.Sleep(time.Second * 10)
}
}