io包的使用

通过Buffer实现文件复制

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
func copyFile(src, dst string) error {
	// 只读方式打开源文件
	srcFile, err := os.Open(src)
	if err != nil {
		return err
	}
	// 延迟关闭源文件
	defer srcFile.Close()

	// 创建文件，并写入模式打开
	dstFile, err := os.Create(dst)
	if err != nil {
		return err
	}
	// 延迟关闭目标文件
	defer dstFile.Close()

	// 定义一个1024字节的buffer切片用来临时存放数据
	buffer := make([]byte, 1024)

	// 遍历读取源文件并存储到buffer中。
	for {
		n, err := srcFile.Read(buffer)
		// 判断读取中的错误信息
		if err != nil {
			// 如果是文件读取完毕的错误就跳出循环
			if err == io.EOF {
				break
			}
			// 如果是其他错误就return返回错误信息
			return err
		}

		// 将buffer中的所有内容写入到目标文件中
		n, err = dstFile.Write(buffer[:n])
		// 如果出现错误即返回错误信息
		if err != nil {
			return err
		}
	}
	return err
}

func main() {
	err := copyFile("./filepath.go","aaa")
	fmt.Println(err)
}

io.Copy和io.CopyBuffer实现文件复制

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
func copyFile(src, dst string) error {
	// 只读方式打开源文件
	srcFile, err := os.Open(src)
	if err != nil {
		return err
	}
	// 延迟关闭源文件
	defer srcFile.Close()

	// 创建文件，并写入模式打开
	dstFile, err := os.Create(dst)
	if err != nil {
		return err
	}
	// 延迟关闭目标文件
	defer dstFile.Close()

	// 通过io.Copy将一个流复制到另外一个流中，替代前面的for循环写入文件流
	_, err = io.Copy(dstFile, srcFile)
	return err

	//// 创建一个字节切片，通过copyBuffer复制文件
	//buffer := make([]byte, 1024)
	//_, err = io.CopyBuffer(dstFile, srcFile, buffer)
	//return err
}

func main() {
	err := copyFile("./filepath.go", "bbb")
	fmt.Println(err)
}

io.MultiWrite使用

MultiWrite将一个信息输出到多个地方中

1
2
3
4
5
6
7
8
9
10
11
func main() {
	// 创建两个文件
	logFile1, _ := os.Create("1.log")
	defer logFile1.Close()
	logFile2, _ := os.Create("2.log")
	defer logFile2.Close()

	// 将信息分别写入到logfile1、logfile2和标准输出中
	writer := io.MultiWriter(logFile1, logFile2, os.Stdout)
	writer.Write([]byte("hello world"))
}

运行结果

1
2
3
4
5
6
7
8
$ go run filepath.go 
hello world% 

$ cat 1.log 
hello world%

$ cat 2.log 
hello world%

io.MultiReader使用

MultiReader将多个文件一起读取进行处理，当所有文件都读出完毕后才会返回io.EOF

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func main() {
	// 创建两个文件
	logFile1, _ := os.Open("1.log") // 文件内容：12345
	defer logFile1.Close()
	logFile2, _ := os.Open("2.log") // 文件内容：abcde
	defer logFile2.Close()

	// 以此读取文件中的内容
	reader := io.MultiReader(logFile1, logFile2)
	buffer := make([]byte, 4)

	for {
		n, err := reader.Read(buffer)
		if err != nil {
			break
		}
		fmt.Println(n, err, string(buffer[:n]))
	}
}

运行结果

1
2
3
4
5
$ go run filepath.go
4 <nil> 1234
1 <nil> 5
4 <nil> abcd
1 <nil> e

ioutil包的使用

ioutil.ReadAll

传递一个文件打开对象读取文件中的所有数据，返回读取的数据和遇到的错误。如果读取成功，则err返回nil，而不是EOF。

1
2
3
4
5
6
7
8
9
10
11
func main() {
	f, err := os.Open("./filepath.go")
	if err != nil {
		fmt.Println("open file filed：", err)
	}
	defer f.Close()

	// 读取文件打开对象中的所有内容
	ctx, _ := ioutil.ReadAll(f)
	fmt.Println(string(ctx))
}

ioutil.ReadFile

直接传递一个文件路径读取文件中的所有数据，返回读取的内容和遇到的错误。

1
2
3
4
func main() {
   ctx,err := ioutil.ReadFile("./filepath.go")
   fmt.Println(string(ctx),err)
}

ioutil.WriteFile

通过ioutil.WriteFile向文件写入数据，如果之前有数据则会将原来的进行清空，如果文件不存在则会以指定的权限创建该文件。

1
2
3
func main() {
   ioutil.WriteFile("write.txt",[]byte("我爱Go语言"),os.ModePerm)
}

ioutil.ReadDir

读取指定目录中的所有目录和文件（不包括子目录）。返回读取的文件信息列表和遇到的错误，列表是经过排序的。

1
2
3
4
5
6
7
8
9
10
11
func main() {
   files,err := ioutil.ReadDir("/tmp")
   fmt.Println(err)
   for _,file := range files{
      if file.IsDir(){
         fmt.Println("目录：",file.Name(),file.ModTime().Format("2006-01-02 15:03:04"))
      }else {
         fmt.Println("文件：",file.Name(),file.Size(),file.ModTime().Format("2006-01-02 15:03:04"))
      }
   }
}

ioutil.TempDir

在当前目录下，创建一个以test为前缀的临时文件夹，并返回文件夹路径

1
2
3
4
5
func main() {
	//在当前目录下，创建一个以test为前缀的临时文件夹，并返回文件夹路径
	dir,err := ioutil.TempDir("./","test")
	fmt.Println(dir,err)
}

ioutil.TempFile

在当前目录下，创建一个以test为前缀的文件，并以读写模式打开文件，并返回os.File指针

1
2
3
4
5
6
func main() {
   // 在当前目录下，创建一个以test为前缀的文件，并以读写模式打开文件，并返回os.File指针
   file,_ := ioutil.TempFile("./","test")
   file.WriteString("写入字符串")
   file.Close()
}