ToB企服应用市场:ToB评测及商务社交产业平台

标题: go语言的成神之路-筑基篇-对文件的操纵 [打印本页]

---

作者: 王柳    时间: 2024-12-2 05:31
标题: go语言的成神之路-筑基篇-对文件的操纵

目次

一、对文件的读写
Reader 接口
 Writer接口
copy接口
bufio的使用
ioutil库 
二、cat命令
三、包
1. 包的声明
2. 导入包
3. 包的可见性
4. 包的初始化
5. 标准库包
6. 第三方包
 7. 包的构造
8. 包的别名
9. 包的路径
10. 包的版本管理
四、go mod
1. 初始化一个新的模块
2. 依赖管理
3. 查看依赖关系
4. 下载依赖
5. 清理未使用的依赖
6. 更换依赖
7. 版本管理
8. 私有模块
9. 构建和测试
10. 示例
总结

---

一、对文件的读写

在 Go 语言中，io 包提供了根本的接口，用于 I/O 原语。它的主要目标是将这些原语抽象化，使得它们在不同的实现中可以通用。
Reader 接口

以下是一个对文件中内容读取的一个示例：

1. package main
4. import (
5.         "fmt"
6.         "io"
7.         "os"
8. )
10. func main() {
11.         // 打开文件 text.txt，如果打开失败，打印错误信息并返回
12.         file, err := os.Open("./text.txt")
13.         if err != nil {
14.                 fmt.Println(err)
15.                 return
16.         }
17.         // 确保文件在函数结束时关闭
18.         defer file.Close()
19.         // 定义一个长度为 128 的字节数组作为缓冲区
20.         var buf [128]byte
21.         // 存储文件内容的字节切片
22.         var content []byte
23.         for {
24.                 // 从文件中读取数据到缓冲区，n 表示读取的字节数
25.                 n, err := file.Read(buf[:])
26.                 // 如果到达文件末尾，跳出循环
27.                 if err == io.EOF {
28.                         break
29.                 }
30.                 // 如果读取过程中出现错误，打印错误信息并返回
31.                 if err != nil {
32.                         fmt.Println(err)
33.                         return
34.                 }
35.                 // 将读取到的数据添加到 content 切片中
36.                 content = append(content, buf[:n]...)
37.         }
38.         // 将字节切片转换为字符串并打印
39.         fmt.Println(string(content))
40. }

复制代码

 

 Writer接口

以下是写入文件的操纵：
注：每次写入的时候原文件中的内容都会被覆盖。

1. // Writer接口的定义和实现
2. package main
5. import (
6.         "fmt"
7.         "os"
8. )
10. func main() {
11.         // 打开文件 text.txt，如果文件不存在则创建，如果文件存在则清空内容
12.         file, err := os.Create("./text2.txt")
13.         if err != nil {
14.                 fmt.Println(err)
15.                 return
16.         }
17.         // 确保文件在函数结束时关闭
18.         defer file.Close()
20.         // 定义一个字符串
21.         str := "Hello,World!"
22.         // 将字符串转换为字节切片
23.         data := []byte(str)
24.         // 将字节切片写入文件
25.         _, err = file.Write(data)
26.         // 如果写入过程中出现错误，打印错误信息并返回
27.         if err != nil {
28.                 fmt.Println(err)
29.                 return
30.         }
31. }

复制代码

写入一个 Hello,World!
 

写入一个”你好世界！“

可以看出原来文件中的文本被更换了。
copy接口

以下是复制文件的操纵：

1. // io.Copy的使用
2. package main
5. import (
6.         "fmt"
7.         "io"
8.         "os"
9. )
11. func main() {
12.         // 打开文件 text.txt，如果文件不存在则创建，如果文件存在则清空内容
13.         begin, err := os.Open("./text2.txt")
14.         if err != nil {
15.                 fmt.Println(err)
16.                 return
17.         }
18.         // 确保文件在函数结束时关闭
19.         defer begin.Close()
21.         // 打开文件 text2.txt，如果文件不存在则创建，如果文件存在则清空内容
22.         end, err := os.Create("./text3.txt")
23.         if err != nil {
24.                 fmt.Println(err)
25.                 return
26.         }
27.         // 确保文件在函数结束时关闭
28.         defer end.Close()
30.         // 将文件 text.txt 的内容复制到文件 text2.txt 中
31.         _, err = io.Copy(end, begin)
32.         // 如果复制过程中出现错误，打印错误信息并返回
33.         if err != nil {
34.                 fmt.Println(err)
35.                 return
36.         }
37. }

复制代码

 begin中的内容会自动覆盖end中的内容。

bufio的使用

常见的方法如下：

 

1. // bufio的使用
2. package main
5. import (
6.         "bufio"
7.         "fmt"
8.         "io"
9.         "os"
10. )
12. func wr() {
13.         // 参数2 是文件的打开方式，os.O_CREATE|os.O_WRONLY|os.O_APPEND 表示创建文件并以写入模式打开，文件不存在则创建，文件存在则在文件末尾追加内容
14.         // 参数3 是文件的权限，0666 表示文件所有者、组和其他用户都有读写权限
15.         // w写 r读 a追加 x执行
16.         file, err := os.OpenFile("./text.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
17.         if err != nil {
18.                 fmt.Println(err)
19.                 return
20.         }
21.         defer file.Close()
23.         // 获取writer对象
24.         writer := bufio.NewWriter(file)
25.         writer.WriteString("hello bufio")
27.         // 刷新缓冲区
28.         writer.Flush()
29. }
31. func rd() {
32.         file, err := os.Open("./text.txt")
33.         if err != nil {
34.                 fmt.Println(err)
35.                 return
36.         }
37.         defer file.Close()
39.         reader := bufio.NewReader(file)
41.         for {
42.                 line, _, err := reader.ReadLine()
43.                 if err != io.EOF {
44.                         fmt.Println(err)
45.                         break
46.                 }
47.                 if err != nil {
48.                         fmt.Println(err)
49.                         return
50.                 }
51.                 fmt.Println(string(line))
52.         }
53. }
55. func main() {
56.         wr()
57. }

复制代码

以这种方式举行读写不会覆盖原来的文件 

读取文本文件的时候是按行读取的

ioutil库 

1. // ioutil的使用
2. package main
5. import (
6.         "fmt"
7.         "io/ioutil"
8. )
10. func wr() {
11.         err := ioutil.WriteFile("./text.txt", []byte("hello ioutil"), 0666)
12.         if err != nil {
13.                 fmt.Println(err)
14.                 return
15.         }
16. }
18. func re() {
19.         content, err := ioutil.ReadFile("./text.txt")
20.         if err != nil {
21.                 fmt.Println(err)
22.                 return
23.         }
24.         fmt.Println(string(content))
25. }
26. func main() {
27.         wr()
28.         re()
29. }

复制代码

这个工具库相对于其他的工具库更为简朴。相应的函数已经被很好的打包完成了。 

二、cat命令

1. package main
4. import (
5.         "bufio"
6.         "flag"
7.         "fmt"
8.         "io"
9.         "os"
10. )
12. // cat 函数接收一个 bufio.Reader 指针作为输入，用于读取文件或标准输入的内容
13. func cat(r *bufio.Reader) {
14.         // 开始一个无限循环，用于逐行读取数据
15.         for {
16.                 // 从 bufio.Reader 中读取一行数据，直到遇到换行符 '\n'，存储在 buf 中，并将可能的错误存储在 err 中
17.                 buf, err := r.ReadBytes('\n')
18.                 // 如果读取到文件末尾，打印错误信息并退出循环
19.                 if err == io.EOF {
20.                         fmt.Println(err)
21.                         break
22.                 }
23.                 // 将读取到的一行数据输出到标准输出
24.                 fmt.Fprintf(os.Stdout, "%s", buf)
25.         }
26. }
28. func main() {
29.         // 解析命令行参数
30.         flag.Parse()
31.         if flag.NArg() == 0 {
32.                 // 从标准输入读取数据并输出到标准输出
33.                 cat(bufio.NewReader(os.Stdin))
34.         }
35.         // 依次处理每个文件
36.         for i := 0; i < flag.NArg(); i++ {
37.                 // 打开文件
38.                 f, err := os.Open(flag.Arg(i))
39.                 if err!= nil {
40.                         fmt.Fprintf(os.Stderr, "cat: %s: %s\n", flag.Arg(i), err)
41.                         continue
42.                 }
43.                 // 读取文件内容并输出到标准输出
44.                 cat(bufio.NewReader(f))
45.                 // 关闭文件
46.                 f.Close()
47.         }
48. }

复制代码

上述代码中，cat 函数的主要功能是从 bufio.Reader 中逐行读取数据并输出到标准输出。在 for 循环中，使用 r.ReadBytes('\n') 方法读取一行数据，当遇到文件结束符 io.EOF 时，打印错误信息并退出循环，否则将读取的数据输出到标准输出。在 main 函数中，首先解析命令行参数，若没有命令行参数，则从标准输入读取数据；如有命令行参数，则依次打开文件，调用 cat 函数读取文件内容并输出，末了关闭文件。
注：在 cat 函数中，当遇到 io.EOF 时，打印错误信息可能不是最佳做法，由于 EOF 不是错误，而是文件结束的标记。可以思量修改为不打印错误信息，仅退出循环。

   如果文件中有内容就会打印出文件中的内容。
  如果直接执行go run mian.go会打印输出用户输入的内容。 
  三、包

在 Go 语言中，包（package）是构造代码的一种方式，它可以将相干的函数、变量和类型组合在一起，以便于代码的管理、复用和维护。以下是关于 Go 语言包的一些紧张信息：
1. 包的声明

在 Go 文件的开头，使用 package 关键字来声明包的名称。

1. package main

复制代码

• package main
   是一个特别的包，它体现该文件是一个可执行程序的入口点。
  
• 对于其他包，可以使用其他名称，如 package utils 或 package math。
  

2. 导入包

使用 import 语句来导入其他包。

1. import (
2.     "fmt"
3.     "os"
4.     "github.com/yourusername/yourpackage"
5. )

复制代码

• 导入标准库中的包，如 fmt 和 os。
  
• 导入第三方包，如 github.com/yourusername/yourpackage。
  

3. 包的可见性

• 在 Go 中，标识符（函数、变量、类型）的名称首字母大小写决定了其可见性：
  
• 首字母大写的标识符是导出的，可以被其他包访问。
  
• 首字母小写的标识符是未导出的，只能在当前包内使用。
  

1. package mypackage
3. // 导出的函数
4. func ExportedFunction() {
5. }
7. // 未导出的函数
8. func unexportedFunction() {
9. }

复制代码

 在另一个包中，可以调用 mypackage.ExportedFunction()，但不能调用 mypackage.unexportedFunction()。
4. 包的初始化

包可以包含一个 init 函数，它会在包被导入时自动执行。

1. package mypackage
3. import "fmt"
5. func init() {
6.     fmt.Println("Initializing mypackage")
7. }

复制代码

• 一个包可以有多个 init 函数，它们会按照声明的顺序执行。
  

5. 标准库包

Go 标准库包含了很多有效的包，例如：

• fmt：格式化输入和输出。
  
• os：提供操纵系统功能，如文件操纵、环境变量等。
  
• io：提供根本的 I/O 操纵接口。
  
• bufio：提供缓冲的 I/O 操纵。
  
• net：提供网络编程功能。
  
• sync：提供同步原语，如互斥锁、读写锁等。
  

6. 第三方包

可以使用 go get 命令来获取第三方包
比如在gin框架学习中引用的gin包

1. import "github.com/gin-gonic/gin"

复制代码

 7. 包的构造

• 通常，一个目次对应一个包。
  
• 包的名称应该与目次名称雷同，除非使用 package main
  。
  

8. 包的别名

可以为导入的包设置别名。

1. import (
2.     f "fmt"
3. )

复制代码

• 这里将 fmt 包的别名设置为 f，可以使用 f.Println() 来调用 fmt.Println()。
  

9. 包的路径

• 包的路径是其在文件系统或远程仓库中的位置。
  
• 对于标准库，路径是 std 包的一部分，如 fmt 包的路径是 std/fmt。
  
• 对于第三方包，路径是其在远程仓库中的位置，如 github.com/gin-gonic/gin。
  

10. 包的版本管理

• Go 1.11 及以后的版本支持模块（module），可以使用 go.mod 文件来管理依赖的版本。
  
• 例如，创建一个 go.mod 文件：
  

1. module mymodule
3. go 1.14
5. require github.com/gin-gonic/gin v1.7.4

复制代码

这将确保使用 github.com/gin-gonic/gin 的 v1.7.4 版本。
以下是一个完备的示例，展示了包的使用：

1. package main
2. import (        "fmt"        "mypackage")func main() {        // 使用标准库的 fmt 包        fmt.Println("Hello, World!")        // 使用自界说包 mypackage        mypackage.ExportedFunction()}

复制代码

在这个示例中：

• 导入了 fmt 标准库包和 mypackage 自界说包。
  
• 在 main 函数中，调用了 fmt.Println() 和 mypackage.ExportedFunction()。
  

通过合理使用包，可以将代码构造得更加清楚、易于维护和复用，同时利用 Go 语言强大的标准库和丰富的第三方库资源。
四、go mod

go mod 是 Go 语言从 1.11 版本开始引入的模块管理工具，它答应开发者更好地管理项目标依赖关系，而不再依赖于 GOPATH 环境变量。
1. 初始化一个新的模块

使用 go mod init 命令来初始化一个新的模块。例如：

1. go mod init example.com/myproject

复制代码

这将创建一个 go.mod 文件，内容如下：

1. module example.com/myproject
3. go 1.14

复制代码

• module 后面的部分是模块的名称，通常是一个唯一的标识符，如域名加项目名。
  
• go 后面的部分是 Go 语言的版本。
  

2. 依赖管理

当你导入一个新的包时，go mod 会自动更新 go.mod 文件。例如：

1. package main
2. import (        "github.com/gin-gonic/gin")func main() {        gin.Default()}

复制代码

运行 go build 或 go run 时，go mod 会自动更新 go.mod 文件，添加所需的依赖：

1. module example.com/myproject
3. go 1.14
4. require github.com/gin-gonic/gin v1.7.4

复制代码

3. 查看依赖关系

使用 go list -m all
 命令可以查看所有的依赖关系：

1. go list -m all

复制代码

4. 下载依赖

使用 go mod download
 命令可以下载所有的依赖：

1. go mod download

复制代码

5. 清理未使用的依赖

使用 go mod tidy
 命令可以清理未使用的依赖：

1. go mod tidy

复制代码

6. 更换依赖

如果必要更换一个依赖，可以在 go.mod 文件中使用 replace 指令。例如：

1. replace github.com/oldpackage => github.com/newpackage v1.2.3

复制代码

7. 版本管理

• go mod 会自动选择依赖的最新版本，但可以使用 require 指令指定版本。例如：
  

1. require github.com/gin-gonic/gin v1.7.4

复制代码

• 可以使用 @ 符号指定特定的版本，如 v1.7.4、v1.7.4+incompatible 或 v1.7.4-pre。
  

8. 私有模块

对于私有模块，可以使用 replace 指令或环境变量 GOPRIVATE 来管理。例如：

1. replace private.com/myproject => /path/to/local/project

复制代码

9. 构建和测试

• go build 和 go test 命令会自动使用 go.mod 中的依赖信息。
  

10. 示例

以下是一个完备的 go.mod 文件示例：

1. module example.com/myproject
3. go 1.14
4. require (    github.com/gin-gonic/gin v1.7.4    github.com/somepackage v1.2.3)replace github.com/oldpackage => github.com/newpackage v1.2.3

复制代码

总结

• go mod init 初始化模块。
  
• go mod tidy
   清理未使用的依赖。
  
• go mod download
   下载依赖。
  
• go mod edit 编辑 go.mod 文件。
  
• go list -m all
   查看依赖。
  

使用 go mod 可以让 Go 项目标依赖管理更加灵活和方便，制止了 GOPATH 的限制，提高了项目标可维护性和可移植性。




免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4