20_GoLang语言入门_基础语法_IO操作

字数统计: 5.6k字   |   阅读时长≈ 26分

文件的操作：

文件路径和文件名的区别？

  • 文件路径
    • 绝对路径
    • 相对路径
  • 文件名
    • 文件路径中最后分割符后的字符串 
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      //文件路径
      filePath =String.valueOf(file.getAbsolutePath());
      //文件夹路径
      fileDir =String.valueOf(file.getParent());//方式一
      //文件夹路径
      String fileDir1 = filePath.substring(0, filePath.lastIndexOf("\\"));//方式二
      //文件名和后缀
      String fileNameSuffix =String.valueOf(file.getName());
      //文件后缀
      String Suffix = filePath.substring( filePath.lastIndexOf(".")+1);
      //文件名
      String fileName = fileNameSuffix.substring( 0,fileNameSuffix.lastIndexOf("."));

1. 文件路径：

  • 相对路径：relative 都是相对于当前工程

    • ../aa.txt 表示上一层目录
    • ./aa.txt 表示当前目录

  • 绝对路径：absolute 从根盘符开始

    • /Users/liangjunke/Desktop/三维生态景观设计软件开发计划.docx

2. 文件的信息。

**

** 3.文件的常规操作：

创建文件夹，创建文件，删除文件，打开文件，关闭文件… …

** 4.文件的读/写。**

**

**** 5.文件的复制。**

**

**** 6.ioutil包**

**

**** 7.bufio包**

****

01、文件信息和文件的常规操作

****

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

import (
	"fmt"
	"os"
)

func main() {
	fmt.Println("-------------------------------1.filepath文件路径：相对路径/绝对路径---------------------------------")
	{
		//fmt.Println("----------文件名/文件路径------------")
		//fileName1:="/Users/liangjunke/Desktop/三维生态景观设计软件开发计划.docx"
		//fileName2:="aa.txt"
		//fmt.Println(filepath.IsAbs(fileName1))//true
		//fmt.Println(filepath.IsAbs(fileName2))//false 只判断是否为根目录，不判断文件存在
		//fmt.Println("----------绝对路径------------")
		//abs, _ := filepath.Abs(fileName1)//
		//fmt.Println(abs)
		//fmt.Println(filepath.Abs(fileName2))
		//fmt.Println("----------上一层路径/当前路径------------")
		//fmt.Println("获取父目录：",path.Join(fileName1,".."))//获取文件的上一层路径         ——>技巧1
		//fmt.Println()
	}
	fmt.Println("-------------------------------2.fileInfo文件信息：根据文件名获取文件信息-----------------------------")
	{
		//fileInfo, err := os.Stat(fileName1)
		//if err != nil {
		//	fmt.Println(err.Error())
		//} else {
		//	fmt.Printf("%T\n", fileInfo)
		//}
		//fmt.Println(fileInfo.Name())
		//fmt.Println(fileInfo.Size())
		//fmt.Println(fileInfo.ModTime())
		//fmt.Println(fileInfo.Mode()) //-rw-r--r--   x可执行   也可以用八进制表示： r 4,  w 2,  x 1, - 0
		////fmt.Println(fileInfo.Sys())
		//fmt.Println()
	}
	fmt.Println("-------------------------------3.1文件的常规操作：创建文件夹-----------------------------------------")
	{
		////3.1 os.Mkdir()     只能创建一层目录
		//err2 := os.Mkdir("/Users/liangjunke/Desktop/LJKTest20210811", os.ModePerm) //os.ModePerm 0777 可读可写可执行
		////            0666 可读可写
		//if err2 != nil {
		//	fmt.Println(err2.Error())
		//} else {
		//	fmt.Println("文件夹创建成功了！！！！")
		//}
		////3.2 os.MkdirAll()  可以同时创建多层目录
		//err3 := os.MkdirAll("/Users/liangjunke/Desktop/LJKTest20210811_02/aa/bb/cc", os.ModePerm)
		//if err3 != nil {
		//	fmt.Println(err3.Error())
		//} else {
		//	fmt.Println("文件夹创建成功了！！！！")
		//}
		//fmt.Println()
	}
	fmt.Println("-------------------------------3.2文件的常规操作：创建文件-------------------------------------------")
	{
		////3.2 创建一个文件	使用的是0666模式（可读可写）
		//file1, err4:= os.Create("/Users/liangjunke/Desktop/LJKTest20210811/abc.txt")//如果已经存在的话，会被覆盖，重新创建
		//if err4!=nil {
		//	fmt.Println(err4.Error())
		//}else {
		//	fmt.Println(file1)
		//	fmt.Println("文件创建成功了！！！！")
		//}
		//file2, _:= os.Create("./Day12io输入输出/aabbcc.txt")
		//fmt.Println(file2.Name())
		//fmt.Println()
	}
	fmt.Println("-------------------------------3.3-3.4文件的常规操作：打开/关闭文件-----------------------------------")
	{
		fileName001 := "/Users/liangjunke/Desktop/LJKTest20210811/abc.txt"
		//fileName002:="./Day12io输入输出/aabbcc.txt"

		//3.3  打开文件，让当前的程序和指定的文件建立了一个连接
		//3.3.1 os.Open()
		file001, err001 := os.Open(fileName001) //打开，就是建立了一个连接，操作指针地址就是操作文件
		if err001 != nil {
			fmt.Println(err001.Error())
		} else {
			fmt.Println("文件打开成功！！", file001)
		}
		//3.3.2 os.OpenFile()
		/*
			第一个参数：文件的名称
			第二个参数：文件的打开方式
				O_RDONLY: 只读模式
				O_WRONLY: 只写模式
				O_RDWR:   可读可写模式
				O_APPEND: 追加模式
				O_CREATE: 文件不存在就创建
				O_EXCL:   在O_CREATE一起使用，构成一个新建文件的功能，他要求文件必须不存在。
				O_SYNC:   同步方式打开，即不使用缓存，追加写入硬盘
				O_TRUNC:  打开并清空文件
			第三个参数：文件的权限
				文件不存在，创建文件，需要指定权限
				文件存在，可以不写
		*/
		file002, err002 := os.OpenFile(fileName001, os.O_WRONLY|os.O_CREATE, os.ModePerm)
		if err002 != nil {
			fmt.Println(err002.Error())
		} else {
			fmt.Println("文件打开成功！！", file002)
		}
		//3.4  关闭文件，让当前的程序和指定的文件的连接断开
		err003 := file001.Close()
		if err003 != nil {
			fmt.Println(err003.Error())
		} else {
			fmt.Println("文件关闭成功了！！！")
		}
		err004 := file002.Close()
		if err004 != nil {
			fmt.Println(err004.Error())
		} else {
			fmt.Println("文件关闭成功了！！！")
		}
		fmt.Println()
	}
	fmt.Println("-------------------------------3.5文件的常规操作：删除文件夹/文件-------------------------------------")
	{
		//3.5.1 删除文件夹
		//os.Remove()  删除空文件和文件夹
		err005 := os.Remove("/Users/liangjunke/Desktop/LJKTest20210811_02/aa/bb")
		if err005 != nil {
			fmt.Println(err005.Error())
		} else {
			fmt.Println("文件删除成功了！！！")
		}
		//os.RemoveALl()  删除所有  -rs   循环删除
		err006 := os.RemoveAll("/Users/liangjunke/Desktop/LJKTest20210811")
		if err006 != nil {
			fmt.Println(err006.Error())
		} else {
			fmt.Println("文件删除成功了！！！")
		}
	}
}

02、文件的读写操作

  • step01: 打开文件 os.Open()
  • step02: 读/写
  • step03: 关闭文件

02.1 文件的读取

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

import (
	"fmt"
	"io"
	"os"
)

func main() {
	fmt.Println("----------------------------01.确定文件名&文件路径------------------------------------------------")
	//01 确定文件名&文件路径
	fileName := "./Day12io输入输出/aabbcc.txt"
	fmt.Println("----------------------------02.打开文件，建立连接------------------------------------------------")
	//02 打开文件，建立连接
	file01, err01 := os.Open(fileName)
	if err01 != nil {
		fmt.Println("文件打开有误！", err01.Error())
		return
	} else {
		fmt.Println("文件成功打开！", file01)
	}
	fmt.Println("----------------------------03.对文件进行读取------------------------------------------------------")
	//03 对文件进行读/写
	bytes := make([]byte, 8, 8) //创建了一个长度为8的容器
	n := -1
	var err error
	//逐次推导过程：
	{
		////第一次读取
		////从file01对应的文件中读取最多len(bytes)个数据,存入到bytes数组中。
		//n, err02 := file01.Read(bytes) //返回的是读取的个数和错误           ----------------->文件读取的核心:万事万物皆二进制
		//if err02 != nil {
		//	fmt.Println("--------第一次读取---------")
		//	fmt.Println("文件读取有误！", err02.Error())
		//	return
		//} else {
		//	fmt.Println("--------第一次读取---------")
		//	fmt.Println("文件读取成功！", n) // 8, 为返回的字节的个数
		//	fmt.Println("bytes中缓存的数据为：")
		//	for _,v :=range bytes{
		//		fmt.Printf("%d \t",v)
		//	}
		//	fmt.Println()
		//	//fmt.Printf("%T\n",bytes)
		//	fmt.Println("解析到的字符串类型的数据为：",string(bytes[:n]))
		//}
		////第二次读取
		//n, err03 := file01.Read(bytes) //返回的是读取的个数和错误
		//if err03 != nil {
		//	fmt.Println("--------第二次读取---------")
		//	fmt.Println("文件读取有误！", err03.Error())
		//	return
		//} else {
		//	fmt.Println("--------第二次读取---------")
		//	fmt.Println("文件读取成功！", n) // 8, 为返回的字节的个数
		//	fmt.Println("bytes中缓存的数据为：")
		//	for _,v :=range bytes{
		//		fmt.Printf("%d \t",v)
		//	}
		//	fmt.Println()
		//	//fmt.Printf("%T\n",bytes)
		//	fmt.Println("解析到的字符串类型的数据为：",string(bytes[:n]))
		//}
		////第三次读取
		//n, err04 := file01.Read(bytes) //返回的是读取的个数和错误
		//if err04 != nil {
		//	fmt.Println("--------第三次读取---------")
		//	fmt.Println("文件读取有误！", err04.Error())
		//	return
		//} else {
		//	fmt.Println("--------第三次读取---------")
		//	fmt.Println("文件读取成功！", n) // 8, 为返回的字节的个数
		//	fmt.Println("bytes中缓存的数据为：")
		//	for _,v :=range bytes{
		//		fmt.Printf("%d \t",v)
		//	}
		//	fmt.Println()
		//	//fmt.Printf("%T\n",bytes)
		//	fmt.Println("解析到的字符串类型的数据为：",string(bytes[:n]))
		//}
		////第四次读取
		//n, err05 := file01.Read(bytes) //返回的是读取的个数和错误
		//if err05 != nil {
		//	fmt.Println("--------第四次读取---------")
		//	fmt.Println("文件读取有误！", err05.Error())
		//	return
		//} else {
		//	fmt.Println("--------第四次读取---------")
		//	fmt.Println("文件读取成功！", n) // 2, 为返回的字节的个数
		//	fmt.Println("bytes中缓存的数据为：")
		//	for _,v :=range bytes{
		//		fmt.Printf("%d \t",v)
		//	}
		//	fmt.Println()
		//	//fmt.Printf("%T\n",bytes)
		//	fmt.Println("解析到的字符串类型的数据为：",string(bytes[:n]))
		//}
		////第五次读取
		//n, err06 := file01.Read(bytes) //返回的是读取的个数和错误
		//if err06 != nil {
		//	fmt.Println("--------第五次读取---------")
		//	fmt.Println("文件读取有误！", err06.Error())  //EOF:end of file
		//	return
		//} else {
		//	fmt.Println("--------第五次读取---------")
		//	fmt.Println("文件读取成功！", n) // 0
		//	fmt.Println("bytes中缓存的数据为：")
		//	for _,v :=range bytes{
		//		fmt.Printf("%d \t",v)
		//	}
		//	fmt.Println()
		//	//fmt.Printf("%T\n",bytes)
		//	fmt.Println("解析到的字符串类型的数据为：",string(bytes[:n]))
		//}
	}
	//for优化写法：
	{
		for i := 0; ; {
			n, err = file01.Read(bytes) //返回的是读取的个数和错误                  //----------------->文件读取的核心
			// file01.ReadAt(bytes,4)
			i++
			if n == 0 || err == io.EOF {
				fmt.Printf("在第%d次，文件读取完毕！", i)
				//fmt.Println("文件读取有误！", err.Error())
				break //break跳出本次循环
			} else {
				fmt.Printf("第%d次解析到的字符串类型的数据为：%s\n", i, string(bytes[:n]))
			}
		}
	}
	fmt.Println("----------------------------04.关闭文件，断开连接------------------------------------------------------")
	//04 关闭文件，断开连接
	err99 := file01.Close()
	if err99 == nil {
		fmt.Println("文件已成功关闭！")
	}
}

02.2 文件的写入

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

import (
	"fmt"
	"os"
)

func main() {
	/*
		文件的写入：
			将程序中的数据写出到文件中。
			又称数据的持久化保存。
			程序中的数据称为瞬时性的数据。（内存中）
	*/
	//0.备用写入文件的数据
	bytes := []byte{65, 66, 67, 68, 69, 70}

	//1.打开文件，建立连接
	//1.1 os.open()
	//file, err := os.Open("./Day12io输入输出/aabbcc.txt")
	//if err!=nil{
	//	fmt.Println("文件打开有误！",err.Error())
	//}else {
	//	fmt.Println(file.Name())
	//}
	//1.2 os.OpenFile()
	file, err := os.OpenFile("./Day12io输入输出/aabbcc.txt", os.O_WRONLY, os.ModePerm)
	if err != nil {
		fmt.Println("文件打开有误！", err.Error())
	} else {
		fmt.Println("------------------------------------2.文件写入操作---------------------------------------------")
		//01.   file.Write()
		{
			n, err := file.Write(bytes) //n 为写出的字节数
			if err != nil {
				fmt.Println("文件写入有误！", err.Error())
			} else {
				fmt.Println("写出文件成功！总共字节数为：", n)
			}
		}
		//02.   file.WriteString()
		{
			n, err := file.WriteString("LJKLJKLJKLJKLJKJLJKLJKLJKLJKLJKLJKLJKLJK") //n 为写出的字节数
			if err != nil {
				fmt.Println("文件写入有误！", err.Error())
			} else {
				fmt.Println("写出文件成功！总共字节数为：", n)
			}
		}
	}
	fmt.Println("------------------------------------3.关闭文件，断开连接--------------------------------------------")
	//3. 关闭文件，断开连接
	err = file.Close()
	if err != nil {
		fmt.Println("文件关闭错误！", err.Error())
	} else {
		fmt.Println("文件已经成功关闭！")
	}
	fmt.Println()
	fmt.Println("------------------------------------4.简写文件写出操作--------------------------------------------")
	file02, _ := os.OpenFile("./Day12io输入输出/aabbcc.txt", os.O_WRONLY, os.ModePerm)
	file02.WriteString("1234567890") // 光标一开始位于文件开头的位置，替换已有的字节
	file.Close()
	file03, _ := os.OpenFile("./Day12io输入输出/aabbcc.txt", os.O_WRONLY, os.ModePerm)
	file03.WriteString("hello面12") // 光标一开始位于文件开头的位置，替换已有的字节
	file.Close()
}

03、文件的复制

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

import (
	"fmt"
	"io"
	"os"
)

func main() {
	_srcFile := "./Day12io输入输出/aabbcc.txt"
	_destFile := "./TestDir/test.txt"
	//自定义函数一：
	{
		//total000, err000 := copyFile1(_srcFile, _destFile)
		//if err000 != nil {
		//	fmt.Println(err000.Error())
		//} else {
		//	fmt.Println("文件拷贝成功!!!", total000)
		//}
	}
	//自定义函数二：
	{
		total001, err001 := copyFile2(_srcFile, _destFile)
		if err001 != nil {
			fmt.Println(err001.Error())
		} else {
			fmt.Println("文件拷贝成功!!!", total001)
		}
	}
}

//自定义函数一：实现函数的拷贝，返回值是拷贝的字节的总数量和发生的错误
func copyFile1(src, dest string) (int, error) {
	srcfile, err := os.Open(src)
	if err != nil {
		return 0, err
	}
	destFile, err2 := os.OpenFile(dest, os.O_WRONLY|os.O_CREATE|os.O_APPEND, os.ModePerm)
	if err2 != nil {
		return 0, err2
	}
	defer fmt.Println("所有文件关闭成功！")
	defer srcfile.Close() //defer的使用？在有return的情况下
	defer destFile.Close()
	defer fmt.Println("所有文件开始关闭！")
	//拷贝数据
	bytes := make([]byte, 1024*4, 1024*4) //4kb
	n := -1
	total := 0
	for {
		n, err = srcfile.Read(bytes)
		if err == io.EOF || n == 0 {
			fmt.Println("已从文件1拷贝完毕！！")
			break //break 和 return的区别？
		} else if err != nil {
			fmt.Println("拷贝异常！！")
			return total, err
		}
		total += n
		_, err := destFile.Write(bytes[:n])
		if err != nil {
			fmt.Println("往文件2中写出有误！", err.Error())
		} else {
			fmt.Println("往文件2中写出完毕！！！")
		}
	}
	return total, nil
}

//自定义函数二：实现函数的拷贝，返回值是拷贝的字节的总数量和发生的错误
func copyFile2(src, dest string) (int64, error) {
	srcfile, err := os.Open(src)
	if err != nil {
		return 0, err
	}
	destFile, err2 := os.OpenFile(dest, os.O_WRONLY|os.O_CREATE|os.O_APPEND, os.ModePerm)
	if err2 != nil {
		return 0, err2
	}
	defer fmt.Println("所有文件关闭成功！")
	defer srcfile.Close() //defer的使用？在有return的情况下
	defer destFile.Close()

	defer fmt.Println("所有文件开始关闭！")
	n, err3 := io.Copy(destFile, srcfile)
	return n, err3
}

04、Seek

  • Seek:寻找：用于设置指针光标的位置。
    • 第一个参数：偏移量
      • 距离文件开头offset个字节
    • 第二个参数：如何偏
      • 0：距离文件开头offset个字节
      • 1：距离光标当前位置多少个字节
      • 2：距离光标末尾位置多少个字节
  • 随机读取文件：
    • 可以设置指针光标的位置

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

import (
	"fmt"
	"os"
)

func main() {
	file, _ := os.OpenFile("./TestDir/test.txt", os.O_RDWR, os.ModePerm)
	bs := []byte{0}
	fmt.Println("------------------------1.Seek练习一--------------------------------------")
	_, err := file.Seek(10, 0) //从哪偏移
	//文件读取
	_, err = file.Read(bs)
	if err != nil {
		fmt.Println("文件读取错误！", err.Error())
	} else {
		fmt.Println(string(bs)) //j
	}
	fmt.Println("------------------------2.Seek练习二--------------------------------------")
	_, err2 := file.Seek(0, 2)
	if err2 != nil {
		fmt.Println("文件光标设置有误！", err2.Error())
	} else {
		//文件写入
		_, err = file.WriteString("lolololo")
		if err != nil {
			fmt.Println(err.Error())
		} else {
			fmt.Println("文件写出完成！！！")
		}
	}
	//文件关闭
	err = file.Close()
	if err != nil {
		fmt.Println("文件关闭有误！！", err.Error())
	} else {
		fmt.Println("文件成功关闭！！")
	}
}

05、bufio包和ioutil包

io包：

最基本的包，读写的常规操作。

Reader接口，Writ接口

io.copy()

bufio包： ——————————核心包————————————

  • buffer缓存：将一个字节数组作为缓冲区，内存中。
  • 将io包下的Reader,Write对象进行封装，带缓存的封装，提供读写效率。
  • 将io包下的Reader和Write进一步封装，带缓存的Reader和Write，实现高效的读和写。
    • ReadBytes()
    • ReadString()
    • ReadLine()

ioutil包

  • ReadFile() //一次性读取所有
  • WriteFile() //一次性全部写入
  • ReadDir() //读取目录
  • ReadAll()

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

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func main() {
	/*

	*/
	fmt.Println("-------------------------------1.io/ioutil包-----------------------------------------------------")
	{
		//1.ReadFile() 读取文件中所有的数据
		{
			//	bytes, err := ioutil.ReadFile("./TestDir/test.txt") //ReadFile()
			//	if err != nil {
			//		fmt.Println("文件读取有错！", err.Error())
			//	} else {
			//		fmt.Println("文件读取成功！", string(bytes))
			//	}
		}
		//2.WriteFile() 写出文件中所有的数据
		{
			//bytes=make([]byte,1024,1024)
			//	s1 := "helloWorld_ljk"
			//	bytes := []byte(s1)
			//	err := ioutil.WriteFile("./TestDir/test2.txt", bytes, os.ModePerm) //从文件头位置开始写入
			//	if err != nil {
			//		fmt.Println("文件写入有误！", err.Error())
			//	} else {
			//		fmt.Println("s1字符串成功写入到文件中！！")
			//	}
		}
		//3.复制文件
		{
			//	bytes, err := ioutil.ReadFile("./TestDir/test2.txt")
			//	err = ioutil.WriteFile("./TestDir/test3.txt", bytes, os.ModePerm)
			//	if err != nil {
			//		fmt.Println("文件写入有误！", err.Error())
			//	} else {
			//		fmt.Println("test2已经复制到test3中了！！")
			//	}
		}
		//4.ReadAll()
		{
			//	str := "ljkljkljklkjkljkljljkljljkljljkljkljlkjk"
			//	reader:= strings.NewReader(str)                               //strings类   类似于c#StringBuilder
			//	bytes, err := ioutil.ReadAll(reader)
			//	if err!=nil {
			//		fmt.Println("文件读取有误！",err.Error())
			//	}else {
			//		fmt.Println("文件成功读取",string(bytes))
			//	}
		}
		//5.ReadDir(), 读取一个目录下的子内容：子文件和子目录，但是仅一层
		{
			//	dirName := "./TestDir"
			//	fileInfos, err := ioutil.ReadDir(dirName) //获取到文件信息
			//	if err != nil {
			//		fmt.Println("文件读取有误！", err.Error())
			//	} else {
			//		fmt.Println("文件成功读取,总共读取到的文件数是：", len(fileInfos))
			//		fmt.Println("----------------------------")
			//		for _, v := range fileInfos {
			//			//fmt.Printf("切片中存储的元素的格式为%T\n",v)
			//			fmt.Println(v.Name())
			//			fmt.Printf("是否是一个目录：%t\n", v.IsDir())
			//
			//		}
			//	}
		}
	}
	fmt.Println("-------------------------------2.io/bufio包：执行更高效--------------------------------------------")
	{
		//1. ReadLine() 和 ReadBytes()，一般更倾向于ReadBytes()。ReadLine()一般利用ReadString()代替。
		{
			//file, _ := os.Open("./TestDir/test3.txt")        // file可以被看作io包下Reader和Write的实现。
			//rd := bufio.NewReaderSize(file, 1024)		       // 构建带缓存的reader对象：bufio.Reader
			//fmt.Printf("%T\n",rd)
			//bytes, isPrefix, _ := rd.ReadLine() //一次读一行,        如果是字符用rd.ReadLine()
			//														// 如果是图片数据，用rd.ReadBytes()
			//fmt.Println(string(bytes))
			//fmt.Println(isPrefix) //并不是前缀，可以读取完整，所以返回false
			//						// false能够读取完整，true不能读取完整

			//关闭文件，断开连接
			//err:=file.Close()
			//if err!=nil {
			//	fmt.Println("文件关闭有误！",err.Error())
			//}else {
			//	fmt.Println("文件已经成功关闭！！")
			//}
		}
		//2.ReadString
		{
			file, _ := os.Open("./TestDir/test3.txt") // file可以被看作io包下Reader和Write的实现。
			rd := bufio.NewReaderSize(file, 1024)     // 构建带缓存的reader对象：bufio.Reader

			for {
				readString, err := rd.ReadString('_')
				if err == io.EOF {
					fmt.Println("文件全部读取完毕！")
					break //打断，不然一直循环进行
				} else if err != nil {
					fmt.Println("文件读取有误！", err.Error())
					return
				} else {
					fmt.Println("文件读取成功！内容为：", readString)
				}
			}

			//关闭文件
			err := file.Close()
			if err != nil {
				fmt.Println("文件关闭有误！", err.Error())
			} else {
				fmt.Println("文件已经成功关闭！！")
			}
		}
		//3.Flush()更新
		{

		}
	}
}

文件读写练习：

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

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

func main() {
	fmt.Println("-------------------------练习一：遍历文件夹pro，包含子目录--------------------------------------------")
	{
		//fileProName:="/Users/liangjunke/Desktop/20210729临时文件"
		////遍历文件夹
		//listDir(fileProName)
	}
	fmt.Println("-------------------------练习二：模拟聊天记录：从键盘接收数据------------------------------------------")
	{
		//chatFileName:="./TestDir/weChat.txt"
		////读取键盘输入
		//reader1 := bufio.NewReader(os.Stdin)                //创建一个bufio.Reader对象，读取键盘输入（标准输入）
		////打开要写出到的文件
		//openFile,err := os.OpenFile(chatFileName, os.O_CREATE|os.O_WRONLY|os.O_APPEND, os.ModePerm)
		//if err!=nil {
		//	fmt.Println("文件打开有误！",err.Error())
		//}else {
		//	//写出数据
		//	//1.创建一个bufio.Writer对象，写出数据到weChat.txt文件中
		//	writer1 := bufio.NewWriter(openFile)
		//	//2.延迟关闭
		//	defer openFile.Close()
		//	//3.1写的数据内容：日期
		//	writer1.WriteString("\n")
		//	writer1.WriteString(time.Now().Format("2006-01-02"))
		//	writer1.WriteString("\n")
		//	writer1.Flush() //刷新缓冲区：将缓冲区的数据，写入到目标文件中
		//	//3.2写的数据内容：时间+姓名+"输入的内容"
		//	str:="" //读取到的数据
		//	flag:=true
		//	name:=""
		//	content:=""
		//	for{
		//		//01.写出时间
		//		writer1.WriteString(time.Now().Format("15:04:05"))
		//		writer1.WriteString("\n")
		//		//02.写出"name：内容"
		//		if flag {
		//			name="小明"
		//		}else{
		//			name="小红"
		//		}
		//		flag=!flag
		//		//读取的键盘内容,以"\n"截取
		//		str, _= reader1.ReadString('\n')
		//		//拼接键盘输入的内容信息+姓名
		//		if	str=="over\n"{                             //手动设置退出标识"over"
		//			fmt.Println("程序即将退出！")
		//			//writer1.WriteString("over")
		//			writer1.WriteString(str)
		//			break
		//		}
		//		content=fmt.Sprint(name,":",str)
		//		fmt.Println(content)
		//		writer1.WriteString(content)
		//		//03.进行写入的数据更新
		//		writer1.Flush()
		//	}
		//}
	}
	fmt.Println("-------------------------练习三：断点续传-----------------------------------------------------------")
	{
		/*
				断点续传：
					文件传递：文件复制
					将"./Day12io输入输出/aabbcc.txt"   -----剪切/复制到 -----   "./TestDir/aabbcc.txt"中
				思路：
					1.边复制，边记录复制的总量。
					2.根据数据量，将源文件的光标移动到数据量的位置进行复制，对目标文件的光标移动到数据量的位置进行写入数据。
			        3.临时文件容器，作为参考，使用完后销毁！可读可写。
					内存：临时性数据（程序运行，开辟的缓存），程序关闭会销毁
					文件/硬盘：数据的永久化保存数据。（数据库也可以持久化保存数据）
		*/
		srcFileName := "./Day12io输入输出/head.jpg"  //源文件      可读
		destFileName := "./TestDir/copyHead.jpg" //目标文件    可写
		tempFileName := "./TestDir/tempHead.txt" //临时文件    可读可写
		openFile, _ := os.Open(srcFileName)
		copyDestFile, _ := os.OpenFile(destFileName, os.O_CREATE|os.O_WRONLY, os.ModePerm)
		tempFile, _ := os.OpenFile(tempFileName, os.O_CREATE|os.O_RDWR, os.ModePerm)

		//稍后关闭
		defer openFile.Close()
		defer tempFile.Close()
		defer copyDestFile.Close()

		//1.读取临时文件中的数据，根据seek
		tempFile.Seek(0, 0)
		bs := make([]byte, 100, 100) //只存文件数据量的大小
		n1, err := tempFile.Read(bs)
		fmt.Println("读取的数量是：", n1)
		conStr := string(bs[:n1])
		fmt.Println("临时文件获取到的字符串为：", conStr) //" "字符串
		//countTemp, _ := strconv.Atoi(conStr)//将字符串转成整型int64
		countTemp, _ := strconv.ParseInt(conStr, 10, 64) //将字符串转成整型int
		fmt.Println("转成的整型数据为：", countTemp)
		//fmt.Printf("%T",countTemp) //int64

		//2.设置读/写的偏移量
		openFile.Seek(countTemp, 0)
		copyDestFile.Seek(countTemp, 0)
		data := make([]byte, 512, 512) //内存的缓存数据
		n2 := -1                       //读入的数据量
		n3 := -1                       //写出的数据量
		total := int(countTemp)        //读取的总量
		for {
			//3.将源文件中的数据进行读取
			n2, err = openFile.Read(data) //返回读取的数据量
			if err == io.EOF {
				fmt.Println("文件复制完毕...")
				tempFile.Close()        //关闭缓存文件
				os.Remove(tempFileName) //删除缓存文件
				break
			}
			//4.往目标文件中写入数据
			n3, _ = copyDestFile.Write(data[:n2]) //将数据写入到目标文件

			//5.缓存文件中数据量更改
			total += n3
			tempFile.Seek(0, 0)                       //将复制总量，存储到临时文件中,覆盖掉原有的数据
			tempFile.WriteString(strconv.Itoa(total)) //将数值转成字符串

			//假装断电，出现异常
			//if total>12 {
			//	panic("出现断电情况了！！！！")
			//}
		}

	}
}

//利用递归，遍历文件夹
func listDir(dirName string) {
	//遍历当前文件夹名称下的文件目录
	fileInfos, err := ioutil.ReadDir(dirName)
	if err != nil {
		fmt.Println("文件读取有误", err.Error())
	} else {
		//fmt.Println(len(fileInfos))
		for k, fileInfo := range fileInfos {
			fileName := path.Join(dirName, fileInfo.Name())
			fmt.Println("第", k+1, "个文件的名称为：", fileName)
			//如果是文件夹的话，继续遍历
			if fileInfo.IsDir() { //递归遍历的核心：考虑是什么时候跳出循环！！！！
				listDir(fileName)
			}
		}
	}
}

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
三维数字孪生、虚拟仿真
三维平台数据展示、VR沉浸式开发、党建360/720全景开发

联系QQ:2583493258

很惭愧

只做了一点微小的工作
谢谢大家