Go Study Day08 - 标准库
子车轻罗 2019/8/17 go学习提升
# time标准库
# 时间类型
now := time.Now()
fmt.Println(now)
fmt.Println(now.Year())
fmt.Println(now.Month())
fmt.Println(now.Day())
fmt.Println(now.Date())
fmt.Println(now.Hour())
fmt.Println(now.Minute())
fmt.Println(now.Second())
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
# 时间戳
// 时间戳
fmt.Println(now.Unix())
fmt.Println(now.UnixNano())
// time.Unix()
ret := time.Unix(1564803667, 0)
fmt.Println(ret)
fmt.Println(ret.Year())
fmt.Println(ret.Day())
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
# 时间间隔
// 时间间隔
fmt.Println(time.Second)
// now + 24小时
fmt.Println(now.Add(24 * time.Hour))
1
2
3
4
2
3
4
# 定时器
timer := time.Tick(time.Second)
for t := range timer {
fmt.Println(t) // 1秒钟执行一次
}
1
2
3
4
2
3
4
# 格式化时间
// 格式化时间 把语言中时间对象 转换成字符串类型的时间
// 2019-08-03
fmt.Println(now.Format("2006-01-02"))
// 2019/02/03 11:55:02
fmt.Println(now.Format("2006/01/02 15:04:05"))
// 2019/02/03 11:55:02 AM
fmt.Println(now.Format("2006/01/02 03:04:05 PM"))
// // 2019/02/03 11:55:02.342
fmt.Println(now.Format("2006/01/02 15:04:05.000"))
// 按照对应的格式解析字符串类型的时间
timeObj, err := time.Parse("2006-01-02", "2019-08-03")
if err != nil {
fmt.Printf("parse time failed, err:%v\n", err)
return
}
fmt.Println(timeObj)
fmt.Println(timeObj.Unix())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/格式化时间把语言中时间对象转换成字符串类型的时间
//2019-08-03
fmt.Println(now.Format("2006-01-02"))
//2019/02/0311:55:02
fmt.Print1n(now.Format("2006/01/0215:04:05"))
//2019/02/0311:55:02AM
fmt.Println(now.Format("2006/01/02 03:04:05 PM"))
////2019/02/0311:55:02.342
fmt.Print.1n(now.Format("2006/01/0215:04:05.000"))
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
func f2(){
now:=time.Now()//本地的时间
fmt.Println(now)
//明天的这个时间
//按照指定格式职解析一个字符串格式的时间
time.Parse("2886-81-0215:64:65","2019-68-6414:41:58")
//按照东八区的时区和格式取解析一个字符串格式的时间
//根据字符串加载时区
loc,err :=time.LoadLocation("Asia/Shanghai")
if err != nil{
fmt.Printf("load loc failed,err:%v\n",err)
return
}
//按照指定时区程析时间
time0bj,err:=time.ParseInLocation("2006-01-8215:04:05","2019-08-0414:41:50",1oc)
if err !=nil {
fmt.Printf("parse time failed,err:%v\n",err)
return
}
fmt.Println(timeobj)
//时间对家相减
td :timeobj.Sub(now)
fmt.Println(td)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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"
"os"
)
// 打开文件
func main() {
fileObj, err := os.Open("./main.go")
if err !
读了128个字节
= nil {
fmt.Printf("open file failed, err:%v", err)
return
}
// 记得关闭文件
defer fileObj.Close()
// 读文
读了128个字节
件
// var tmp = make([]byte, 128) // 指定读的长度
var tmp [128]byte
for {
n, err := fileObj.Read(tmp[:])
if e
读了128个字节
rr != nil {
fmt.Printf("read from file failed, err:%v", err)
return
}
fmt.Printf("读了%d个字节\n", n)
fmt.
读了66个字节
Println(string(tmp[:n]))
if n == 0 {
return
}
}
}
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
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
# file.Read()
# 基本使用
Read方法定义如下：
func (f *File) Read(b []byte) (n int, err error)
1
它接收一个字节切片，返回读取的字节数和可能的具体错误，读到文件末尾时会返回0和io.EOF。 举个例子：
func main() {
// 只读方式打开当前目录下的main.go文件
file, err := os.Open("./main.go")
if err != nil {
fmt.Println("open file failed!, err:", err)
return
}
defer file.Close()
// 使用Read方法读取数据
var tmp = make([]byte, 128)
n, err := file.Read(tmp)
if err == io.EOF {
fmt.Println("文件读完了")
return
}
if err != nil {
fmt.Println("read file failed, err:", err)
return
}
fmt.Printf("读取了%d字节数据\n", n)
fmt.Println(string(tmp[:n]))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 循环读取
使用for循环读取文件中的所有数据。
func main() {
// 只读方式打开当前目录下的main.go文件
file, err := os.Open("./main.go")
if err != nil {
fmt.Println("open file failed!, err:", err)
return
}
defer file.Close()
// 循环读取文件
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("read file failed, err:", err)
return
}
content = append(content, tmp[:n]...)
}
fmt.Println(string(content))
}
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# bufio读取文件
bufio是在file的基础上封装了一层API，支持更多的功能。
package main
import (
"bufio"
"fmt"
"io"
"os"
)
// bufio按行读取示例
func main() {
file, err := os.Open("./xx.txt")
if err != nil {
fmt.Println("open file failed, err:", err)
return
}
defer file.Close()
reader := bufio.NewReader(file)
for {
line, err := reader.ReadString('\n') //注意是字符
if err == io.EOF {
if len(line) != 0 {
fmt.Println(line)
}
fmt.Println("文件读完了")
break
}
if err != nil {
fmt.Println("read file failed, err:", err)
return
}
fmt.Print(line)
}
}
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
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
# ioutil读取整个文件
io/ioutil包的ReadFile方法能够读取完整的文件，只需要将文件名作为参数传入。
package main
import (
"fmt"
"io/ioutil"
)
// ioutil.ReadFile读取整个文件
func main() {
content, err := ioutil.ReadFile("./main.go")
if err != nil {
fmt.Println("read file failed, err:", err)
return
}
fmt.Println(string(content))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 文件写入操作
os.OpenFile()函数能够以指定模式打开文件，从而实现文件写入相关功能。
func OpenFile(name string, flag int, perm FileMode) (*File, error) {
...
}
1
2
3
2
3
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。
# Write和WriteString
func main() {
file, err := os.OpenFile("xx.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
if err != nil {
fmt.Println("open file failed, err:", err)
return
}
defer file.Close()
str := "hello 沙河"
file.Write([]byte(str)) //写入字节切片数据
file.WriteString("hello 小王子") //直接写入字符串数据
}
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
# bufio.NewWriter
func main() {
file, err := os.OpenFile("xx.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
if err != nil {
fmt.Println("open file failed, err:", err)
return
}
defer file.Close()
writer := bufio.NewWriter(file)
for i := 0; i < 10; i++ {
writer.WriteString("hello沙河\n") //将数据先写入缓存
}
writer.Flush() //将缓存中的内容写入文件
}
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
# ioutil.WriteFile
func main() {
str := "hello 沙河"
err := ioutil.WriteFile("./xx.txt", []byte(str), 0666)
if err != nil {
fmt.Println("write file failed, err:", err)
return
}
}
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
